Transcripciones
1. HABILIDAD de INTRO: Hola a todos y bienvenidos al curso
de
desarrollo de juegos móviles de Unity. Como puedes ver, aprenderemos a través este juego de ejemplo de Space Shooter Se crea con el
nuevo sistema de entrada. Pero antes de entrar en detalles, ten en cuenta que con este curso también
obtendrás algunos conocimientos
generales y técnicas
que podrás aplicar a otro tipo de juegos móviles. Por ejemplo, aprenderemos a
implementar tres tipos de anuncios. Un ejemplo son los anuncios recompensados,
cuando un jugador pierde el juego, puede ver un
anuncio
que no se puede omitir y seguir jugando. Otro ejemplo son los anuncios saltables que pueden aparecer entre niveles. Y controlamos la frecuencia con la
que aparecerán. También aprenderemos a enviar notificaciones para dispositivos
Android e iOS. Hay una selección de niveles con un sencillo sistema de desbloqueo. A medida
que el jugador gana un nivel, el siguiente se desbloqueará. Para cada nivel, hacemos un seguimiento de los puntajes y puntuaciones altas. Aprendemos a
crear una pantalla de carga, que por supuesto puedes
usar en cualquier tipo de juego. Todos los niveles tienen fondos de desplazamiento y reproductores que pueden generar
diferentes tipos de enemigos. El jugador puede
recoger algunos potenciadores como escudo y mejoras de
tiro. Es posible perder la mejora de tiro
al recibir daño. No sería divertido
sin alguna pelea de jefes. Por lo que implementamos Boss
al final de un nivel. La optimización es una parte
importante. Entonces aprenderemos un poco
sobre los objetos Scriptable, cómo usar Profiler para
detectar posibles problemas, Y usamos el nuevo sistema de sondeo de
objetos de Unity. Aprendemos a
probar juegos en teléfonos, tanto Android como iPhone. Al final, llenamos todos los
formularios en Google Play y pasamos por
el proceso de publicación. Hay mucho
contenido que no
logré mencionar en
esta breve introducción. Pero si encuentras algo
de esto interesante, inscribirte hoy y
verte en el curso.
2. Crea un proyecto y elige configuraciones: Hola a todos. Bienvenido al curso de tirador
espacial móvil. Para comenzar con el curso, vamos a elegir la configuración óptima
del proyecto. Así que primero abre tu Unity
Hub y ve a instancia. Aquí puedes encontrar todas las versiones
instaladas de Unity en tu PC. Utilizaré la unidad en
versión 2022 para este curso. Entonces, la mejor manera de
seguir este curso es
usar cualquier versión 2022 o más reciente. Además, asegúrate de tener instalados los
módulos
Android o iOS. Para instalar módulos para la versión de
Unity es necesario hacer clic en el
botón Configuración y agregar módulos, luego elegir Android
o iOS o ambos, y continuar con
la instalación. Como pueden ver, ya tengo módulos para la versión 2022. Ahora ve a proyectos.
Nuevos proyectos. Primero, seleccione la versión de Unity. Entonces puedes ver algunas plantillas de
proyectos. Se puede ver que hay plantillas móviles 2D
y 3D. Estas plantillas vienen
con un montón de paquetes que necesitas
para los juegos móviles, pero muchas veces
no los vas a usar todos. Entonces, en cambio, prefiero
crear proyectos básicos 2D o 3D y luego
ingresar manualmente paquetes que
estoy seguro que usaré. Este es un juego 2D. Así que selecciona la plantilla básica 2D y elige un nombre
y una ubicación. Entonces podemos crear un proyecto. Deberías ver
algo como esto. Lo primero que tenemos que
hacer es cambiar la plataforma de destino
a Android o iOS. Así que ve a Configuración de compilación de archivos. Por defecto, la plataforma de destino es Windows, Mac y Linux. Este es un juego para móviles, así que seleccionaré Android y haré
clic en Switch Platform. Espera un momento a que
la unidad haga el trabajo. Bonito. Esta es una configuración básica del proyecto. En el siguiente video, exploraremos una característica muy útil
Device Simulator. Nos vemos en la próxima conferencia.
3. Simulador de dispositivos: Hola a todos. Después de la configuración básica del proyecto, exploremos
otra característica interesante que nos ayudará a
desarrollar un juego móvil. Es un simulador de dispositivos. Para abrirlo, selecciona
la ventana del juego, expande la lista, y aquí puedes cambiar a la ventana del
simulador. También
lo puedes encontrar si vas a Window general y simulador de
dispositivo, el simulador te mostrará
cómo se verá el juego en un determinado dispositivo y podrás probar la jugabilidad con el mouse. Si expande la lista de dispositivos, puede ver un par de
dispositivos que puede seleccionar. Te recomiendo que
instales dispositivos adicionales. Te dará muchas más
opciones para elegir. Por supuesto, se puede jugar
con algunos ajustes. Puede escalar la vista
o elegir el ajuste a la pantalla. Se puede girar la pantalla. Y esta zona segura es para la
navegación de elementos de la interfaz de usuario. Siéntase libre de elegir
el dispositivo que desee. Iré con Samsung
Galaxy S 105 G. Ahora, cuando todo esté en su lugar, en el siguiente video, importaremos activos del proyecto
y rebanaremos algunos sprites. Nos vemos ahí.
4. Editor de Sprite y Importación y Sprite: Hola a todos. Continuemos con el curso
e ingresemos algunos sprites. La organización sobre el
espacio de trabajo es muy importante. Así que vamos a crear una nueva
carpeta para sprites. Asegúrese de seleccionar
la carpeta de activos. Haga clic con el botón derecho en Crear carpeta. Yo lo llamaré sprites. Ábrela. Ahora, puedes descargar este
precio de los recursos. Usa algunas herramientas como cuando
hay dos archivos de extracción. Como puedes ver, los sprites
están organizados en carpetas. Selecciónalos y
arrástralos al proyecto. Siéntase libre de explorar sprites. Por ahora, seleccionemos
el sprite del jugador. En la ventana del inspector, podemos ver los ajustes de sprites. Expandamos esta
parte en la parte inferior para obtener una mejor vista previa
del sprite seleccionado. Para la mayoría de los sprites que codifican estas configuraciones predeterminadas son buenas. No necesitamos
cambiar nada. Podemos seleccionar la vista de escena y tocar el
sprite en el juego. Sin embargo, algunos sprites
necesitan cambios, por ejemplo, en la carpeta de enemigos, tenemos dos enemigos
en un sprite. Necesitamos una manera de cortar este
sprite en dos partes. Así que selecciona el sprite, cambia el modo sprite de
sencillo a múltiple. Después ve al
Editor de Sprite y aplica los cambios. En el Editor de Sprite. En este caso, los sprites pueden parecer un poco borrosos,
pero no te preocupes, eso es porque están
escalados para previsualización, porque es un juego para móviles. Por lo general, las dimensiones son pequeñas como sea posible para optimizar
el rendimiento. Para cortar, los sprites van a rebanar, elegir cuadrícula por tamaño de celda. Sé que el tamaño de una celda para
este sprite es de 128 píxeles. ¿Cómo sé que
en este proyecto, cada propagación tiene dimensiones
incluidas en el nombre, por ejemplo, este sprite se
llama enemigos 128. Entonces, si haces tus propios sprites
o contratas a algunos artistas, asegúrate de conocer
las dimensiones precisas del sprite y la cuadrícula. A mí me gusta poner
dimensiones en los nombres. Bien, establezca el tamaño de píxel en 128
para x e y. Haga clic en Rebanar. Se pueden ver dos celdas separadas, cada una con un enemigo. Aplicar cambios y salir
del Editor de Sprite. Podemos eliminar el objeto
anterior. Ahora, cuando expandas el sprite, podremos usar cada
enemigo por separado. Otro ejemplo es
este efecto de explosión. Tenemos que cortarlo. También en el Inspector, se
puede leer el
tamaño completo del sprite, que a veces es
importante conocer. Ahora, repita el proceso. El tamaño de las celdas es el mismo. Este efecto de explosión
se utilizará posteriormente para la animación. Aquí viene tu primer
mini desafío. Puedes pasar por otros
sprites que necesiten rebanar. Slice, solo se integran los
sprites que tienen múltiples objetos
colocados. No necesitas los sprites simples de
rebanada. Después de terminar, Nos
vemos en la siguiente conferencia.
6. Nueva configuración de sistema de entrada: Hola a todos. En este video, entramos un nuevo sistema de entrada y
ajustamos algunos ajustes. Lo primero que
tenemos que hacer es ir
a Window Package Manager. Por defecto, deberías
ver todos los paquetes que ya están en
el proyecto para
mostrarte todos los
paquetes disponibles de Unity ir a paquetes y seleccionar
Unity Registry. Desde el Registro de Unity, podemos buscar
el sistema de entrada, seleccionarlo y dar clic
en el botón Instalar. Para finalizar el
proceso de instalación
se reiniciará la unidad . Después de la muerte. Si vas a paquetes
en el proyecto, puedes ver que tenemos el nuevo
sistema de entrada en la lista. Salir del administrador de paquetes para asegurarnos de que está instalado
correctamente, podemos ir a Editar configuración
del proyecto, seleccionar el reproductor y expandir otros ajustes.
Desplácese hacia abajo. Estamos buscando manejo
activo de insumos. Se puede ver el sistema antiguo, el nuevo sistema,
y ambas opciones. Asegúrese de que el nuevo
sistema o ambos estén seleccionados. Seleccionaré ambos. Bonito. Tenemos una cosa más que hacer para simular el tacto en la
pantalla con el ratón. Tenemos que ir a Análisis
de Ventanas. Entrada, depurador. Vaya a opciones y habilite, simule la
entrada táctil desde el mouse o el lápiz. Ahora, podemos usar el ratón
con el simulador, y eso es todo para los preparativos
básicos. Nos vemos en la próxima conferencia.
7. Fundamentos de tacto mejorados: Hola a todos. Exploremos el
nuevo sistema de entrada. El nuevo sistema de entrada es súper flexible y se puede
utilizar de muchas maneras. Desde Unity, podemos ver
que el soporte táctil se divide en el
bajo nivel de soporte en la clase de pantalla táctil y un soporte de alto nivel en
la clase Touch mejorada. La clase Touch mejorada tiene
más opciones y el control está diseñado para tirar de la función de actualización y
unity recomienda usarlo. Entonces, para este proyecto, usaremos la clase de
estadísticas mejoradas para controlar la entrada. Una vez que conoces la sintaxis
y la teoría detrás de esto, control
táctil
se vuelve realmente fácil. Primero, necesitamos
habilitar un toque mejorado. Por lo general lo hacemos en su
propia función habilitada. Además, tenemos que desactivarlo en su propia función deshabilitada
es bastante simple sintaxis. Entonces el toque mejorado proporciona acceso a la información a
lo largo de dos dimensiones, con el dedo y por el tacto. Entonces, cómo definimos un
dedo y un toque, cada dedo se define como el enésimo contacto
en una pantalla táctil. Por ejemplo, tocamos la
pantalla táctil con un dedo, no
importa cuál
sea el primer contacto. Y cierta información se
almacena en el dedo cero. Si tocamos la pantalla
con dos dedos, información se almacena
para ambos dedos. Dedos cero y
dedo uno variables. Los dedos que están
tocando la pantalla se almacenan en la matriz de dedos de
actividad. Entonces, para obtener la información, utilizamos la siguiente sintaxis. Toca esos dedos activos. Dado que se trata de una matriz para obtener la información del primer dedo que está tocando la pantalla, usamos el índice cero para obtener
el segundo dedo activo. Si existe, usamos el
índice uno y así sucesivamente. Bien, hay una matriz
más que usamos, y esa es la matriz de dedos. Observe que no hay
palabra clave activa. Es la matriz de
todos los dedos posibles. Pueden tocar la
pantalla al mismo tiempo. Por lo general, esta matriz tiene diez
elementos para diez dedos, pero puede estar por todas partes dependiendo del hardware
y el software. Para usar esta matriz, debemos verificar si hay una condición
adicional. Tenemos que verificar si el dedo
de esta matriz está activo. Si eso es cierto, entonces podemos usarlo. En el siguiente ejemplo, demostraré
la diferencia entre estas dos matrices. Esto es realmente importante. Así que tómate tu tiempo
para entender esto. Digamos que tocamos la
pantalla con dos dedos. Esto representará la matriz
activa de dedos, y esto representará
la matriz de dedos. Ahora necesitamos obtener algunos datos, tal vez su posición
o algo más. Digamos que este es
el primer dedo que tocó la pantalla. Por lo que tiene índice cero
para ambas matrices. Eso significa que este
dedo tiene índice uno. Ahora bien, si por ejemplo
levantamos un dedo con índice cero en la matriz de
dedos activos, el dedo que tenía índice uno se convierte en el dedo
con índice cero. Sin embargo, en los dedos, matriz, los índices permanecieron iguales. Pero este dedo es cero, ya no
está activo. Cuando levantamos todos los dedos de la pantalla, todo se restablece. Para concluir, es
importante de qué matriz y de qué
índice obtenemos datos. Ahora, echemos un
vistazo al toque. Cuando tocas la pantalla
con una unidad de dedo, ellos almacenarán cierta información
en la estructura táctil. La estructura es más fácil de
explicar usando las fases. Cada toque ha comenzado
y terminado las fases. La fase inicial ocurre en el primer fotograma cuando un
dedo toca la pantalla. La fase terminada ocurre cuando dejamos el
dedo de la pantalla. Entre esas dos fases, también
podemos tenerlas movidas
y fases estacionarias. Por supuesto, la fase es cuando movemos el dedo
sobre la pantalla táctil. Y la fase estacionaria es cuando no
movemos nuestro dedo. Hay una fase más
llamada cancelada. Ocurre cuando
tenemos un toque y nos alejamos el enfoque
de la aplicación. Alejarse o perder el enfoque ocurre cuando minimizamos
la aplicación. Estas fases son muy útiles y
las usaremos en el curso. Además, hay una
matriz de toques activos que podemos usar para obtener toques activos similares
a la matriz de dedos. Bien, eso fue un poco de teoría sobre la clase Touch
mejorada. Usémoslo en la siguiente conferencia para crear movimiento de jugador.
8. Mover Jugador con Touch: Hola a todos. En esta conferencia,
aprenderemos a mover el reproductor
utilizando el nuevo sistema de entrada
y controles táctiles. Para comenzar, vaya a la carpeta de
scripts, cree un script C-sharp. Yo lo llamaré
controles de jugador. Ábrela. El primer paso es agregar el espacio de nombres
tocado mejorado del sistema de entrada. Como dijimos en la conferencia
anterior, necesitamos habilitar
mejorado tocado. Lo hacemos en su
propia función enable. Recuerda, esa
función se llama cada vez que el objeto está habilitado, luego lo deshabilitamos en su
propia función deshabilitada. Eso sucede cuando el
objeto se desactiva, destruye y así sucesivamente. A continuación, necesitamos recibir
entradas en la función de actualización. Para este juego, solo
necesitamos un dedo. La mejor opción es
recibir entradas solo desde el primer dedo
que toca la pantalla. No importa
cuál físicamente, solo que sea el primero. Entonces en la declaración if, escribimos
los dedos de punto táctil con índice cero. El índice cero cumple con
el primer dedo, notarás un error. Esto se debe a que esta estructura se
puede utilizar para
múltiples espacios de nombres. Entonces necesitamos especificar
qué espacio de nombres usar. Podemos hacer clic derecho en el
toque y abrir acciones rápidas. Puedes ver que
podemos usar para espacios de nombres, motor
Unity que toque y motor
Unity que toque
mejorado. Necesitamos usar un toque mejorado. Ahora, en la parte superior del script, deberías ver que
cada vez que usamos touch, es desde el espacio de nombres
touch mejorado. Ahora, podemos continuar
con la declaración if. Tenemos que verificar si el dedo
índice está activo, lo que significa que
toca la pantalla. Entonces podemos usar touch para obtener el primer toque activo de
la matriz de toques activos. Sabemos que este toque activo vendrá desde el
primer dedo en la pantalla debido a la
declaración if del toque activo, necesitamos obtener una posición. Primero, usamos el vector tres para almacenar la
posición de la pantalla del toque. Dado que esta es una posición de pantalla, necesitamos
convertirla a nuestra posición. La posición de la pantalla es una
posición en la pantalla. Es diferente a
la posición mundial. La posición mundial es la posición real en
la escena y el juego. Eso es lo que necesitamos.
Para la conversión. Utilizamos la cámara principal. La cámara principal tiene la pantalla de
funciones para votar punto. Entonces le damos una posición de pantalla convertida en una posición mundial, y luego la almacenamos nuevamente en
la variable de posición táctil. También podemos almacenar
la cámara principal en una variable para un
mejor rendimiento. Vamos a crear una nueva variable
de cámara. En el inicio, digamos que la cámara principal de dos
cámaras de dominio punto. Ahora podemos usar la variable de
cámara principal en el código. Entonces podemos establecer la posición
del jugador usando el
nuevo vector tres. Para x, usamos la
posición táctil que x y la posición táctil y
para la posición y, posición en el eje z no
importa. Solo necesita estar
frente a la cámara. Lo pondré a
cero. Vamos a probar esto. En Unidad. Seleccione el reproductor y agregue el script del
controlador del reproductor. Presiona Reproducir. Puedo hacer clic en la nave espacial y moverla por la pantalla. No obstante, si hago clic en
algún lugar de la pantalla, la nave espacial se
teletransportará a esa posición. Este no es el
comportamiento que necesitamos. La idea es que el jugador no necesite hacer clic en la
nave espacial para moverla. El jugador debería poder
hacer clic en cualquier parte la pantalla y mover la
nave espacial desde su posición. De esa manera, el jugador tiene más visibilidad y
control sobre la pantalla. Por ejemplo, si hago clic aquí y
la nave espacial está aquí, y corté el dedo hacia abajo, quiero que esa nave también
baje desde su posición. Para implementar ese comportamiento, necesitamos calcular
la distancia entre la posición táctil
y la nave espacial. Volvamos al guión. Crear un vector tres
offset que vamos a utilizar es una distancia desde el
tacto hasta la nave espacial. Como ya sabéis de la
conferencia anterior, el tacto tiene fases. Si acabamos de tocar la
pantalla en ese fotograma, se inicia la fase
táctil. Así que vamos a comprobar si se inicia
la fase del primer toque activo. Observe que hay un error. También necesitamos especificar el espacio de
nombres para la fase de separación. Utilizamos el sistema de entrada
que toca paga namespace. Después para calcular los valores de desplazamiento, un poco de matemática vectorial. desplazamiento es igual a la posición táctil menos la
posición de la nave espacial, y eso se transforma en
esa posición. Esto nos dará la
distancia que necesitamos. Entonces podemos comprobar si la
fase es igual a movernos. Eso significa que si el jugador mueve
el dedo en la pantalla, claro, entonces necesitamos
mover la nave espacial. Entonces podemos usar este código
con una sola modificación. Restar el desfase X de la coordenada x y el desfase
y de la coordenada y. Hay una fase en
la que el jugador está tocando la pantalla y
no mueve el dedo. Entonces, si la fase es estacionaria, entonces haz lo mismo. Ajuste la posición con desplazamiento. Y eso es todo lo que necesitamos
para codificar. Vamos a probarlo. Primero. Intentemos hacer clic
en la nave espacial. Eso funciona bien. Después haz clic
en cualquier parte de la pantalla e intenta mover la nave espacial. Se puede ver que la nave espacial sigue el tacto correctamente. Esto es lo que queríamos. Por supuesto, existe la posibilidad de
salir de la pantalla. En la próxima conferencia, abordaremos esa
situación. Nos vemos ahí.
9. Restricciones de movimiento de jugadores: Hola otra vez. Hagamos algunas
restricciones de movimiento para el jugador para que no pueda
salir de la pantalla. La idea es usar una ventana gráfica. Echemos un vistazo a
la pantalla del móvil. El espacio de la ventana gráfica está normalizado y relativo
a la cámara. Lo que eso significa es que
los valores van 0-1, por ejemplo las coordenadas o la
esquina inferior izquierda son cero-cero. El primer número es para el valor x y el
segundo número es cuatro, el valor y, las coordenadas
de la esquina superior derecha, R11, las
coordenadas inferiores a la derecha son 10
y superior izquierda 01, el punto central es 0.50, 0.5. Usaremos esas coordenadas y las convertiremos
en espacio virtual. Entonces dígale al jugador que no
puede moverse más allá de
esas coordenadas. Bien, ahora que conocemos la idea, comencemos a abrir el script del controlador
del reproductor. Primero, necesitamos
valores flotantes privados para los puntos máximos izquierdo, derecho, abajo y arriba. En el inicio. Podemos
asignar esos valores usando la ventana gráfica a la función de punto
mundial. Entonces el maxilar izquierdo obtiene un
valor de la cámara principal, esa ventana gráfica al punto del mundo. Como dije, convertimos
view port a punto mundial. Ahora necesitamos marcar el ritmo de las coordenadas de la
ventana gráfica. Entonces usamos el nuevo vector dos. Dado que esta es la
posición máxima izquierda para el valor x, intentemos con 0.15. Y para la y, podemos usar cero. Verás que un error es
porque esta función devuelve el vector tres y lo estamos
almacenando en valor flotante. Pero solo necesitamos un
valor x del vector. Entonces al final, ¿verdad, esa x para el máximo, verdad? El proceso es el mismo. Simplemente cambie el valor x
para que sea simétrico. Uno -0.15 es 0.85. Para el valor de mezcla, el proceso es similar. Ahora la coordenada X
es cero y la coordenada y puede ser
un número pequeño, por ejemplo 0.05. Al final, elegimos el
valor y con punto y. El valor máximo de APP será 0.6 porque no
quiero que el jugador
se mueva hasta la parte superior de la pantalla. Bien, ahora que conocemos las coordenadas de restricción,
vamos a aplicarlas. Vaya a la función de actualización. Simplemente
alejaré un poco porque esta será
una larga línea de código. Ahora, dentro de la
instrucción IF principal en la parte inferior se anula la posición con la transformación esa posición nuevo vector tres. Para restringir valores, usamos el mito F, esa función de abrazadera. Primero escribimos el valor
que queremos restringir, y esa es la
posición x del jugador. Después escribimos el valor mínimo, en este caso, que es el lado
izquierdo de la pantalla. Entonces la posición máxima izquierda, entonces escribimos el valor máximo que es el
lado derecho de la pantalla, en este caso max, ¿verdad? Para las coordenadas y, queremos transformar
esa posición punto y. El valor mínimo es max down y el valor máximo es max up. Para el eje z, solo
podemos escribir cero. Creo que esto es todo
lo que necesitamos para codificar. Vamos a probarlo. Se puede ver que ahora el jugador no puede
salir de la pantalla. A lo mejor podemos aumentar un poco las coordenadas
inferiores. También puedes ver
que no puedo moverme por encima del 0.6 de la pantalla. Por supuesto, se puede
ir al guión y aumentar el valor
máximo superior. Ahora, puedo moverme todo el camino hacia arriba. Siéntete libre de experimentar con los valores y encontrar
lo mejor para tu juego. Esto funcionará para cualquier tamaño
de pantalla en cualquier dispositivo. Puedes probarlo en otros
dispositivos en el simulador. Bien, eso es todo
por esta conferencia. Nos vemos en la siguiente.
10. Límites de cámara: Hola a todos. En esta conferencia, ajustaremos nuestra cámara para todos los tipos y tamaños de pantallas. En este punto, el tamaño de la
cámara es bueno, pero en un dispositivo
móvil diferente, tal vez sea demasiado
grande o demasiado pequeño. Para resolver este problema, utilizamos máquina pecadora
y una cámara virtual. Así que vamos a importar el paquete de la máquina de
cine. Vaya a Package Manager y
seleccione Unity Registry, busque la máquina central
e instálelo. Ahora, vamos a crear
una cámara virtual. Puede restablecer el componente de
transformación y establecer el eje z
en un valor negativo. De esa manera, nos aseguramos de que los objetos estén
frente a la cámara. Observe que ahora controlamos el tamaño de la cámara en
esta cámara virtual. La idea es crear
dos objetos vacíos en los bordes laterales de
la pantalla y luego asegurarse de que esos
dos objetos representen los bordes del KMer
independientemente del dispositivo. Por lo que siempre necesitan estar dentro la vista de la cámara y actuar
como límites de borde. Vamos a crear un nuevo objeto de juego
vacío. Lo llamaré punto final izquierdo. Podemos darle un icono. Después reinicie el componente de
transformación, mueva el objeto hacia la izquierda. Creo que menos
cuatro es una buena relación calidad-precio. No vayas
hasta el borde. Después duplique el objeto. Este será el punto correcto del valor para x y necesita ser
simétrico, por lo que son cuatro. Ahora necesitamos un nuevo objeto de juego
vacío. Llámalo grupo objetivo,
restablece la posición. Luego podemos agregar el script desde el paquete de
la máquina de la ciudad en el script del grupo
objetivo de la máquina de escena. Se puede ver que podemos añadir objetos de
destino a la lista. Necesitamos objetivos. Uno es punto izquierdo y
otro es un punto derecho. Genial. Ahora seleccione Virtual k-mer. Arrastre el grupo objetivo a
la caída y mire los campos. Ya que estamos usando un grupo
de objetos para el objetivo, seleccionamos grupo compositor, necesitamos cambiar un
par de opciones. El primero es el tamaño de encuadre
grupal. Define cuánto espacio de
pantalla
ocupa el
cuadro delimitador de los objetivos. Tenemos que configurarlo en uno para
que los bordes de la pantalla estén exactamente en los puntos
izquierdo y derecho. Luego establece el
amortiguamiento del marco a cero. Cuanto menor sea el valor, la cámara
fester se
ajustará al
tamaño correcto cuando comience el nivel. Ahora, puedes probarlo
en el simulador, cambiar los dispositivos y
ver cómo se ve el juego. Debería estar bien. Sin embargo, hay
un problema oculto. Observe que las restricciones
de
movimiento ya no funcionan
correctamente. El motivo es que establecemos restricciones en la función de
inicio, pero el cine
no tuvo tiempo de
configurar correctamente la cámara
al inicio del nivel. Entonces el puerto de vista del
que obtenemos coordenadas, sentido de datos equivocados. La solución es bastante sencilla. Podemos usar Corutine
con función queratina. Podemos retrasar la
ejecución del código. La sintaxis es un
poco diferente. Necesitamos crear la función
numeradora. En la función, el código está un poco separado en dos partes. En la primera parte, hacemos algo o nada
dependiendo de lo que necesitemos. En este caso nada. Después agregamos retardo de tiempo. Escribimos yield, return new, y luego elegimos qué tan
largo será el retraso. Por ejemplo, podemos
esperar al final de un marco. Podemos esperar una cierta
cantidad segundos, y así sucesivamente. Esperemos 0.2 s.
Después de que pase el tiempo, ejecutamos la segunda
parte del código. En este caso, lo necesitamos
para obtener valores de restricción. Esos 0.2 s es tiempo suficiente
antes de ver una máquina para ajustar la cámara y luego
obtenemos los datos correctos del puerto de visualización. En realidad, usemos un
peso para el final de un marco. Para este ejemplo, esperamos que un fotograma sea tiempo suficiente
para ajustar la cámara. Lo último que necesitamos para llamar a esta función con
start coroutine. Utilice la corrutina de inicio en el inicio y llame a la función de
establecer límites. Vamos a probarlo. Ahora.
Todo funciona bien. Tenga en cuenta que a veces
se ve una máquina necesita más tiempo para
ajustar la cámara, por ejemplo, en todos sus dispositivos móviles. Entonces tal vez sea más inteligente tener
más retraso de tiempo. Eso es. Espero que lo entendieras todo y te vea
en la próxima conferencia.
11. Actualización de controles táctiles [No se salte]: Hola a todos. Esta
es una actualización rápida. Parece que la unidad es
nuevo sistema de entrada y algunos dispositivos Samsung tienen problemas de
compatibilidad. No te preocupes, te voy a mostrar
como arreglarlos. Quizás incluso para
cuando veas esto, la unidad y Samsung ya
resolvieron este problema. En ese caso, no es
necesario hacer ningún cambio. Veamos el problema. Por alguna razón, los dispositivos
Samsung no
registran esta línea de código. Creo que
tienen problemas con la matriz de dedos o
algo así. Pero en realidad lo registran, pero sólo cuando se usa
un lápiz óptico. No van a registrar
el dedo desnudo, lo cual es realmente extraño. Otros dispositivos Android y iPhones no tienen ese problema Entonces, reemplacemos
esa línea de código. Podemos usar la clase táctil
para contar toques activos. Entonces, bien, toca esos toques
activos que cuentan. El conteo tiene que ser
mayor que cero. Eso significa que tenemos uno o más toques activos
en la pantalla. Vamos a probarlo. Aquí tengo un dispositivo Samsung
y todo funciona. Sin embargo, el jugador puede abusar comportamiento de
movimiento mediante el
uso de multi-touch Observe que si uso
más dedos y viví el primer dedo
que mueve la nave espacial,
la nave espacial se teletransportará a la posición
del segundo Para evitar eso, necesitamos
otra declaración if. Usemos el primer toque
activo. Tiene índice cero. Entonces usemos el dedo
y el índice alrededor de ese toque. El índice de ese dedo
debe ser igual a cero. Eso significa que usamos solo el primer dedo
que toca la pantalla. Después mueve el código
dentro de la sentencia if. Vamos a probarlo. Como puedes ver, ahora,
todo funciona. Yo sugeriría que utilice este enfoque ya que
funciona en todos los dispositivos. Espero que Unity y Samsung
solucionen sus problemas. Mientras tanto,
asegúrate de probar
tu código en tantos
teléfonos como sea posible. Pero no hemos terminado. Otro error puede aparecer
en el editor de Unity. El error que estoy a punto de mostrarte solo pasa en editor de Unity. No afectará tu juego
publicado en los teléfonos móviles, pero puede resultar molesto cuando
pruebes tu juego en Unity. Por supuesto, tengo la solución. Primero, déjame mostrarte el bicho. Puedo controlar el barco normalmente mientras mi ratón está en la pantalla. Pero si hago clic fuera
de la pantalla, obtendré este error. Lo mismo sucede cuando se mantiene pulsado el botón izquierdo del ratón y arrastra el ratón fuera de la pantalla. Básicamente, sucede
cada vez que
pulsas fuera de
la pantalla del móvil. Cuando construyes tu
juego en el teléfono, no
puedes presionar
fuera de la pantalla. La pantalla es
lo único que puedes usar. Entonces no sé por qué el editor de Unity registra posiciones de pantalla
fuera de la pantalla, pero sé cómo solucionarlo para
que este error
no te moleste Se puede notar que los valores
para la pantalla posicionan r infinito para x e
infinito negativo para el eje Podemos usar esa información. Vaya al script del
controlador del reproductor aquí abajo vector
tres posiciones táctiles. Vamos a escribir hash,
si Unity Editor, y luego escribir hash. Y si ahora todo lo que
tenemos justo entre esas líneas se
compilará sólo en
el editor de Unity. No se compilará cuando construyas tu juego a teléfonos. Aquí, podemos verificar si la posición táctil en x
es igual a infinito. Si eso es cierto, entonces regresa y no
ejecutes el código de abajo. Entonces en el editor de Unity, cuando presionemos fuera
de la pantalla, el código se detendrá aquí y
eso evitará errores. Vamos a probarlo. Arrastraré el ratón fuera de la pantalla y no pasa nada. Puedo hacer clic en cualquier lugar y no
tengo errores. Bonito. Espero que la unidad resuelva estos
errores en versiones más nuevas, y eso es todo por este video. Nos vemos en la siguiente.
12. Conteo de grietas: Hola a todos. En esta conferencia, aprenderemos
a contar pasos. Esta conferencia es optativa. No vamos a utilizar pasos en
este proyecto de espacio más corto, pero a lo mejor será útil
para tus juegos y proyectos. Ampliarás tus conocimientos
sobre los controles táctiles. Si abres documentación, el enlace está en los recursos. Después bajo la clase Touch, puedes ver todas las propiedades
que podemos usar. Algunos de ellos
ya los hemos visto y usado por ejemplo fases y posición de pantalla para contar cuántos
tipos hizo el reproductor, necesitamos la propiedad de conteo de cintas. Vamos a abrir el script del
controlador del reproductor. Por ejemplo, digamos que necesitamos
registrar un doble toque. Necesitamos una declaración si. Entonces usamos la clase touch, en nuestro caso, mi
touch una variable. Entonces mi toque, ese tipo cuenta. Si el conteo es de dos, entonces podemos hacer algo. Y eso es todo. Es así de simple. Vamos a probarlo. Simularé un doble toque
con un doble clic. Se puede ver la consola
que tenemos debug log. Bonito. Por supuesto, puede cambiar
el número de cintas, por ejemplo, podemos verificar si hay una cinta. Esto es todo por esta conferencia. Espero que hayas aprendido más sobre los controles
táctiles y
nos veamos en el siguiente.
13. Joystick virtual: Hola a todos. En esta conferencia, agregaremos un joystick virtual que podremos
usar para mover la nave espacial. Como pueden ver, puedo mover la nave espacial moviendo
este joystick virtual. Tenga en cuenta que esto es opcional. No utilizaremos este
enfoque durante el curso. Utilizaré controles táctiles
para el resto del curso. Aún puedes seguir el curso con esta opción de
joystick. Pero la razón principal de
esta conferencia es
mostrarte lo fácil que es
implementar un joystick virtual. A lo mejor lo usarás en tus
futuros juegos y proyectos. Bien, comencemos. Como dije, vamos a utilizar
un nuevo sistema de entrada. Voy a repetir el proceso de importación en caso de que te hayas saltado esa parte. Primero, tenemos que ir
a Package Manager. Se asegura de seleccionar
Unity Registry, luego buscar
el sistema de entrada, seleccionarlo y hacer clic en
el botón Instalar. Ya lo he hecho. Luego haga clic derecho en
la ventana del proyecto para crear la acción de entrada. Yo lo llamaré controles. Haga clic en el botón Editar. Esto abrirá una nueva pestaña. Haga clic en el botón Más para
crear un nuevo mapa de acción. Este mapa de acción
será para el jugador, así que llámalo jugador. Entonces tenemos acciones. Las acciones pueden ser, por ejemplo ,
disparos, movimiento, etc. Cada acción tiene una
o más fijaciones. Las fijaciones son como disparadores. Determinamos qué botón
presionar para activar la acción. Simplemente eliminaré esta acción
para mostrarte el proceso. Para crear una nueva acción, haga clic en este botón más. Esta acción
será para el movimiento, así llamarlo movimientos. Puedes ver las
propiedades de acción aquí. Tenemos que cambiar
el tipo de acción. Para el joystick. No necesitamos un botón, necesitamos usar un valor. También. Necesitamos establecer el tipo
de control a cualquier valor o usar un vector para. Después selecciona la
encuadernación y
abre, abre y gamepad y
selecciona una vida en juego. Ahora, cuando terminemos, es importante
salvar el activo. Si haces algunos cambios, recuerda guardarlo. Después selecciona el jugador. Necesitamos agregar un componente de
entrada de jugador. Después arrastrando los
controles de activos que hicimos. Ahora vamos a crear la
interfaz de usuario para el joystick. Necesitamos una imagen. Yo lo llamo un palo izquierdo. Ir a la vista de escena. Seleccione la imagen. Yo sólo voy a acercar
un poco. Si quieres tener un joystick
en la esquina inferior izquierda,
entonces necesitamos cambiar Anchor, entonces necesitamos cambiar Anchor, Preset y pivot point a
la esquina inferior izquierda, mantener presionada Mayús y Alt y elegir
la esquina inferior izquierda. Podemos cambiar un poco la
posición. Entonces agreguemos el propio componente
screen stick. Para la mascota de control. Elige el mismo ritmo
que hicimos en nuestros controles, y ese es el stick izquierdo. Vamos a probar esto. Se puede ver que la
imagen se está comportando como un joystick, pero
no pasa nada. El jugador no se mueve. Antes de lidiar con eso, ajustemos un poco el joystick, lo
movemos más a la esquina. Entonces cambiemos la imagen. Consulta el enlace en los recursos para obtener más imágenes de
joystick virtuales gratuitas. También podemos aumentar un poco
la escala. Esto se ve mejor. Observe que existe la variable de disposición de
movimiento. Determina qué tan lejos nos moveremos el joystick
desde su centro. Vamos a aumentarlo a 100. Esto es mucho mejor. También para que la interfaz de usuario sea compatible
y escalable para todos los dispositivos, necesitamos seleccionar Canvas. Después cambia el modo de escala
a escala con el tamaño de pantalla. Después establecer una resolución de referencia. Vamos a hacer coincidir el ancho
y la altura por igual. Así que establece esto en 0.5. Todo lo que tenemos que hacer ahora es
conectar el joystick
con el movimiento del jugador. Seleccionemos al jugador. Tengo el script del
controlador del reproductor. Vamos a abrirlo. Para que el joystick funcione. Primero, necesitamos crear
una referencia de acción de entrada. De vuelta en Unity. Expanda el conjunto de controles. Se puede ver la acción, mover, arrastrarla en el campo vacío. Volver al guión. Necesitaremos un
flotador de velocidad variable. Después en actualización, vamos a usar
vector para la dirección. Obtendremos los valores de dirección a partir de la referencia de acción de entrada. Así que usa la acción de movimiento para usar
esa acción que lee el valor. Los sticks en gamepads tienen valores
vectoriales dos. Eso significa que
leemos el vector de valor dos. Para mover realmente al jugador, usa transform que traduce. Multiplicamos el vector de
dirección de movimiento con la variable de velocidad y luego multiplicamos
todo con el tiempo, tiempo
delta para un movimiento suave. Eso es todo lo que necesitamos para volver a
revestir en Unity. No olvides establecer la velocidad. Vamos a probarlo. Ahora se puede ver a medida que muevo el
joystick, el jugador se mueve. Bonito. Eso es todo por este tutorial y nos vemos en el siguiente.
14. Concepto de enemigo: Hola a todos. En esta conferencia aprenderemos
a crear enemigos utilizando el concepto de herencia. La mejor práctica para usar herencia es
cuando se tiene un grupo de objetos que tienen muchas funcionalidades comunes, por ejemplo ,
un grupo de enemigos. El concepto es muy sencillo. Creamos un padre también
conocido como clase base. Luego creamos clases infantiles. Las clases hijo heredarán variables y funciones
de la clase padre. Además, los lugares infantiles pueden tener sus propias variables
y funciones. Déjame mostrarte un ejemplo. Primero, para mantenerse organizado, seleccione la carpeta de scripts y cree una nueva
para los scripts enemigos. Entonces vamos a crear el
nuevo script C-sharp. Llámalo NME.
Será nuestra clase base. Ábrela. Bien. Todos los enemigos necesitaban tener salud que sea común
para todos ellos. Así que crea una variable de salud de
flotación pública. Ahora, podemos crear
una clase infantil, por ejemplo Meteor. Ábrela para hacer de
esta una clase infantil, reemplazar el comportamiento motor
con la clase enemiga. Por ahora, deja al
niño lugar así, sin variables o funciones que no
sean inicio y actualización. En Unity, podemos crear un nuevo objeto de juego vacío,
el script de meteoros. Y podemos ver la variable
salud. La variable salud
se hereda de la clase enemiga y podemos
usarla en la clase Meteor. Vamos a la clase enemiga. Por lo general, podemos usar variables
protegidas
en lugar de las públicas. Las variables protegidas
son algo intermedio entre lo privado y lo público. Son visibles solo las clases de
padres e hijos. Otros lugares pueden verlas o
cambiarlas directamente. Eso también significa que no podemos
verlas en el inspector
por defecto. Para ello, utilizamos campo
serializado. Bonito. Echemos un vistazo a
la estructura un poco más. Tenemos una clase padre, una clase meteorito
hijo
enemigo, y podemos, por ejemplo crear una clase infantil de nave espacial. Entonces tanto el meteoro como la nave espacial
necesitan tener salud. Necesitan tener un cuerpo rígido, probablemente en animador para
animaciones y así sucesivamente. Todas esas cosas que son comunes
van en la clase de padres. También todos los enemigos
pueden recibir daño. Así podemos crear la función take damage
en la clase padre. Las clases hijo heredarán
esas variables y funciones. Como dije, además, podemos tener funciones específicas
solo para clases infantiles. La clase de meteoritos puede tener, por ejemplo, la función de
rotación y la nave espacial
puede tener una función should. Y esa es la
lógica básica de la herencia. Ahora, vayamos
al guión enemigo y creemos la función de tomar
daño. asegura de que
sea público porque a otras clases las
llamaremos a esta función. También. Se necesita tomar un parámetro de
flotación dañado. En esta función,
disminuiremos la salud con
el valor del daño. Entonces podemos agregar alguna animación
de daños. Después de la deuda, podemos verificar si la salud es menor
o igual a cero. Entonces tal vez podamos jugar
una animación de destruir. Posteriormente, escribiremos código
real para deuda. Ahora,
te voy a mostrar uno avanzado el truco con funciones
virtuales. Las funciones virtuales funcionan muy bien con el patrón de herencia. Entonces creamos una
función virtual en una clase padre. Todas las clases hijo pueden usar
esa función virtual, pero también pueden anularla. Eso significa agregar algo de
código y funcionalidad. Digamos la sintaxis. Creamos una función de vacío
virtual pública. Observe la palabra clave virtual. Vamos a llamarlo secuencia de daño. Y también podemos
crear esa secuencia. Ahora, reemplace los comentarios
con funciones. Cuando el enemigo toma la imagen, ocurre
la secuencia del rebaño. Esa secuencia ocurre cuando la salud es menor
o igual a cero. Podemos agregar alguna funcionalidad a las funciones
virtuales si es necesario. En este caso, no lo necesitamos. Pasemos al guión de meteoritos. Dado que esta clase
es una clase hijo, podemos anular funciones
virtuales. Observe la anulación de palabras clave. Por defecto, se llamará al código de la clase
base. Entonces si tienes algo aquí en la función virtual
que se llamará, pero recuerda que no
tenemos que llamarlo, es una opción. Así que sólo podemos eliminar
esa línea de código. Podemos hacer algo diferente y único para esta clase infantil. De esa manera, cada clase
infantil puede tener un daño
diferente y esas
secuencias y comportamientos, por ejemplo, un tipo de enemigo puede
explotar en esa secuencia. Otro tipo de enemigo puede, por ejemplo explotar y también
generar más enemigos. Las posibilidades son infinitas. Bien, eso es toda teoría que
necesitamos saber.
A través del curso. Vamos a agregar más cosas
al enemigo de clase base. En la próxima conferencia, aplicaremos este conocimiento
y haremos el primer enemigo. Entonces nos vemos ahí.
15. Meteor prefabricado: Hola a todos. En esta conferencia, crearemos preferencias de material que puedan destruir al jugador. En primer lugar, podemos eliminar los objetos del medidor de
la conferencia anterior. Entonces podemos ir a sprites enemigos y arrastrar 1 m a la escena. Podemos renombrarlo para asegurarnos de que los enemigos sean visibles frente
al fondo, aumentar el orden en una capa. Observe que el
jugador es demasiado grande. Sería muy difícil evitar
meteoritos mismos proyectiles. Podemos cambiar la
escala tal vez a 0.6. Genial. Ahora seleccione inmaduro para poner
este objeto bajo la influencia del motor de física y las fuerzas en el componente 2D del cuerpo rígido. Nos encontraremos con que estás usando
este componente en el script. Observe que hay algunos
ajustes como la gravedad. Si presionamos Play, el objeto caerá. Para colisionar realmente
con otros objetos, necesitamos un colisionador, en este caso, colisionador
circular 2D. Acerquemos para ver mejor. Voy a disminuir el
radio un poco perfecto. También necesitamos agregar un Cuerpo Rígido y
componentes colisionadores al jugador. Ed, cuerpo rígido 2D. Para el jugador, podemos
poner la gravedad a cero. El jugador tiene sprite más
complejo. Así podemos agregar el colisionador de
polígonos 2D. Para aumentar el rendimiento,
podemos eliminar algunas líneas del colisionador en el botón
editar colisionador. Ahora, mantenga el control y haga clic en la línea cuando se convierta en
un derecho para eliminarla. También podemos mover algunos vértices. Voy a acelerar un poco. Puedes editar el
colisionador como desees. No hace falta que
sea lo mismo que el mío. Podemos salir del modo de edición. Ahora selecciona el meteoro. Para evitar seleccionar
el fondo, podemos desactivar la selección, mover el medidor a la mitad. Ahora, podemos saborear la colisión
en el modo de juego. Como puede ver, los objetos chocan. El siguiente paso es habilitar la opción East Trigger
en el colisionador de meteoritos. Ahora, los objetos no
colisionarán, sino que se detecta colisión y podemos utilizarla en el script. A continuación, cambiar su
cuerpo rígido tipo dos cinemática. Ahora bien, otros objetos y fuerzas no
pueden afectar a este objeto, lo que significa que nada puede
empujar o tirar de este meteoro. Podemos controlar el movimiento
sólo a través del guión. Además, recuerda cualquier
objeto que tenga un colisionador y pretendas
mover, destruir o cambiar. Necesita tener un componente
RigidBody2D. Podemos agregar el
guión del meteorito y moverlo hacia arriba en el inspector. Ábrela. Antes de comenzar a codificar aquí, vamos a ir a la clase enemiga
padre. Todos los enemigos tendrán un componente 2D de cuerpo
rígido. Así podemos crear una variable
protegida, RB. En Unity, puede arrastrar el componente de cuerpo rígido
al campo vacío. Ahora vuelve al guión de
meteoritos. Quiero crear materiales con diferentes velocidades aleatorias finales. Así que creamos para flotar variables que podamos
ver en el Inspector. Una es la velocidad mínima y la
otra es la velocidad máxima. Y también necesitamos una velocidad de nube privada
en la función de inicio, podemos establecer la velocidad. La velocidad obtendrá el valor
con ese rango aleatorio. Por lo que el valor pasará de velocidad
mínima a velocidad máxima, que establecemos en el inspector. Ahora, necesitamos agregar
velocidad a los maduros. Entonces usamos RB de cuerpo rígido, esa velocidad y la
colocamos en vector a abajo, lo que significa un valor negativo. En el eje y, es menos uno. El medidor se moverá hacia abajo y
solo necesitamos multiplicar
dirección con velocidad. En Unity, establece valores mínimos
y máximos. Vamos a probarlo. Bonito. Ahora, detectemos una colisión entre el meteoro
y la nave espacial. Utilizamos la función On Trigger
Enter to d. Esta función se
llamará cuando algo entre en el gatillo que
tenemos en el Meteor. Se puede ver que
la función tiene un parámetro de colisionador 2D. Vamos a cambiarle el nombre a
otro colisionador. Posteriormente, tendremos un sistema dañado y
dañaríamos al jugador. Pero por ahora, vamos a
destruir al jugador. Utilizamos la función
destruir y
queremos destruir otro
colisionador, ese objeto de juego. Entonces este es el objeto
inmaduro con el que colisionó. Vamos a verlo. Bonito. Sin embargo, el meteorito puede
tocar otros objetos. Por lo que queremos especificar sólo
para destruir al jugador. Hay muchas
maneras de hacerlo. Usaremos etiquetas, seleccionaremos el jugador e
iremos al menú desplegable. Seleccione el reproductor de etiquetas. Por supuesto, puedes
crear una nueva etiqueta aquí. Simplemente haga clic en el botón más. No lo haré ahora. Solo asegúrate de que
el jugador tecnológico o lo que sea que uses esté seleccionado. En primer lugar, queremos comprobar
si el objeto tiene el reproductor con la función de
comparación. Si eso es cierto, entonces destruido. Genial. Ahora necesitamos
crear un prefabricado a partir de detonador es como una copia del objeto con
todos sus componentes. Primero, vamos a crear una
nueva carpeta, prefabs. A continuación, arrastre y suelte los
objetos del medidor de la jerarquía. Ahora, podemos crear fácilmente copias de ese
objeto en la escena. Utilizaremos este prefab para
la llave inglesa en el futuro. Si vas a los sprites enemigos, verás dos meteoros más. Tu mini reto es crear prefabs a partir de estos sprites. La solución es muy sencilla. Puedes repetir el proceso para recordar todo lo que
hemos hecho, pero hay una manera
fácil de hacerlo. Podemos seleccionar el prefab
de la jerarquía, reemplazar el sprite, renombrarlo y arrastrar el prefab a
la carpeta Prefabs. Queremos crear un
nuevo prefab original. Entonces haz lo mismo para
crear un tercer Prefab. Y eso es todo
por esta conferencia. Nos vemos en la siguiente.
16. Matriz de colisión: Hola a todos. hacer un spammer prefabs de cuatro
metros, te
mostraré un truco útil sobre colisiones
entre objetos. Exploraremos la matriz de
colisión usando las métricas de colisión, decidimos entre qué capas se detectará
la colisión. Entonces primero, necesitamos
crear más capas. Selecciona el jugador y ve a la esquina superior derecha
en el inspector. Recuerda aquí nuestras
capas para colisiones. Ya tenemos algunas capas
predeterminadas, pero vamos a crear otras nuevas. Ir a agregar capas. Vamos a crear el reproductor de capas. También podemos crear
uno para los enemigos. Ahora selecciona el jugador y
asigna la capa que hicimos. A continuación, podemos seleccionar el
prefabricado de meteoros de la jerarquía. El material debe estar
en la capa Enemigo. Para prefabs, es importante anular
los cambios si quieres aplicarlos a las otras instancias
del mismo prefab. Ahora bien, si vas a la carpeta Prefabs,
selecciona meteorito tres, y podrás ver que ya
está en la capa Enemigo por
la anulación que aplicamos. Ahora selecciona los otros 2 m y
cambia la capa dos enemiga. Dado que hicimos los cambios
directamente a los activos, no
necesitamos
anular nada. Usted hace anulaciones justo cuando se realizan cambios en los prefabs
en la jerarquía. Ahora, vaya a Editar
configuración del proyecto y seleccione Física 2D. Ir a Matriz de colisión de capas. Aquí puedes ver todas
las capas de colisión y las relaciones entre ellas. Por defecto, se habilita una colisión
entre todas las capas. También puedes ver las capas que hicimos para deshabilitar la colisión
entre las capas, solo desmarca la casilla. En este caso, deshabilitamos la colisión entre
las
capas por defecto y NME para que podamos
seguir desactivando colisión hasta llegar
al reproductor de capas. Necesitamos una colisión entre
el jugador y los enemigos. Así que deja eso comprobado. Siguiente. No necesitamos
colisión entre enemigos. Para el jugador de capa también
deshabilitó otras colisiones. Solo para mostrarte, si estás deshabilitado las colisiones entre el enemigo
y el jugador, el meteorito
atravesaremos por el jugador y
no se detectará colisión. Así que asegúrate de que la
colisión esté habilitada. Esta es una buena manera de
controlar lo que colisionará y
lo que no colisionará. Definitivamente deberías usar
esto en tus proyectos. Posteriormente en el curso, agregaremos más capas
y modificaremos esta matriz. Eso es todo por esta conferencia. Nos vemos en la siguiente.
17. Spawner de meteoros: Hola a todos. En esta conferencia,
crearemos un spammer para meteoros. También nos aseguramos de que
los meteoros se encuentren fuera de la pantalla y dentro de los límites del borde izquierdo
y derecho. Primero, vamos a crear un
nuevo GameObject vacío. Esto habrá
meteoritos compañero. Podemos restablecer el componente de
transformación. Entonces necesitamos crear
un nuevo script C-sharp. Llámalo madura pounder, el guión al
objeto del juego y ábrelo. Ahora, vamos a crear
algunas variables. Necesitamos una variedad
de objetos de juego. Esta matriz contendrá
los prefabricados de meteoritos. Entonces necesitamos la variable de
tiempo de generación. Esta variable determinará
cuándo expondrán los meteoros. Necesitamos un temporizador para
seguir rastreando el tiempo. Y la variable entera I
es un índice para la matriz. A continuación, necesitamos una referencia
a la cámara principal. Por supuesto, necesitamos
un maxilar izquierdo y máximo derecho variables
para los bordes de la pantalla. Y en este caso, también
necesitamos una
variable de posición y que estará fuera de la pantalla para
asegurarnos de que el medidor abarque en
la posición correcta. En la función de inicio, vamos a configurar una referencia
para la cámara principal es de la misma manera que hicimos en el script del controlador del reproductor. También podemos ir al script del controlador del
reproductor. Aquí podemos copiar la función de establecer
límites. Vamos a pegarlo en
el script spawner. Podemos eliminar las marcas abajo
y max variables superiores. Utilizamos variables maxilar izquierdo
y máximo derecho. Siéntase libre de modificar estos
números si es necesario. Necesitamos agregar una variable, y es por eso que posicionar. Esa posición tiene que estar
fuera de la pantalla. Entonces, para el valor y, usa algo mayor que uno. Voy a usar 1.1. A continuación, llame a esta función en el inicio con la corrutina de inicio. Ahora, vamos a crear la
lógica principal del engendrador, tiempo
calculado y los meteoros. Por defecto, el temporizador es cero, pero podemos asegurarnos
y establecerlo a cero. Entonces aumentamos el
temporizador por tiempo.DeltaTime. Time.deltatime es el
tiempo entre dos fotogramas, es que actualizamos fotogramas, el tiempo va a aumentar. Entonces comprobamos si ese temporizador
es mayor que nuestro tiempo. Si eso es cierto, necesitamos gastar uno de
los prefabricados de tres metros. Establecemos el índice I al
azar ese rango, que va de cero
a metros de esa longitud. En este caso, el índice
será el número 01 o dos. Ahora, cuando tenemos
un número de índice, podemos generar un medidor prefab de la matriz para crear objetos. En tiempo de ejecución, utilizamos la función
Instanciar. Primero, escribimos el
objeto que necesitamos generar. En este caso, ese es un meteoro prefab de
la matriz con índice i. Luego elegimos esta posición
delimitadora. Necesitamos un nuevo vector tres. Para el valor x, usamos ese rango aleatorio. Va del maxilar
izquierdo al máximo, derecho. Esto expondrá meteoros
dentro de los bordes de la pantalla. Para el valor y,
utilizamos la posición y. Recuerda, el valor está por encima de
la parte superior de la pantalla. Para el eje z, si usa algún
número que pondrá el objeto frente a
la cámara. Creo que nuestra
cámara es menos diez, así que podemos ir menos cinco, por ejemplo siguiente, necesitamos
establecer la rotación
del objeto para elegir
la rotación predeterminada, solo
podemos usar
cuaternión, esa identidad. Pero para que se vea mejor, vamos a usar rotación aleatoria. Establezca la rotación usando
cuaterniones que los valores de Euler, x e y necesitan ser cero. Y para la rotación en el eje z, usamos un aleatorio
ese rango 0-360. Entonces tenemos que restablecer
el temporizador a cero. Genial. Vayamos a la unidad. Podemos elegir el tiempo de desove, e.g I. Lo estableceré a cada 2 s. Luego podemos agregar
prefabs de Meteor a la matriz. Me encantó el inspector y
ve a la carpeta Prefabs, selecciona meteoros y
arrástralos a la matriz. Asegúrese de usar
prefabricados de los activos. No uses prefabs
de la jerarquía. Vamos a probarlo. Bonito, todo funciona. No obstante, tenemos que
encargarnos de un problema. Aumentaré el tiempo de desove y jugaré un poco el juego. Se puede ver en la jerarquía que tenemos muchos objetos. Esos son metros que
evitamos en su
caída al infinito. Para resolver esto,
vayamos al guión de Demeter. Vamos a utilizar la función
en se hizo invisible. Esta función
se llamará cuando el objeto ya no sea
visible para la cámara. En otras palabras, cuando el
objeto sale de la pantalla, entonces sólo tenemos que llamar a la función de destruir y
destruyó este objeto de juego. Vamos a probarlo. Ahora, se puede ver
que los meteoros son destruidos a medida que
salen de la pantalla. Bonito. Para que este límite sea
aún mejor, podemos aleatorizar el tamaño
de los meteoros, responder. En el script spawner, vamos a almacenar el objeto que se encontró en la variable de
objeto del juego. Entonces podemos crear una variable aleatoria para
el tamaño de los meteoros. Voy a establecer un rango muy pequeño. Puedes aumentar la
diferencia si quieres. Entonces cambiamos la
escala local del meteoro. Para x e y, use el tamaño variable. Genial, esto es todo lo
que necesitamos para codificar aquí. Nos vemos en la próxima conferencia.
18. Rotación de objetos: Hola a todos. Antes de agregar
capacidad de tiro al jugador, decidí exprimir en esta conferencia sobre la rotación de
Meteor. Esto es opcional,
pero creo que los medios Roseville se ven
mejor si rotan. El objetivo es
rotar meteoros en z, x está en el guión. Eliminemos este prefab de la jerarquía open
Demeter script. Primero, necesitamos flotar
variable, Rotar, velocidad. Luego en la función de actualización, necesitamos rotar el
objeto cada fotograma. Utilizamos la función Transformar
Girar. Para ejes x e y. No necesitamos la rotación. Y para el eje Z, usa Velocidad de
rotación y
multiplícalo con tiempo, tiempo delta. Utilizamos el tiempo.Deltatime para que la rotación
se vea agradable y suave. Esto es todo lo que necesitamos
para codificar en Unity. Seleccione un prefabs de meteoritos
y establezca una velocidad de rotación. Vamos a probarlo. Bonito. Creo que esto
se ve mucho mejor. Eso es todo por esta conferencia. Nos vemos en la siguiente.
19. Dispara para jugadores: Hola, otra vez. Agreguemos
capacidad de tiro al jugador. En esta conferencia, crearemos disparos
básicos a partir de
un punto de disparo. Las mejoras y los disparos para más puntos se realizan
más adelante en el curso. Primero, necesitamos una posición
desde la que disparemos. Así que haz clic derecho en el jugador y crea un objeto de juego vacío. Este objeto es un
objeto hijo del jugador. Yo lo llamaré punto básico de
tiro. Tenemos que movernos para disparar en posición un poco
sobre la nave espacial. Luego crea un nuevo script
C-sharp. Yo lo llamaré tiro de jugador. Ábrela. Como siempre. Primero, vamos a crear las
variables que necesitamos. Necesitamos una variable de objeto de juego para el prefabricado de bala láser. Necesitamos un punto de transformación
desde el que disparemos. Entonces necesitamos la variable de
intervalo de disparo. Además, vamos a crear una
variable flotante para que podamos
restablecer el intervalo. Este valor de intervalo de disparo
en unidad en el Inspector. Y luego en la función start, podemos almacenar ese valor en
la variable interval reset. A continuación, hay muchas
maneras de crear temporizadores. Ya hicimos uno
para este pounder, pero para este caso, vamos a crear un temporizador
disminuyendo el valor. Cada fotograma, disminuimos intervalo de
disparo
por tiempo.DeltaTime. Si ese intervalo de disparo
es menor o igual a cero, entonces podemos mostrar
21 bala láser. Antes de crear una
función para el cortocircuito, simplemente
restablecemos el intervalo
configurándolo al valor predeterminado. A continuación, crear una función para abarcar los objetos que usamos
instanciar es que recuerdes, primero escribimos el
prefabricado que necesitamos para machacar y es una bala láser. Tenemos que gastarlo en la posición
básica debe apuntar. Podemos usar rotación por defecto y usar cuaternion
punto e. la entidad. Luego llame a la función cuando el intervalo sea menor
o igual a cero. En Unity, selecciona el
reproductor y agrega el guión. Se puede ver que
necesitamos establecer algunas referencias. Por ahora. No tenemos un chico
láser en prefab, pero tenemos un punto de disparo. Arrastre el punto que hicimos
al inicio de la conferencia. También podemos establecer el intervalo de
disparo en 0.3 s.
Ahora, vamos a crear un prefabricado de bala
láser. Ir al reproductor de sprites. Y aquí se puede ver
el sprite proyectil. Vamos a arrastrarlo a la escena. Renombrarlo. Es un poco grande. Así que establece la escala en 0.5. A continuación, agregue el componente 2D
del cuerpo rígido. Elige el tipo de cuerpo cinemático. A continuación, necesitamos un colisionador. Voy a usar colisionador cápsula 2D. Ajustemos un poco el colisionador. Tiene que ser más pequeño. Luego habilite la opción
Is Trigger. Ahora, vamos a crear una nueva capa de
colisión para proyectiles. Ir a Añadir Capa. Yo lo llamaré
jugador proyectil's. Selecciona el objeto y elige la capa del
proyectil del jugador. Recuerde, cuando
creamos una nueva capa, necesitamos modificar
la matriz de colisión para un mejor control de colisión. Quiero que el proyectil sea
colisionar solo con enemigos, así que desactivó otras colisiones. Por último, podemos crear un
guión para la bala láser. El script al objeto. Ábrela. Vamos a crear variables. Primero, necesitamos la
velocidad de la bala. Entonces necesitamos la variable
daño. Esta variable determinará cuánto daño hará la
bala. También necesitamos la variable 2D
del cuerpo rígido. En la función start, establecemos la velocidad para transformarla multiplicada por la velocidad. Transformar que arriba es
la dirección y está representada por el eje
verde en la escena. Esto hará que la
bala se mueva hacia arriba. No necesitamos la función de
actualización para detectar colisión con la bala que usamos en Trigger Enter a D, entonces no necesitamos verificar qué colisionó con la bala debido a la matriz
de colisión. Sabemos que sólo los enemigos
chocan con la bala. Entonces de la colisión, obtenemos el componente enemigo. Recuerda que la clase enemiga es una clase padre para todo
tipo de enemigos. Entonces, cada tipo de enemigo como guión enemigo
es una clase padre. El guión enemigo, tenemos la función de tecnología dañada que recibe función de daño
dañará al enemigo. Ahora, cuando conseguimos el componente, podemos llamar a la función
enemiga que tome la imagen. La función toma
un argumento y ese es el daño que
le haremos al enemigo. Después destruye la bala. No obstante, hay casos en que
las balas van a fallar a los enemigos, entonces tenemos que
destruir esas balas. Igual que los meteoros, los videos
que no se vuelven invisibles funcionan
cuando la bala es de la pantalla destruida. Ahora ve a Unity, conecta el componente de
cuerpo rígido. Ajuste la velocidad y el daño. Voy a poner la imagen en uno. Ahora, arrastre la bala
a la carpeta Prefabs. Elimine esta de
la más alta aquí. Selecciona el jugador y
arrastra la bala prefabricada
de los activos. Vamos a probarlo. Como puede ver, se detecta
colisión, pero no destruimos meteoros. Una explicación simple para eso. Seleccione uno de los principales prefabricados. Se puede ver que la salud es 0.1 bala debería ser
suficiente para destruirla. Vamos al medidor o guión. Estamos buscando la función de secuencia de
muertes. Recuerde que esta función
se llama en el tanque función
dañada cuando la
salud es cero o menos. Y llamamos a la función de
daño grueso cuando un enemigo choca
con una bala. Entonces todo está
conectado correctamente, pero esa secuencia no
está haciendo nada. Está vacío. Solo tenemos que destruir el
meteoro en la secuencia de muerte. En Unity, selecciona
todos los prefabricados de Meteor. Si quieres que el meteorito sea destruido con una bala
puesta Salud a una, elegiré dos, lo que significa dos balas para
destruirlo. Vamos a probarlo. Bonito, todo funciona. Nos vemos en la próxima conferencia.
20. PlayerStats y sistema de daños: Hola a todos. Vamos a crear un sistema de salud y
daño para el jugador. A través del curso,
operaremos el sistema
con animaciones, gestor de
juegos, lógica
y otras cosas. Pero la funcionalidad central
se realiza en esta conferencia. Primero, necesitamos un
nuevo script C-sharp. Yo lo llamaré los estados previos. El guión para el jugador. Ábrela. Vamos a crear
algunas variables. Necesitamos un flotador, se burla de
la variable de salud. Esta será la
salud máxima para el jugador, que determinamos
en el Inspector. Entonces necesitamos una variable
privada, salud que representará
la salud actual del jugador en
la función de inicio, Vamos a establecer
salud actual, salud máxima. No necesitamos la función de
actualización. Ahora, vamos a crear una función para que el jugador pueda
tomar la imagen. Yo lo llamaré
jugador toma daño y toma un
parámetro, daño. Como puedes ver,
el sistema de daños es similar al sistema de daño
enemigo. Aquí, disminuimos esa
salud por cantidad de daño. Después, comprueba si la salud es
menor o igual a cero. Si eso es cierto, entonces podemos destruir al jugador. En el futuro. Aquí habrá mucha
más lógica, animaciones que abarcan explosiones, mostrando la
escena de la muerte y demás. Ahora ve a Unity. Voy a fijar salud máxima 23. Ir al guión enemigo. Todos los enemigos infligirán daño. Entonces tiene sentido crear una variable dañada
en la clase padre. En Unity, selecciona
un prefabs de meteorito y observa que hay una
variable de daño en el Inspector. Voy a poner el daño a uno. Después abre el guión material. Si recuerdas, cuando un meteorito
choca con el jugador, inmediatamente
destruimos al jugador. Podemos comentar
esa línea de código. La idea es dañar al jugador. Ahora, podemos obtener el componente de estadísticas
del jugador. De las estadísticas del jugador llamamos
al jugador tomar la función
de imagen. La función toma
la variable de daño que creamos en
las arcillas enemigas. Destruyamos también el meteoro. Ahora, podemos probarlo. El jugador debe ser destruido
luego de golpes de tres metros, ya que la salud es de tres y el
daño es de 112.3, está funcionando. Por supuesto, sería bueno
ver cuánta salud tiene
para el jugador. Por lo que en las próximas conferencias, crearemos una
barra de salud para el jugador.
21. Fundamentos de la interfaz de la UI: Hola a todos. En esta conferencia, aprenderemos
sobre los fundamentos de la interfaz de usuario. Tener lo adecuado es
configurar un Canvas, cómo
posicionarte correctamente son elementos en más para crear un
ayudante y menús principales, es
necesario conocer cosas
fundamentales. Primero, hagamos clic derecho
en el más alto aquí. Y aquí puedes ver
todos los elementos de la interfaz de usuario. El más común, nuestra
imagen, texto y botón. Vamos a crear una imagen. Esto creará automáticamente imagen del
lienzo y el sistema de eventos. Antes de comenzar a trabajar
con la imagen, seleccionemos el sistema de eventos. Debido a que estamos usando
un nuevo sistema de entrada, necesitamos reemplazar este módulo. Esto permitirá
la interacción con botones y otros
elementos interactuables en el futuro. Ahora, haz doble clic en el
lienzo para ver el tamaño completo. Por defecto, el Canvas
tiene el mismo tamaño de pantalla. Seleccionemos nuestra imagen. Cambiar posición a cero-cero. Ahora, la imagen está en
medio de la pantalla. Si vas al simulador, deberías ver la imagen. Lo primero que tenemos
que cambiar es hacer que los elementos de la
interfaz de usuario se escalen
dependiendo del dispositivo. Eso significa que en dispositivos más pequeños, los elementos de la
interfaz de usuario deben ser dispositivos cada vez más
pequeños y
más grandes, por ejemplo, I. Cambiará a
un dispositivo más grande. Observe que el tamaño de
la imagen es el mismo. Esto no es lo que necesitamos para cambiar el tamaño, seleccione Canvas. Deberías ver el componente escalar del
lienzo. Después cambia la escala a
escala con el tamaño de pantalla. Observe que la imagen es más grande. El siguiente paso es elegir
una resolución de referencia. Dado que este juego es para
retratos en perspectiva, fijemos la resolución
en una proporción de nueve a 16. Y queremos igual
anchura y altura de imagen. Así que establece la imagen en 0.5. Ahora, cuando cambies de dispositivo, el tamaño debería
cambiar correctamente. A lo mejor es difícil de
ver en esta plaza, pero la forma en que los verdaderos sprites, el cambio,
sería más visible. Ahora, pasemos al error más común
que veo que comete la gente. Digamos que necesitamos crear un ancho de barra de salud, esta imagen. La Barra de Salud necesita
estar en la esquina superior. Seleccionemos la imagen y movemos a la esquina
superior izquierda. Se puede ver que
en el simulador, la posición es buena. Sin embargo, vamos a elegir
un dispositivo más pequeño. Ahora puedes ver que la
imagen es de la pantalla. ¿Por qué sucede esto? La respuesta es la posición de anclaje. Seleccione la imagen y
abra los Presets de Anclaje. Por defecto, la posición de anclaje está en el centro de la pantalla. Se puede ver la
posición del ancla en el Lienzo. ¿Cómo funcionan los anclajes? En realidad, son
realmente simples. La distancia entre
la posición de anclaje y el objeto es
siempre la misma. Por lo que esta distancia se
aplicará para cada dispositivo. En dispositivos más pequeños, esa
distancia es demasiado grande, por lo que la imagen es de la pantalla. Otro ejemplo,
Digamos que este es nuestro dispositivo de prueba
y la distancia. Si elegimos un dispositivo más grande, la imagen no
estaría en la esquina. Estará más cerca del
medio, entonces debería estarlo. La solución es elegir
otra posición de anclaje. En nuestro caso, el ancla necesita estar en la esquina
superior izquierda. Ahora, usamos esta distancia desde el
anclaje superior izquierdo hasta la imagen. Esto funcionará para cada dispositivo. Ahora, vamos a elegir el Preset de Anclaje
superior izquierdo. También podemos mantener el turno para fijar el punto de pivote
a esa esquina. Ahora, cambia los dispositivos
en el simulador y ve que la imagen está
en la posición correcta. Bien, ahora tenemos que
colocar correctamente los elementos de la interfaz de usuario
para todos los dispositivos, lo que significa que estamos listos
para crear una barra de salud. Nos vemos en la próxima conferencia.
22. Barra de salud: En esta conferencia, crearemos
un ayudante para el jugador. Para comenzar desde cero. Eliminemos la imagen
de la conferencia anterior. Ahora vamos a crear una nueva imagen. Yo lo llamaré Health Bar shape. Tenemos un sprite para esta imagen y lo arrastramos al campo
de imagen de origen. Si acercamos el zoom, podemos ver que la forma
se ve deformada. Así que haz clic en el botón Establecer tamaño
nativo. Ahora la imagen tiene
dimensiones idénticas a las del sprite. No obstante, si intentamos
cambiar la altura y el ancho, la forma se deformará. Para arreglarlo, seleccione el Editor de
Sprite Sprite. Utilizaremos la técnica de las nueve
diapositivas. Se llama nueve
diapositivas porque
dividimos el sprite
en nueve pedazos. Busca el cuadrado verde, luego puedes tirar de
la línea verde hacia abajo, asegúrate de que esté
por debajo de las esquinas. El objetivo es separar las
esquinas de los costados. Para esta línea, se asegura de
que esté por encima de las esquinas. Entonces tenemos un alineamiento de izquierda
y derecha. Se puede ver que el sprite
se divide en nueve piezas. Las esquinas no se estirarán en la forma solo los
lados se estirarán. Aplicar cambios. Después selecciona la imagen y
cambia el tipo a rebanar. Se puede ver la diferencia
cuando cambiamos las dimensiones, la forma no se deforma. Bonito. Hagamos clic derecho en el lienzo y creemos un nuevo objeto de juego
vacío. Yo lo llamaré bar. Barra será un objeto padre
a la forma de barra de salud. Seleccionemos la forma. Ve a Presets de Anclaje
y estírelo. Mantenga presionada la tecla Alt y haga clic en
el botón de estirar. Cuando cambiamos las dimensiones
de la barra de salud, que es un objeto padre, la forma se ajustará. Vamos a crear un nuevo objeto de imagen
hijo. Yo lo llamaré antecedentes
de salud. Voy a usar el cuadrado de Sprite. Cambiemos el color. Después ve a Anchor
Presets y estírela. Muévelo hacia arriba un lugar en la jerarquía para que
la forma sea visible al frente. Cuando hacemos zoom en un letal
porque tenemos bordes redondos, la imagen de fondo es
visible fuera de los bordes. Si eliges otro color, sería más visible. Para arreglarlo, solo
cambiemos las dimensiones. Entonces. Podemos crear una
imagen infantil del fondo. Yo lo llamaré campo de la salud. También podemos usar el
sprite cuadrado y estirarlo. Ahora, cambia el color. Escogeré amarillo, luego cambiaré la imagen
y seleccionaré campo. Podemos ver algunos ajustes. La idea es cambiar este monto de llenado a medida
que cambiamos la salud. Primero, cambiemos
el método
de relleno de radio a horizontal. Esto nos dará el comportamiento
deseado. Observe que el
monto de llenado tiene valores 0-1. Alejemos, seleccionemos el ayudante y cambiemos los anclajes a la esquina
superior izquierda. Sostenga para
establecer también la posición. Ajusta un poco la posición. A lo mejor podemos cambiar el color de la forma para hacer que los bordes sean más gruesos. Aumentemos un poco el tamaño. Ahora bien, esto se ve bien. Veamos cómo se ve
en el simulador. Genial. Pasemos al guión de estadísticas
del jugador. Primero para obtener acceso
a los elementos de la interfaz de usuario, necesitamos incluir
el espacio de nombres de la interfaz de usuario. Entonces podemos crear
una variable de imagen. Yo lo llamaré ayudar a llenar. La idea es cambiar la cantidad de llenado cada vez
que el jugador recibe daño. Además, es una buena idea establecer el monto de llenado cuando comience
el juego. Entonces, en la función de inicio, hemos ayudado a llenar esa
cantidad de llenado igual a la salud. Pero como dije, el valor debe ser 0-1. Entonces dividimos la salud
por la salud máxima. Podemos copiar y pegar ese
código en el reproductor, tomar la función de imagen, y eso es todo lo que
necesitamos para codificar. En Unidad. Arrastre la imagen del
campo de salud a la ranura de la imagen. Vamos a probarlo. Como puede ver, tenemos plena salud. Tomemos daños. Bonito. La Barra de Salud reacciona. Añadiré más elementos a la barra de salud solo para
que se vea mejor. No es esencial. Entonces voy a crear una
imagen infantil de la forma. Usa el
sprite basado en iconos y cambia de color. El ancla necesita ser llamada a la
mitad izquierda para establecer
también la posición y
cambiar el tamaño de esa imagen un poco. Va a la izquierda. Voy a llamar a este icono sostenerla. Después crea una
imagen infantil del titular. Usa el
sprite del icono de Ayuda y cambia su tamaño. Los ajustes preestablecidos de anclaje son
relativos al padre. Entonces esto tiene que
estar en el medio, tal como está. Ahora. Podemos seleccionar la Barra de Salud y colocarla en la posición
correcta. Bien. A lo mejor los bordes
deberían ser un poco más gruesos. Podemos aumentar un poco el tamaño. Puedes jugar con la
configuración como más te guste, cada juego es diferente. Eso es todo. Y nos vemos en la siguiente conferencia.
23. Ayudante de área segura: Hola a todos. En esta conferencia, exploramos un
activo gratuito que nos ayudará a ajustar sus elementos
para todos los dispositivos, por ejemplo, cada dispositivo tiene un área segura en que se
garantiza que los elementos se muestren correctamente. Puede hacer clic en el botón de área
segura para ver el área segura
para este dispositivo. Cada dispositivo tiene
diferentes diseños y diferentes zonas seguras. Cambiemos el dispositivo. E.g. Muestra April XR. Observe que debido a los
diferentes diseños se mantienen barra no
es completamente visible. Así que la idea es colocar
la barra del talón y otros elementos de la interfaz de usuario dentro del área
segura para cada dispositivo. Por suerte, hay uno llamado asset en Unity Asset Store. Puedes Google Ayudante de área segura. Debería ser la primera opción. Así es como se
ve. Es gratis. Así que haz clic en Agregar a mis activos. Por supuesto, necesitas iniciar
sesión en tu Unity ID. Si no lo hiciste. Después de eso, da clic en Abrir en Unity o lo que sea una opción. En unidad, el
gestor de paquetes debería abrir. Puedes ver que el
gestor de paquetes tiene la opción, mis activos en la lista deberían
ser el ayudante de área segura. Entonces necesitas descargarla. Ya lo hice. Entonces tengo un botón de descarga. Después de descargar los activos, haga clic en el botón Importar. No necesitamos la escena demo. Si quieres ver ese ejemplo, no dudes en incluirlo, pero solo necesitamos este guión de
área segura. En el proyecto. Deberías ver el guión. Ahora haga clic derecho en el lienzo y cree un objeto de juego vacío. Llamémoslo un área segura. Entonces tenemos que
estirarlo por la pantalla. El objeto de área segura
debe ser padre de la barra de salud y otros elementos de la interfaz de usuario que
necesitamos controlar. A continuación, agregue el guión de área segura. Asegúrese de que conformar
x e y están habilitados. Ahora bien, si presionamos Play, la Barra de Salud
estará en la zona segura. Podemos probarlo en otros dispositivos. Genial, funciona perfectamente. Entonces por ejemplo, si tenemos la barra **** en la esquina
superior derecha, sin este activo,
no será visible en absoluto. Pero con el activo Se
ve justo como debería. Eso es todo por esta conferencia. Nos vemos en la siguiente.
24. Animación de explosión: En esta conferencia,
aprenderemos a crear animaciones, por ejemplo, cuando se destruyen objetos, usamos animación de explosión.
Para mantenerse organizado. Vamos a crear una nueva
carpeta para animaciones. Primero, necesitamos encontrar los
sprites que usaremos. En la carpeta de enemigos. Podemos ver explosión Sprites. Usemos el
primero de la escena, cámbielo a explosión. No podemos verlo en la escena por el
orden en la capa, necesitamos aumentarlo. Quiero que esta explosión sea visible frente a todo. Creo que el
jugador ha ordenado diez y un
fondo transparente es 12. Es bueno
anotar esas cosas. Entonces tenemos que ir
más alto que eso. Vamos a establecerlo en 20. En juegos más grandes y
complejos, recomiendo crear y
usar más capas de clasificación. Ahora, vamos a abrir algunas pestañas de
animación. Ve a Animación de ventanas y
abre la pestaña de animación. Abramos también
la pestaña del animador. Usamos la pestaña animador para las transiciones de
animación
en la siguiente conferencia. Después asegúrate de seleccionar el
objeto que deseas animar. Para crear animación, haga clic
en el botón Crear. Selecciona la
carpeta Animaciones que creamos. Voy a llamar a esta animación
explosión ejemplo. Si le das un
vistazo al objeto, ahora tenemos el componente
animador, que tiene un controlador. Esos son
componentes necesarios para las animaciones. Vaya a la carpeta Animaciones. Aquí puedes ver
el controlador y el
ejemplo de animación que creamos. A continuación, seleccione el objeto de
explosión y arrastre todos los Sprites de explosión
a la línea de tiempo. Veamos cómo se ve. Animación, pero sigue siendo rápido. Tenemos que ralentizarlo. Seleccione la explosión,
amplíe las opciones y elija Mostrar frecuencia de muestreo. Ahora puedes establecer los fotogramas por
segundo para esta animación. Por defecto, son 60, Vamos a establecerlo en 12. Se ve mucho mejor. Sin embargo, se puede ver
que la animación se repite. Tenemos que ir a la carpeta
Animaciones y seleccionar nuestra animación de
ejemplo de explosión. Necesitamos desactivar el tiempo de bucle. Bonito. Es una buena idea destruir el objeto una vez finalizada la
animación. Así que vamos a crear un nuevo C sharps. Yo lo llamaré explosión. El script al
objeto. Ábrela. No necesitamos la función de
actualización. En el inicio. Destruyamos el objeto con un retraso de 2 s. Vamos a probarlo. La animación se ejecuta una
vez y después de 2 s, el objeto se destruye y
podemos verlo en la jerarquía. Ahora, podemos crear un prefab. Eliminar el objeto
de la escena. La idea es generar
este prefab cuando los meteoros o el jugador
son destruidos. Ya que todos los enemigos valoran es esta explosión prefab
ir al guión enemigo. Vamos a crear una variable de
objeto de juego. Ahora, ve al medidor de guión. En esa secuencia antes de que
destruyéramos el meteoro, vamos a unir la
explosión prefab. Podemos usar la posición y
rotación del oído medio. Vamos a engendrarlo también. Cuando el medidor choca
con el jugador. Después ve al guión de estadísticas
del jugador. Necesitamos esta explosión límite prefab cuando el jugador muere. Esto es todo lo que necesitamos para codificar. Conectemos las cosas en Unity. Selecciona el reproductor y ve
a la carpeta Prefabs. Arrastre el prefab de explosión
a la ranura vacía. Haz lo mismo por 3
m. Vamos a probarlo. Con esto, lanzar un spam de meteoros
y explosiones. Lo mismo sucede cuando
destruimos la nave espacial. Genial. En la siguiente conferencia, creamos animaciones para la nave espacial y
transiciones entre ellas.
25. Animación y transición de daños: Hola a todos. En esta conferencia, creamos esta animación
parpadeante cuando el jugador toma la imagen. Primero, ve a la carpeta
Animaciones, crea una nueva carpeta
para el reproductor. Animaciones. Seleccione el jugador. Después crea animación, asegura de que esté
en la carpeta correcta. La animación se
llamará inactiva. El sprite que necesitamos está
en la carpeta sprites. Generalmente en animaciones inactivas, hay algún movimiento
del objeto que animamos, pero en este caso, usaremos solo
un sprite predeterminado. La animación ociosa será
un sprite estético. Así que selecciona el jugador, toca el sprite
al principio. Y colocaré el mismo
sprite a 1 s en la línea de tiempo. Ahora, vamos a crear
una animación más. Yo lo llamaré daño. Después usa el sprite blanco. Cambiaré la frecuencia
de muestreo a 30. Entonces otra vez, usa el mismo sprite, colócalo en el 0.06 de
la línea de tiempo. Dado que la frecuencia de muestreo es la duración
será un poco más larga. Puede ampliar la
distancia entre fotogramas para aumentar la
duración si es necesario. Ahora, se puede ver la animación, sólo un sprite blanco. Por lo general, para previsualizar la animación, puede usar los botones de vista previa
y reproducción. A continuación, tenemos que desactivar ciclo para la animación
de daño. Después ve al animador,
selecciona el jugador. Ahora puedes ver estados de ralentí
y daño. Necesitamos crear las
transiciones entre ellos. El estado de las naranjas es
la animación por defecto. Haga clic con el botón derecho en el estado
inactivo y cree una transición
al estado dañado. Haz lo mismo en dirección
opuesta. Haga clic en la
flecha de transición para ver algunos ajustes. Para hacer la transición de
un estado a otro, utilizamos el tiempo o condiciones de salida. Para esta transición,
utilizaremos condiciones. Entonces necesitamos crear parámetros, abrir la pestaña Parámetros. Entonces podemos agregar cuatro tipos. En este caso, necesitamos un disparador. Vamos a llamarlo daño. Activaremos este
disparador a través de un script. Ahora podemos desactivar el tiempo de salida. Necesitamos una transición inmediata. Así que establece esto a
cero o condición. Usemos el gatillo. Hicimos. Ten en cuenta que puedes tener más parámetros y
utilizarlos como condiciones. Ahora, es necesario hacer
ambas condiciones para que ocurra la
transición. Por supuesto,
solo necesitamos el gatillo. Así que borra este ejemplo, luego selecciona la transición
de daño a Idle. Aquí usaremos el tiempo de salida
en lugar de las condiciones. Si establecemos el tiempo de salida en uno, eso significa que la transición
ocurrirá cuando se complete
la animación de daño. Si, por ejemplo establece el tiempo de salida en 0.5, entonces la transición
ocurrirá cuando se complete el
50 por ciento de la
animación. Establezca esto en uno. La duración de la transición debe
ser cero, por ejemplo, cambio. Ahora, cuando completamos los
ajustes en el guión, necesitamos activar el gatillo dañino cuando
un jugador toma la imagen. Abre el guión de estadísticas del jugador. Primero, necesitamos crear un componente Animator en la función de daño tecnológico
para activar el disparador, usamos cualquier disparador de conjunto de datos. Entre paréntesis, escribimos
el nombre del parámetro. Asegúrate de
deletrearlo correctamente. Vamos a probarlo. No olvides
asignar al animador. Tomamos la imagen y podemos
ver la animación de daños. No obstante, si los
tomas varias veces en un
periodo de tiempo realmente corto, podemos simular
eso en este momento. Pero en una situación en la múltiples balas
golpearon la nave espacial, la animación
entraría en modo spam. La nave espacial estaría en la animación de daños
todo el tiempo. Así que vamos a evitar eso
en el script en una variable de perno y
establecer el valor en true. Entonces primero verificamos si
esa variable es verdadera. Después activa la Animación. Y aquí también necesitamos
agregar una función antispam. Vamos a crear un
enumerador anti-spam. Aquí establecemos la
variable ball en false para que
podamos activar
la Animación. Entonces esperamos una cierta
cantidad de tiempo. Voy a establecer el tiempo de
espera en 0.15. Después reinicia la variable de bola. Para llamar a esta función, utilizamos start coroutine. Ahora, cuando el jugador
toma la imagen varias veces en un
intervalo de 0.15, la animación
se llamará solo una vez. Se puede aumentar el
intervalo, si lo desea. Y eso es todo para esta conferencia, tenemos transiciones de animación.
26. Dispara a un enemigo: Hola a todos. En esta conferencia,
creamos un enemigo disparador. Esta es una gran oportunidad
para implementar conocimientos de conferencias
anteriores como movimiento,
disparos y animaciones. Pero también aprenderemos
algunas cosas nuevas. Por lo que será una conferencia un poco
más larga. Empecemos. Primero para disparar a los enemigos, usamos una nave espacial morada. Cambia el nombre, luego
establece la capa en enemigo. Aumentar el orden en
la capa de clasificación. Recuerden, todos los enemigos
van al orden cinco. Luego agreguemos componentes, cuerpo
rígido 2D y
configurémoslo en cinemático. En lugar de usar el colisionador de
polígonos 2D, usaremos dos
colisionadores de libros y luego los fusionaremos. Así que agrega un colisionador de caja 2D. Haga clic en el botón editar
colisionador. Cambiemos la forma. Después agrega otro colisionador de
caja 2D. Nuevamente, cambia la forma. Esto no es súper preciso, sino su rendimiento eficiente y funcionará bien. Para fusionar colisionadores,
utilizamos el colisionador compuesto 2D select utilizado por composite
para cada colisionador. Observe que
tenemos un colisionador. No hay líneas
que se crucen. A continuación, seleccione la
opción Is Trigger en el colisionador compuesto. Ahora, vamos a crear puntos de
tiro. Voy a llamar a esto Canaán izquierdo. Mueve el objeto a la posición de
disparo. Después duplicarlo y
renombrarlo para escribir Canaán. Colócala del otro lado. Vamos a crear un guión. Yo lo llamaré enemigo púrpura. Selecciona al enemigo
y agrega el guión. Ábrela. Primero. Esta clase necesita ser una
clase infantil de la clase enemiga. Solo para recordar, la
clase enemiga tiene algunas variables y funciones que serán
heredadas por todas las clases infantiles, incluida la clase enemiga
púrpura. En el guión enemigo púrpura. Vamos a crear variables
adicionales. Primero, necesitamos un
flotador de velocidad variable. Entonces necesitamos debería, dímero e intervalo de disparo. Vamos a crear las variables de
transformación
para las posiciones de tiro. Luego crea una
variable de objeto de juego para el prefabricado de bala. Vamos a todas las variables
que necesitamos para mover al enemigo. Usemos la variable de
cuerpo rígido que heredamos de
la clase padre. Establezca el vector de velocidad a
abajo multiplicado por la velocidad. Para disparar, necesitamos crear un temporizador en la función de actualización. En primer lugar, aumentamos debemos cronometrar por tiempo.DeltaTime cada fotograma. Entonces comprobamos si ese temporizador es mayor o igual
al intervalo de disparo. Si eso es cierto, entonces podemos disparar. Por supuesto que usamos la función
Instanciar. Instanciar el prefab de bala
en la lata izquierda y posición usa la
identidad del cuaternión para la rotación. Entonces podemos copiar y
pegar este código. Simplemente reemplace el Canaán
izquierdo por el Canaán derecho. Después de la muerte,
sólo tenemos que reiniciar, debe cronometrar a cero. Ahora, el enemigo puede
moverse y disparar. A continuación, resolvamos cuando el enemigo choca
con el jugador. Ya que estamos usando un disparador, necesitamos el On Trigger
Enter para la función. Primero, verificamos si
el objeto está en jugador usando la función de
comparación. Entonces a través de estados de jugador, podemos llamar al jugador
tomar función de daño. Utilice la variable daño, que se hereda
de la clase padre. Entonces instanciamos
la explosión prefabricada. Después de la deuda. Destruimos al enemigo. Entonces todo lo que
hicimos en el guión se sabe de conferencias anteriores. Por eso voy un
poco más rápido. Ahora, vamos a anular las funciones
virtuales
lastimadas y esa secuencia más adelante, agregaremos animación en
la secuencia del rebaño por ahora, en la secuencia de muerte, que se llama cuando la
salud del enemigo está por debajo de cero, instanciar la
explosión prefab. Entonces destruye al enemigo. Por supuesto, los enemigos no
pueden chocar con el jugador o el jugador
no destruye al enemigo. Eso significa que el enemigo va a salir la pantalla para destruir los objetos
que van fuera de la pantalla, utilizamos la propia función se convirtió en
invisible. Salvemos esto y vayamos a la unidad. En unidad, necesitamos
establecer variables. Voy a poner Salud a tres. Entonces necesitamos cuerpo rígido. El daño al colisionar
puede ser uno. Entonces usa el
prefabricado de explosión que hicimos. Establezca la velocidad, por ejemplo cinco y el
intervalo de disparo en uno, lo que significa 1 s.
Conectemos puntos de disparo izquierdo y
derecho. Entonces necesitamos crear
un prefabricado de bala. Entonces vamos a los sprites. Tenemos este sprite de bala. Renombrarlo. Es demasiado grande. Entonces, vamos a disminuir la escala. Creo que esto es bueno. Cambiemos el
orden en la capa. Entonces vamos a crear una nueva
capa para colisiones. Yo lo llamaré proyectiles
enemigos. Ajusta la capa a los proyectiles
enemigos. Vamos a la matriz de
colisiones. Los proyectiles enemigos
necesitan chocar con el jugador, ignorar
otras colisiones. Ahora, agreguemos un Cuerpo Rígido 2D y cambiemos el
tipo a cinemático. A continuación, agregue el colisionador circular 2D. Podemos disminuir un poco
el radio. Necesitamos crear un guión
llamado Purple bullet. El guión a la bala. Ábrela. Necesitamos variables de daño y
velocidad. También necesitamos una variable 2D de
cuerpo rígido. En la función start, vamos a obtener el componente 2D
del cuerpo rígido. La bala tiene que bajar. Así que establece el vector de velocidad a
abajo multiplicado por la velocidad. No necesitamos la función de
actualización. Dañemos al jugador
cuando choca con una bala. Usamos el On Trigger
Enter para la función. Creo que en Unity me olvidé de poner colisionador
es un detonador. Eso lo haremos más adelante. Aquí como de costumbre,
comprobamos por el jugador, luego llamamos al jugador
tomar función de daño, después destruimos la bala. También utilizamos la propia función
se convirtió en invisible para destruir la bala cuando
se sale de la pantalla. Eso es todo por el guion de
bala. En Unity, establecer daño y velocidad también habilitan la opción
Is Trigger. Podemos crear un prefab de bala. Eliminar uno de la escena. Ahora selecciona al enemigo y
usa el prefabricado de bala. Vamos a probarlo. Modifique al enemigo hacia arriba
y presione play. Funciona bien. Ahora, necesitamos crear
animaciones para el enemigo. Vamos a necesitar esta ventana de
animación. Selecciona al enemigo y
crea animación. Lo llamaré enemigo ocioso. Usa el sprite enemigo púrpura. Vamos a crear una animación más
y llamarla daño enemigo. Usa el sprite blanco. Establezca las muestras a 30, y nuevamente, use el sprite blanco. Ve a la carpeta Animaciones, selecciona daño enemigo
y desactiva el tiempo de bucle. Ahora ve a la pestaña del animador. Esta es una buena práctica para las transiciones de
animación que
cubrimos en conferencias anteriores. Vamos a crear dos transiciones. Luego crea un
parámetro de daño. Selecciona la transición
de ídolo a daño. Usar el parámetro
es una condición. La duración es ser cero y desactivar el tiempo de salida
para otra transición, dejar tiempo y simplemente cambiar la duración de
la transición a cero. Ir al guión enemigo púrpura. En realidad, vayamos
al guión enemigo. Por lo general, todos los enemigos
usan un animador. Así que vamos a crear un componente de
animador. Después volver a la secuencia
del rebaño, activó la transición
con el gatillo. En Unity, seleccione NME. Tenemos que asignar el animador. Desplázate hacia abajo y lo verás. Amplía esto y
usa el animador. Vamos a probarlo. Está funcionando bien. También podemos crear una
función antispam para el enemigo, tal como hicimos para el jugador. Pero te voy a mostrar un enfoque
diferente. En la pestaña emisor debajo de las capas, se
puede ver la capa base, su índice es cero y lo
usaremos en el script. Después selecciona el estado de daño
enemigo. En el Inspector,
deberías ver el campo de etiqueta. Utilice la etiqueta IMG. Volver al guión. Primero, verificamos si la
animación ya se está ejecutando. Usamos la función, obtenemos el estado
actual de los animadores con el índice
de la capa base. Después comprueba si esa
animación tiene una etiqueta. En este caso el mg. Si eso es cierto, eso significa que la animación se está ejecutando
actualmente. Entonces solo regresa, no lo
actives una vez más. Este es un
enfoque un poco diferente para lo mismo. Eso es todo lo que necesitamos para codificar. Sólo hay una cosa
más por hacer. Necesitamos crear un prefabricado enemigo
púrpura. Y ahora ya terminamos. Tenemos enemigo disparador. Nos vemos en la próxima conferencia.
27. Enemigo verde: Hola a todos, Bienvenidos
al reto enemigo. Tu reto es crear
una segunda nave espacial enemiga. La nave espacial necesita tener un comportamiento
similar a los metros, solo un poco más rápido y
ancho para dañar la animación. Esta es una buena
práctica para recordar todo lo que aprendimos en
las conferencias anteriores. Bien, seleccionaré el prefab enemigo
verde. Se puede ver que necesita
estar en la capa Enemigo. El orden de clasificación
tiene que ser cinco. A lo mejor si
quieres asegurarte de que las naves espaciales están
frente a los meteoros, puedes aumentarlo o
disminuir los meteoros a cuatro. Se puede ver que tenemos el guión enemigo
verde. Contamos con cuerpo cinemático, rígido. Estamos aquí para colisionadores
y un colisionador compuesto. Y tenemos un estimador
para animaciones. Ahora abre el guión. Primero. El enemigo necesita
ser una clase padre. Utilizamos una
velocidad variable que es habitual. Establecemos la velocidad en
la función de inicio. Para colisiones. el On Trigger Enter
a la función, luego usamos el daño
y eso es secuencias. Básicamente, es un código de
copiar y pegar de la conferencia anterior. Acabo de borrar el
tiroteo aparte. Al final, tenemos
la propia función se convirtió en
invisible en Unity, Veamos transiciones de animación. Tenemos dos animaciones
y transiciones, igual que en la conferencia anterior, los
escenarios son los mismos. Ahora, cuando tengamos
dos tipos de enemigos, vamos a crear una
llave maestra enemiga en la próxima conferencia. Nos vemos ahí.
28. Spawner de enemy: Hola a todos. Ahora, cuando
tengamos algún prefabs, vamos a crear una llave. Primero, vamos a crear
un objeto de juego vacío. Restablecer el componente de transformación. A continuación, vamos a crear el script de engendrador
enemigo. El script al objeto. Ábrela. Dado que se trata de un spammer, podemos usar algún código
del socio de meteoros. Recuerda, primero,
tenemos que asegurarnos de que los objetos atraviesen
fuera de la pantalla. Así que ve al socio de medidores. Copiemos esta parte que
usamos para las posiciones de desove. También necesitan copiar y pegar
la función de límites establecidos. Bonito. Para organizar el script, usemos el encabezado de atributo
y nombrémoslo enemigo prefab. Usemos una variedad de
objetos de juego para los prefabricados enemigos. Entonces necesitamos un temporizador de
flotación enemiga. Luego usa el espacio de atributos para crear espacio
entre variables. Necesitamos una variable flotante, tiempo de spam
enemigo. Entonces vamos a crear una función
que genere enemigos. Primero, aumentemos el
temporizador por tiempo, tiempo delta. Si ese temporizador es mayor o igual al tiempo
entre respuestas, entonces necesitamos generar enemigos. Como tenemos dos enemigos, escojamos uno al azar. Usa al azar ese rango entre
cero y la longitud del enemigo. Esto asegurará
que el código funcione con cualquier número
de prefabs enemigos. Después instanciar al enemigo
usando el índice de selección aleatoria. Para la posición, utilizamos nueva coordenada x del
vector 34. Usa al azar que se disponen entre las posiciones
maxilar izquierda y máxima
derecha. Para la coordenada y, usemos la posición y. Y para el eje z, podemos usar cero. Este es el mismo
procedimiento que antes. Para la rotación, podemos usar
cuaternion esa identidad. Después de la deuda, reiniciamos el temporizador. Llamar a esta función en actualización. Eso es todo lo que necesitamos para codificar. Vayamos a la unidad. Vamos a asignar prefabricados enemigos. Entonces podemos gastar
un enemigo cada 2 s. Vamos a probarlo. Podemos ver al enemigo púrpura. Y podemos ver al enemigo verde. Bonito. Eso es todo. Nos vemos en la próxima conferencia.
29. Condición de ganancia: Hola a todos. En esta conferencia,
creamos condición de victoria. La idea es que
el jugador sobreviva una cierta cantidad de tiempo y
después de la muerte, el juego termina. Primero, vamos a crear
un nuevo objeto de juego. Entonces podemos crear un guión. Yo lo llamaré condición de ganar. El guión al
objeto y abrirlo. Necesitamos un dímero de flotación. Entonces necesitamos un flotador
posible cuando variable de tiempo. También necesitamos una matriz de objetos de juego que
usaremos para los reproductores en la función de actualización. Y vamos a aumentar el temporizador por tiempo.DeltaTime cada fotograma. Luego verifique si ese temporizador es mayor o igual a
posible cuando el tiempo. Si eso es cierto, eso significa que el
jugador ha sobrevivido y podemos desactivar a los reproductores. Utilizamos el contador de bucle for. Yo es cero. Pasamos por el bucle
mientras yo es menor que su longitud de fundador y
aumentamos en uno cada paso. En el bucle, desactivamos
este socio con índice i. Solo cuanto más
se explica este bucle, digamos que tenemos dos
spammers en la matriz. Los índices son 0.1. La longitud de la matriz es de dos. Entonces contador voy a ser
cero al inicio. Entonces comprobamos si cero es
menor que la longitud de la
matriz, que es dos. En nuestro ejemplo, esto es cierto. Entonces desactivamos el
spammer con índice cero. Entonces aumentar I en
11 es menos de dos. Desactivamos este
socio con índice uno, aumentamos I en uno. Ahora dos no es menos de dos. Salgamos del bucle. Después de que desactivamos a los spammers, algunos de los enemigos
siguen en la pantalla porque esos enemigos
aún pueden destruir al jugador. A esto lo llamo
posible cuando el tiempo. Necesitamos crear una función que compruebe si el jugador está vivo después de que todos los enemigos estén
de la pantalla o sean destruidos, entonces podríamos mostrar una pantalla de
ganar o perder. Todo lo que haremos
a través de game manager. Escribo este código en comentarios
para recordarte a ti y a mí mismo lo que hay que hacer en otro guión y
luego llamarlo aquí. En la próxima conferencia, crearemos un controlador de
panel que administrará pantallas de ganar o perder. Por ahora, ve a Unity. Digamos que lo posible
cuando el tiempo es de 10 s, entonces necesitamos agregar
spammers a la matriz. Tenemos enemigo y
meteoritos, pounders. Simplemente voy a organizar un poco
el más alto aquí. Vamos a probarlo. Sobrevive a 10 s y luego los enemigos
deben dejar de gastar. Voy a tratar de no morir. Rejilla. Se puede ver que está
limitando detenido. El siguiente paso es crear paneles
de ganar y perder, lo que hacemos en la siguiente conferencia. Nos vemos ahí.
30. Controlador de panel de UI- Text Mesh Pro: Hola a todos. Vamos a crear pantallas de
ganar y perder y un guión que tendrá funciones para activar
esas pantallas. Primero, vamos a crear una nueva imagen. Yo lo llamaré panel. Tenga en cuenta que esta imagen no
entra en el área segura. A continuación, podemos usar el
cuadrado es una imagen fuente. Entonces tenemos que estirarlo. Después cambia el color. Voy a usar a Blake. Y hagámoslo
un poco transparente. Entonces vamos a crear una nueva imagen. Tiene que ser un
objeto hijo del panel. Yo lo llamaré una pantalla de ganar. Para la imagen de origen, utilizaremos este sprite de panel
grande. Tenga en cuenta que ya
hice nueve rebanadas. Consulta la conferencia de la Barra de Salud para obtener
más información sobre
las nueve diapositivas. Vamos a usar el sprite, aseguramos de que el tipo de
imagen
sea cortado. Entonces podemos cambiar
las dimensiones. La imagen tiene que estar en
medio de la pantalla. Veamos cómo se ve
en el simulador. Esto es bueno. Puedes
cambiarlo como desees. Ahora, agreguemos texto
a la pantalla de venas. Seleccione el texto Mesh Pro. Esta es la primera
vez que usamos texto, por lo que necesitamos importar
texto Mesh Pro. Vamos a cambiarle el nombre a cuando los textos. Entonces ajustemos
la derecha cuando. Este no es el
aspecto final del parabrisas, esto es solo un boceto
y marcador de posición. Por ahora, se trata de
funcionalidad. Y posteriormente
añadiremos más textos con tres botones y
otros elementos de la interfaz de usuario. Entonces vamos a duplicar el parabrisas. Llamado a esta pantalla suelta. Cambiar el texto para fallar. Bien, ahora tenemos pantallas básicas de
ganar y perder. Seleccionemos el panel y ahora agreguemos el componente de
grupo de lienzo. El grupo Canvas tiene algunas
opciones geniales que podemos controlar. Por ejemplo, podemos cambiar la configuración Alfa para
todos los objetos del grupo. Estas pantallas contarán con botones. Entonces, para presionarlos
e interactuar con ellos, necesitamos vivir los yesos de rayos interactables
en bloque habilitados. Podemos poner el Alfa a cero. Entonces deshabilitemos también las pantallas de
ganar y perder. Vamos a crear un nuevo objeto de juego
vacío. Lo llamaré controlador de
panel. Entonces vamos a crear una
carpeta para scripts de interfaz de usuario. Crear un nuevo script. Controlador de panel. El guión al
objeto y abrirlo. Primero, necesitamos la variable de grupo
canvas. Entonces necesitamos jugar variables de
objeto. Uno para parabrisas y
otro para pantalla Louis. No necesitamos la función de
actualización. Vamos a crear una función
que active el parabrisas. Primero, establecemos el valor
alfa en uno. Después activamos el parabrisas. También vamos a crear una función que activará la pantalla. Es un procedimiento similar. Por ahora. Eso es todo lo que
necesitamos para codificar en Unity. Conectemos componentes y
objetos con el script. Necesitamos el
componente de grupo canvas del objeto panel, luego conectamos las pantallas. Ahora la pregunta es
cuándo y cómo llamar a funciones que
activarán esas pantallas. A lo mejor estás pensando, vamos a conectar el controlador del panel
y cuando la condición. No hagas esto, en lugar de hacer una
conexión directa entre ellos, crearemos un manager de juego. Esta es una especie de conferencia de
preparación. En el siguiente video, conectamos todo esto a través del manager del juego. Nos vemos ahí.
31. Gerente de juegos: Hola a todos. En esta conferencia, creamos un manager de juegos. Nuevamente, Manager es un script que controla aspectos importantes
del juego y se utiliza en muchos otros scripts para ayudar a
ejecutar el juego correctamente. Primero, organicemos un poco
lo más alto aquí. Vamos a crear un nuevo objeto de juego
vacío. Voy a llamar gerentes de TI, ya que tendremos diferentes
gerentes en el juego. A continuación, de nuevo, crear un
nuevo objeto de juego vacío. Yo lo llamaré End Game Manager. Este manager, como su nombre lo dice, se
encargará
de controlar funcionalidad cuando el nivel
termine o el jugador muera. También vamos a crear una
carpeta de administrador para scripts. Crea un nuevo script y llámalo End Game Manager. El guión al
objeto, y ábralo. Dado que este gestor de juegos se
utilizará en muchos scripts, necesitamos crear una
instancia estática de esta clase. Así que hemos escrito public static, el nombre de la clase, que es un manager dentro del juego. Entonces elegimos un nombre
para esta instancia, lo
llamaré administrador final. Esto es solo una variable vacía. Ahora, necesitamos asignar valor
en la función despierta, que se llama antes de
la función start. Ponemos la instancia y el
gerente a esta clase. Ahora todo lo que esta
clase contiene variables, funciones, y así sucesivamente. Podemos usarlo con la instancia de
end manager. Tenga en cuenta que la palabra clave static nos
da fácil acceso
a otros scripts. ¿Qué significa fácil acceso? Te voy a mostrar un ejemplo
muy sencillo. Vamos a crear un juego público variable de
pelota terminado. Ahora vamos al guión de estadísticas
del jugador. Cuando el valor de salud del jugador
es menor o igual a cero, eso significa que
el juego ha terminado. Así que solo podemos escribir
End Game Manager, ese gestor final, ese GameOver y establecer la
variable en true. Tenga en cuenta que
no existe una conexión directa entre los estados de los jugadores
y los scripts de GameManager. No necesito usar get component ni conectar
nada en Unity. Esto funcionará tal como es. Ahora. Agreguemos funcionalidad
al gestor del juego final. Necesitamos funciones
cuando juego y perder juego, asegura de que sean públicas. Así podemos llamarlos
en otros guiones. Si los necesitamos. En la función del juego, necesitamos activar la pantalla, desbloquear el siguiente nivel, guardar la puntuación, y así sucesivamente. Por ahora, solo
activemos la pantalla. Vamos al script del
controlador del panel. Recuerda, en el script del
controlador del panel
hicimos funciones que
activarán las pantallas. Así que necesitamos una forma de utilizarlos
en el guión del gestor de juegos. Ahora, te voy a mostrar la
estructura que estamos construyendo. Sabes que en
la escena tenemos End Game Manager y controlador de
panel. El controlador tiene
algunas funciones que controlan los elementos de la interfaz de usuario. También tenemos el objeto
condición de vena en la escena. En el script de condición win, necesitamos llamar a funciones que
activarán los elementos de la interfaz de usuario. También tenemos un
jugador en la escena, y también necesitamos activar elementos de
interfaz de usuario desde el guión de prueba de
jugadores. Podríamos conectar directamente el controlador
del reproductor con esos objetos en el inspector de Unity
o usar el componente getc. Pero queremos evitar eso. No es práctico. Y como gasto de tu juego, habrá más y más
objetos y todo
estará directamente conectado con
todo. Es un desastre. Solo necesitamos conectar
los controladores,
en nuestro caso, el controlador de panel
con el gestor de juegos. Y como el gestor es estático, tiene
fácil acceso
a todos los scripts. Observe la ventaja,
todo pasa por un canal y ese
es el manager del juego. El truco es
conectar de manera eficiente el administrador
y los controladores. En lugar de que el gerente
busque al controlador, el controlador
se registrará ante el gerente. Entonces, en el script del administrador, vamos a crear la variable del
controlador del panel. Entonces podemos crear una función
pública para el registro, registrar el controlador
del panel. Tomará un parámetro, controlador
del panel en la función establece la
variable del controlador del panel a la PC. Ahora ve al script del
controlador del panel. La función start, llamemos a la
función de registro que hicimos. A la función,
pasaremos esta clase. Observe cómo esto es fácil porque el manager es una clase estática. Ahora en el gestor, podemos usar la variable del
controlador del panel para activar los elementos de la interfaz de usuario. Ahora, vamos a crear la función de juego de
resultados. Si el juego terminado es falso, entonces podemos llamar al juego ganador o de lo contrario podemos llamar
al juego de Lewis. Ahora ve a la condición de vena. Cuando expira el tiempo, desactivamos este
pounders y
podríamos llamar directamente a la función de juego de
resultado. Esto funcionaría correctamente. Aquí no hay ningún error, pero tenemos un pequeño problema. Cuando llamamos a la función de juego de
resolución, existe la posibilidad de que
todavía haya algunos enemigos
en la pantalla. Esos enemigos podrían
destruir al jugador. Por lo tanto, necesitamos
introducir algún retraso entre la activación de
estos socios y llamar a la función
de juego de resultado al
script del administrador o delay, utilizamos funciones de co-rutina. Vamos a crear la función de
secuencia de resolución
del enumerador de ojos . Podemos esperar por ejemplo 2 s. Entonces
llamaremos al juego de resultado. Ahora cree una función pública de secuencia de
resolución de inicio. Aquí usamos start correlating para
llamar a la función de
enumerador de ojos. Esta es la función
que
llamaremos en el script de
condiciones de viento. Tenga en cuenta que después de que
el temporizador alcance posible cuándo se cumplirá esta
condición, cada fotograma, se ejecutará
constantemente este código. Así que simplemente deshabilitamos este
objeto de juego después de la primera ejecución. Bien, vamos a probarlo. Necesitamos sobrevivir 10 s. Entonces los
nervios espinales se activarán. Y después de eso,
tenemos dos segundos extra antes de que aparezca
la pantalla de ganar o perder. Depende. ¿Sobrevivimos
a esos dos segundos extra? Como puedes ver, funciona. Ahora, vayamos al guión de estadísticas
del jugador. Después de que el jugador sea destruido, también
necesitamos llamar a la secuencia de resultados de
inicio. Para evitar múltiples llamadas
de diferentes scripts. Antes de iniciar el telón, detengamos la corriente. Si ya está activo,
use stop carótida. Necesitamos pasar una cadena, pero podemos usar un nombre de n,
elegir resolver, secuencia. Intentemos destruir al jugador. Y deberíamos ver
una pantalla suelta. Genial, Esto es todo
por esta conferencia. Nos vemos en la siguiente.
32. Patrón de Singleton: Hola a todos. Actualicemos el guión del administrador
del juego final con el patrón Singleton. Un patrón de un solo término
significa que puede ser solo un objeto del mismo
tipo en todo el juego. Eso significa que
solo deberíamos tener un manager final de juego
en todo el juego. Esto es muy útil
para las clases estáticas ya que debemos
tener cuidado con el rendimiento. En este punto,
tenemos una escena. Vamos a llamarlo nivel uno. Ahora, duplicarlo y
llamarlo nivel dos. Cuando pasamos de una
escena a otra, destruyen
todos los objetos de la
cadena anterior. Por ejemplo, pasamos del nivel
uno al nivel dos. Todos los objetos del nivel uno
son destruidos y la unidad, aunque son nuevos objetos los
que se comportan en un nivel para conectar todas
estas cosas juntas. Conseguimos un juego. Cuando un jugador juega el
juego varias veces, puede iniciarlo en
diferentes niveles. La idea es preservar de alguna manera al mánager desde el nivel
donde empezaron los jugadores. Por defecto, tenemos
algunos objetos en cada escena y cada pecado tiene el objeto de gestor de juego final. Así que vayamos al guión final del gestor de
juegos en la función despierto. Primero, verificamos si
la instancia es nula. Después establece la instancia
a esta clase. Entonces usamos que no
destruyen la función onload. No queremos destruir
este objeto de juego. Sólo para mostrarte,
voy a ejecutar el juego. Da clic en el botón de pausa
y podrás ver que el gestor de juego final
se coloca en otra escena llamada
no destruir onload. Digamos que empezamos en el juego. En el primer nivel. Pasamos a nivel a
todos los objetos excepto el administrador del juego final
será destruido debido a la función no
destruir onload. Este directivo pasará
al nivel dos. Pero ahora tenemos
dos gestores de juego, uno desde el primer
nivel y otro día fue por defecto en
el segundo nivel, necesitamos destruir uno
del segundo nivel en el guión. Use else, lo que significa que la
instancia del administrador final no es nula. Entonces destruye este objeto de juego. Por lo que el GameManager del
nivel dos ejecutará la función despierta
y la instancia de end manager no será
nula porque la
detectará desde el manager
que vino del nivel uno. Entonces en nuestro ejemplo, el manager del nivel dos, vamos a ejecutar esta parte del
código y destruirse a sí mismo. Y eso es todo. Creamos
un patrón singleton. En las próximas conferencias, aprenderemos
a alternar entre, ya que nos vemos ahí.
33. Cambia los niveles/escenas: Hola a todos. Veamos cómo podemos
cambiar ya que usando botones para organizar
la jerarquía, vamos a crear un nuevo objeto de juego
vacío. Llámenlo controladores. Podemos colocar el
controlador de panel debajo de él. Ahora vamos a crear un nuevo objeto y llamarlo controlador de botones. Luego crea un nuevo script
C-sharp. Voy a llamarlo también un botón Controlador en el
script al objeto. Y ábrela. Primero en cambiar,
ya que necesitamos
usar este espacio de nombres
de administración de cosa, podemos eliminar las funciones predeterminadas. Ahora, vamos a crear un nivel de carga de
función pública revolviendo. Se necesita un parámetro de cadena. Yo lo llamaré un nombre de nivel. Para cargar otra escena, utilizamos Scene Manager
que carga escena. Y luego
pegaremos la cadena, que será el
nombre del nivel. También podemos cargar nuevas escenas usando enteros e índice de compilación. Así que vamos a crear una función int de nivel de
carga pública que tome un índice de nivel de
parámetro. Asegurarse de que las funciones
sean públicas. Aquí. También usamos Scene
Manager que carga, pero pagamos es el índice de nivel
entero. Dónde encontrar
índices de compilación para niveles. Ve al archivo de Unity
y a la configuración de compilación. Aquí puedes encontrar, ya que eso se
incluirá en el juego, nuestro nivel uno está incluido. Y aquí se puede ver que el índice de
compilación es cero. Podemos ir a la carpeta Escenas y agregar un nivel dos al cinturón. Se puede ver que
su índice es uno. Entonces para cargar el nivel por índice, pasaríamos uno
de estos números. Genial. Ahora vamos a crear botones para que podamos llamar a las
funciones que hicimos. Primero, seleccionemos
el panel y aumentemos Alpha para que podamos
ver lo que estamos haciendo. Después haga clic derecho en el
parabrisas y cree un botón. Yo lo llamaré botón de inicio. Podemos eliminar el texto. Cambiemos la
imagen de origen para el botón. Usa el sprite de icono de inicio. Haga clic en el botón Establecer tamaño
nativo. Y cambiemos
el ajuste preestablecido de anclaje. Elija la parte inferior central. Podemos moverlo un poco hacia abajo. Esto se ve bien por ahora. Se puede ver que el
botón tiene evento onclick. Esto se llama cuando hacemos
clic en el botón. Agreguemos un nuevo evento. La idea es llamar a funciones
desde el controlador de botones. Así que vamos a arrastrar el controlador de
botón. Después elegimos una función a la que llamar desde el script del
controlador de botones. Vamos a usar el nivel
de carga de la función string. Ahora podemos escribir el nombre de
la escena que queremos cargar. Posteriormente. Este botón conducirá
al selector de nivel principal, que no tenemos ahora. Así que usa el nivel dos. También podrías usar
la función sola, nivel int y escribir
el índice de compilación. Pero en este proyecto, usaremos mayormente
la opción string. Usaremos una carga
con la factura, el índice, solo para
reiniciar el nivel. Yo sólo quería
mostrarte ambas opciones. A continuación, habilitemos una
pantalla perdedora y creemos dos botones. Primero también seremos botón de inicio. Cambiar la posición. Duplicarlo y llamar a
este botón reintentar. Cambiar el icono. Ahora podemos agregar el
evento onclick a los botones, al botón de inicio. Vamos a agregar un nivel
de carga de función de cadena. Por ahora, déjalo vacío. Esto lo cambiaremos más adelante. Utilice la misma función
para el botón de reintento. Aquí puedes escribir el
nombre de la escena actual, pero no quieres
escribir cadenas para cada botón de reintento
en cada nivel. Es mucho trabajo. Entonces vayamos al script del
controlador de botones. Crear un
nivel de reinicio público de la función. Utilizamos Scene Manager
que carga escena. Y luego usamos el construir el índice del pecado
actualmente activo. Así que bien, Scene Manager
que se activa visto, paréntesis, ese índice construido. Esto reiniciará cualquier nivel
en el que se encuentre el jugador. Entonces, para el botón de reintento, usa el
nivel de reinicio de la función. No hemos terminado, pero vamos a probarlo para
ver posibles errores, desactivar las pantallas y cambiar
el valor alfa a cero. Tratemos de ganar. Voy a acelerar un poco el tiempo. Se puede ver el parabrisas
y el botón. Presionarlo, y deberíamos
estar en un nivel dos. Funciona bien. Salgamos del modo de reproducción
e iniciemos de nuevo. Ahora, intentemos
destruir al jugador. Obtenemos la pantalla de Lewis. Reiniciemos el nivel. Haré clic en el
botón de pausa para mostrarte un problema. Se puede ver que el juego
variable terminado
sigue siendo cierto incluso cuando
reiniciamos su nivel. Es porque el manager
final del juego es estético Singleton y todas
las variables mantuvieron sus valores. Entonces ahora si seguimos jugando y llegamos
al final del nivel, seguiremos obteniendo
la pantalla equivocada. Por suerte, hay una solución
sencilla para esto. Ir a las estadísticas del jugador. En la función start, establecemos el valor en false. Ahora, cada vez que
permitimos niveles, la variable se establece en false. Podemos hacer una cosa más en
el guión de condiciones de viento. En la función de actualización, podemos comprobar si la variable game
over es verdadera. Entonces solo regresa y no
ejecutes el código de abajo. Eso significa que el temporizador se
detendrá cuando el jugador
sea destruido. Vamos a probarlo ahora. Destruyó al jugador. Reinicia el nivel. Intenté ganarlo
después del reinicio. Y nos sale la pantalla de viento. Ahora todo funciona. Por supuesto, no queremos una transición instantánea
entre niveles. Necesitamos algún tipo de
efecto de desvanecimiento que creamos
en la próxima conferencia. Nos vemos ahí.
34. Desvanece entre escenas: Hola a todos. Vamos a crear un bonito efecto de desvanecimiento
entre la carga. Ya que voy a crear
este efecto en un Canvas separado y también
leeré el patrón Singleton. Así que vamos a crear un nuevo lienzo
y llamarlo fader Canvas. Cámbielo a escala
con tamaño de pantalla. También podemos cambiar la
referencia, la resolución. Entonces vamos a crear una imagen. Yo lo llamaré fondo
o la imagen fuente. Podemos usar el cuadrado, luego estirarlo y
cambiar de color a negro para asegurarnos de que esta imagen negra sea visible frente otros elementos
de otro lienzo. Tenemos que aumentar el orden de
clasificación de este Lienzo. Después selecciona la imagen y agrega
el componente de grupo de lienzo. La idea es cambiar el valor Alfa para
crear el efecto de desvanecimiento. Por supuesto, aquí no tenemos botones y otros elementos
interactivos. Así podemos desmarcar
las opciones de interactable y re-cast para
cambiar el valor Alpha, podríamos usar animación,
pero para dispositivos móviles, pero para dispositivos móviles, animar elementos de la interfaz de usuario es costoso y no es
bueno para el rendimiento. Entonces la mejor opción es usar scripts y cambiar el
valor a través del código. Vamos a crear un nuevo guión
C-sharp. Yo lo llamaré fade canvas. Agrega el guión al fader
Canvas y ábrelo. Primero. Vamos a crear una instancia pública estática
pagada de Canvas. Entonces vamos a crear un patrón
singleton, tal como hicimos para
el GameManager. Esta es una buena práctica
para repetir algunas cosas. Ahora, necesitamos variables. Primer minuto, un grupo de lona. Entonces necesitamos un flotador, un
cambio, un valor. Flotar, esperar, tiempo. Y audaz, comenzó el desvanecimiento. Eso son todas las variables que necesitamos. Podemos eliminar la función de
actualización. Para crear un efecto de desvanecimiento. Usaremos corrutinas. Vamos a crear la función de desvanecimiento
del enumerador de ojos. Esta función hará que la pantalla
negra sea transparente. Primero, pongamos el
desvanecimiento comenzó a forzar. Esta variable será verdadera solo cuando utilicemos el efecto fade out. Entonces usamos el bucle while. Si bien el valor alfa
es mayor que cero, necesitamos disminuirlo. Así que vamos a disminuir
el valor alfa con la variable de valor de cambio. Entonces tenemos que establecer
la velocidad de cambio. Después de cada cambio, usemos la función wait 4 s y
la variable wait time. Podemos llamar a esta
función en el inicio. Veamos qué hicimos en Unity. Usa el grupo Lienzo de
la imagen de fondo. La variable de valor de cambio
debe ser un número pequeño. Lo estableceré en 0.04. Espera, el tiempo puede ser 0.01. Vamos a probarlo. Se puede ver que tenemos un
bonito efecto de desvanecimiento. Si quieres que
sea más largo podemos disminuir el valor de cambio
o aumentar con el tiempo. Verás que el efecto
dura más, quizá demasiado. Entonces lo haré más corto. Volver al guión. Ahora, vamos a crear
el efecto contrario. La imagen debe pasar de
transparente a negra. Cree una nueva función de
enumerador de ojos, cadena
de desvanecimiento, que
toma un parámetro de cadena. Ahora la
variable de fe iniciada se hará realidad. Ahora bien, si bien el
valor alfa es menor que uno, necesitamos aumentarlo. Entonces también usamos wait 4 s. saldremos la pendiente cuando el alfa sea
uno y la imagen sea negra. Entonces necesitamos a nivel alto. Incluyamos este espacio de nombres
de administración de escenas. Entonces podemos usar una escena de carga y paga
el nombre del nivel de cadena. Después de eso, nuevamente iniciamos
el efecto de desvanecimiento en la nueva escena y la imagen de fondo
vuelve a ser transparente. Podemos agregar algo de tiempo de espera entre la carga
y el efecto de desvanecimiento. Recuerda que este objeto
es singleton estético, por lo que no será destruido
al cambiar de escena. Para asegurarnos de que no
recibamos varias llamadas, podemos verificar si se inició el fundido. Si eso es cierto, entonces usa yield break. Ahora vamos a crear una cadena de carga de bañista de
función pública. Aquí comenzaremos
el efecto fade-out. Después dirígete al controlador de botones que hicimos en la conferencia
anterior. Recuerda, cuando presionamos botones, se llama
a
esta función para cargar un nuevo nivel. En lugar de flotar,
ya que directamente, usemos la función
del Lienzo de fe. En Unidad. Simplemente verifica que tu botón de inicio esté usando la función del controlador del
baño. Esto lo hicimos en la conferencia
anterior. Antes de probarlo, vamos a duplicar este nivel uno. Entonces tenemos los mismos componentes. Eliminar el nivel antiguo para cambiar el nombre del
duplicado al nivel dos. Posteriormente, cuando creamos todos los objetos necesarios que
necesitan estar en cada escena, entonces tendremos una plantilla, pecado y los prefabricados a partir de
los cuales se pueden crear todos los pecados. Para. Ahora, copiamos
escenas de pasta para probarlas. Vamos a intentarlo. Deberíamos ver el efecto de desvanecimiento. Intenta pasar ese nivel. Entonces deberíamos ver el
efecto fade-out y luego fade in. Otra vez. Funciona. Ahora tengo
un reto de un minuto para ti. Intente crear una
función fade-out que
tomará un parámetro int
en lugar de string. La solución es bastante sencilla. Sólo podemos copiar,
pegar el código y establecer esa escena de carga
toma índice de nivel. También necesitamos crear una función pública para llamar a
la versión entera. El script del controlador de botones. Utilizamos esta función
para reiniciar el nivel. Nuevamente, en lugar de
llamarlo directamente, usemos la función
del fader. No usamos esta
función en ningún lado, pero vamos a cambiarla. A lo mejor lo usarás en
algún lugar de tu juego. Necesita usar la
versión entera del fader. Intentemos reiniciar el nivel. Podemos ver los efectos. Eso es todo por esta lección. En la siguiente conferencia, creamos una pantalla de carga.
35. Pantalla de carga: Hola a todos. En esta conferencia, creamos una pantalla de carga. Hagamos clic derecho
en el fader de lienzo y creemos una imagen. Lo llamaré fondo de
carga. Tenemos que estirarlo, luego cambiar el color. Ahora, necesitamos
encontrar la barra **** porque copiaremos,
pegaremos algunos elementos. La Barra de Salud, y convertirla un objeto hijo de la página del
Lienzo ahí. Eliminemos algunos elementos
extra. No necesitamos el portacíconos. Ahora, podemos colocar la barra de carga en
medio de la pantalla. Aumentemos un poco el tamaño. Tiene que ser un objeto hijo
del fondo de carga. Esto se ve bien. Vamos al guión del fader. Primero, incluyamos el espacio de nombres
de la interfaz de usuario. Entonces necesitamos una variable de objeto de
juego llamada pantalla de carga. Entonces necesitamos una imagen,
la barra de carga. Ahora encuentra la función fade-out. Podemos comentar este
código porque
usaremos la cooperación asíncrona
para cargar niveles. La operación asíncrona
nos da la opción de cargar el nivel es un proceso en segundo plano y podemos seguir rastreando
el progreso. A través de la cooperación asíncrona, obtenemos acceso al
progreso que va 0-1. Cuando el nivel está completamente cargado, el progreso no es
en realidad uno es 0.9. Esta diferencia de 0.1 está reservada para la variable bull,
permite la activación del pecado. Podemos controlar esa variable. Y si lo establecemos en false, aunque el siguiente nivel esté completamente
cargado en segundo plano, el valor de progreso no
puede superar 0.9 y no podemos pasar
al siguiente nivel. Cuando establecemos esta variable true y el nivel
está completamente cargado, el valor es uno, y podemos pasar a un nuevo nivel. Tenemos otra
variable importante que se hace. Esta variable es verdadera cuando
la barra de progreso es una, lo que significa nivel completamente
cargado con activación de pecado
permitida
y su fuerza. En cualquier otro caso. Utilizaremos estas variables
para crear una barra de carga. En primer lugar, creamos una variable de
operación asíncrona que
obtendremos el valor a través Scene Manager que
permitió ver Asincrónico. Esto cargará una nueva
escena en el fondo. Entonces establecemos la
activación del pecado en falso. Entonces tenemos el control. Necesitamos activar
la pantalla de carga. Y podemos establecer la cantidad de llenado de la
barra de carga a cero. Ahora usamos un bucle while. Mientras
se realiza la operación asíncrona es igual a false, lo que significa que el
nivel no está completamente cargado o la activación
se establece en false. Establecimos el monto de llenado para el progreso de la cooperación
asíncrona. Dado que el valor va a 0.9, necesitamos dividirlo por 0.9. Aquí no necesitamos usar una
espera 4 s. Podemos simplemente devolver null entre esas
líneas de código. Podemos verificar si el
avance es de 0.9. Nuevamente, eso significa que el nivel está completamente cargado en
segundo plano. Entonces permitimos la activación del pecado. En ese momento se hace la
variable, se hará verdadera la variable
y salimos del bucle while. Podemos eliminar esta línea de código. Ahora, podemos copiar el código. En otra
función fade-out, pegue el código. Sólo para reemplazar el
nombre del nivel con el índice de nivel. Tenemos que hacer una cosa más
en la función fade-in, necesitamos desactivar
la pantalla de carga. Ahora vuelve a Unity. Antes de conectar
objetos con el script, vamos a cambiarles el nombre para que no los
confundamos con
la barra real retenida. Luego usa el fondo de carga como objeto de pantalla de carga. Para la imagen de la barra de carga. Vamos a usar una carga. Vamos a probarlo. Cuando este nivel. Después ir a la siguiente. Observe que debido a que
el nivel es demasiado pequeño y estamos probando en PC, la carga es para pegar
y lo podemos ver. Pero en un dispositivo móvil, verías avances
en la barra de carga. Un truco más, si el fader Canvas está cubriendo
tu vista en la escena, puedes ocultarlo
con este botón. Y eso es todo por esta conferencia. Nos vemos en la siguiente.
36. Efecto de degradación de actualización/fijación: Hola a todos. Se trata de Mario del futuro. Más adelante en el curso, noté un error con
el sistema de desvanecimiento. Es muy específico,
pero necesitamos
abordarlo y arreglarlo con solo
dos líneas de código. Si ves algo
en Unity o en el código que aún
no hicimos. No te preocupes. Esto se debe a que
grabé este video después algunos episodios y decidí colocarlo
aquí en el curso. Rápidamente te mostraré el bicho. Aquí coloqué para depurar registros, uno para desvanecimiento y otro
para efecto de desvanecimiento. Seleccione el fader de lona. Ahora, voy a hacer que
el efecto fade sea más largo. Será más fácil
replicar el error. También, voy a utilizar, ya que eso hacemos
en el futuro, será más fácil de entender. Tengo una etiqueta de
oscilaciones vistas. Este botón inicia
el efecto de desvanecimiento y conduce a un nuevo nivel. Al principio, se puede ver que
todo funciona. Pero hay un caso si
presiono el botón y activo la función fade-out mientras
el fade in sigue funcionando, entonces dos bucles while
pelearán entre sí. Presionemos el botón mientras el efecto de desvanecimiento
sigue activo, puedes verlo en la consola. Al mismo tiempo, estamos disminuyendo y
aumentando el valor alfa. Debido a esto, podemos pasar
al siguiente nivel porque la
pantalla nunca se pondrá negra. Podemos arreglarlo de varias maneras. Mi camino es ir a
la función fade-in. En el bucle while, podemos verificar si la variable Fed
started es verdadera. Eso significa que activamos
el fade out, luego rompemos y salimos
del bucle. Eso es todo lo que tenemos que hacer. Ahora bien, si presiono el botón, el efecto de desvanecimiento se detendrá y el efecto de desvanecimiento
se hará cargo. Si quieres un
comportamiento diferente, por ejemplo, ese efecto de desvanecimiento debe terminar. Entonces puede verificar en la función de desvanecimiento
para el valor alfa. Si no es cero, entonces rompa y salga de
esta función. Ahora podemos presionar el
botón pero no
pasará nada hasta que termine el
desvanecimiento. Depende de ti elegir la
mejor opción para tu juego. Gracias por verte y
verte en la próxima conferencia.
37. Creación de fuentes: Hola a todos. En esta conferencia, pasamos por el
proceso de creación de recursos de
fuentes para nuestros
textos mesh text proud. Arrastraré la carpeta
de fuentes desde la otra pantalla. Puede encontrar el enlace a la página de descarga en
la carpeta de recursos. Puedes usar la misma fuente
o cualquier otra que desees. Ahora, hagamos clic derecho en el
lienzo y creemos un texto. Rápidamente le renombraré. Se puede ver que esta
es la fuente por defecto. Podemos intentar
cambiarlo directamente, pero no pasará nada. Necesitamos crear un
recurso de fuente para reemplazar la fuente. Ve a Ventana, Text mesh Pro
y abre el creador de activos de fuente. Como archivo fuente fuente, usa la fuente que quieras. Puedes ver algunas configuraciones, podemos dejar las predeterminadas. Quizás el
ajuste más importante es el modo renderizado. Para esta fuente, la configuración
predeterminada es buena. Si usas fuentes pixeladas, arrestar o modo es mejor. Por lo que depende de las vistas de fuente. Puedes probar diferentes opciones. Después haga clic en el botón Generar Atlas de
Fuentes. Entonces podemos guardar el activo de la fuente. Ahora, arrastre el activo Ve creado
al campo de activo de fuente. Y se puede ver la nueva fuente. Puedes jugar con
algunos ajustes para exportar el paquete de texto
Mesh Pro. También podemos reemplazar
la fuente que
usamos para las pantallas de ganar
y perder. Eliminar el texto de prueba. Después de habilitar todos los objetos
y establecer Canvas alpha en uno, podrás ver el resultado. Bonito. Eso es todo por esta conferencia.
38. Sistema de puntuación: Hola a todos. Vamos a crear
un sistema de puntuación en el que un jugador obtenga puntos cada
vez que destruye a los enemigos. Mostraremos el marcador en
la esquina superior derecha. Por lo que necesita ir
en la zona segura. Haga clic derecho en el
área segura y cree el texto. Cambiemos el ajuste preestablecido de anclaje
a la esquina superior derecha. Mantenga pulsada la opción Alt y Mayús y haga clic en. Cambiemos un poco la posición. Podemos ampliar un poco el
área de texto. Podemos cambiar la fuente. Este activo de fuentes lo creamos
en la conferencia anterior. Cambiemos la alineación. Yo elegiré el medio, pero tal vez puedas dejar
la alineación izquierda. Esto también va a la mitad. Ahora, escribamos
una puntuación de 1,000. Observe cómo va el texto
en el siguiente alineado. Para evitar eso, necesitamos
deshabilitar la superposición. Ampliemos un poco más el
área de texto. Por supuesto, puedes cambiar
el tamaño de fuente si quieres. Lo dejaré como está. Vamos al guión final del manager
del juego. Usaremos los componentes de malla de texto por paquete
en el script, necesitamos incluir
el espacio de nombres DNS. Entonces vamos a crear una variable
componente de texto. Ahora necesitamos una referencia
para este texto. Vamos a crear una función pública para registrar el texto de la partitura. Ahora podemos ir a la unidad para
crear un nuevo script C-sharp. Yo lo llamaré registro de
puntuación. El guión al texto
que creamos antes. No necesitamos la función de
actualización, necesitamos el espacio de
nombres DNS. En el inicio. Vamos a crear un componente de texto. Dado que el script está en el objeto que tiene
un componente fiscal, podemos usar Get component. Entonces podremos registrar el texto
al gestor del juego final. Es una buena idea
establecer el valor
de texto por defecto uno
con una puntuación cero. Vuelve al guión del
manager del juego. Ahora, podemos crear una puntuación variable
int. Vamos a crear una
función que
aumente la puntuación
y actualice el texto. Necesita tomar
un parámetro int. Primero, aumentamos la puntuación. Después actualizamos el texto. Dado que la partitura es un entero, necesitamos
convertirla en una cadena. Genial. La idea es
llamar a esta función cada vez que se destruye al
enemigo, Vamos al guión enemigo. En el guión enemigo en la función de secuencia de
deuda, que se llama cada
vez que muere enemigo, llamamos texto de puntuación de actualización. Por supuesto, necesitamos pasar
una variable a la función. Así que vamos a crear un valor de puntuación
variable int. Este valor
incrementará la puntuación. Tenga en cuenta que todo esto se hace
en la clase enemiga padre. Necesitamos actualizar las clases infantiles. Empecemos con
el guión de meteoritos. Cuando anulamos
esa secuencia, necesitamos llamar a la
base esa secuencia. A esto lo llamaremos todo
desde la clase base. Hagamos lo mismo con los enemigos
morados y verdes. Ir a la unidad. En la carpeta prefabs, seleccione prefabs NME y elija el valor de puntaje
para cada uno de ellos. Iré con diez
para todos ellos, pero puedes elegir valores
diferentes. Vamos a probarlo. A medida que destruimos enemigos, la puntuación aumenta en diez. Genial. Por supuesto, me gustaría mostrar el puntaje y
el puntaje más alto en las pantallas de ganar o perder. También necesitamos restablecer
el puntaje después de eso, ir al guión del
administrador del juego final. Si recuerdas, tenemos
las funciones de ganar y perder. Aquí mencioné que tenemos que
hacer algo al respecto de la partitura. Necesitamos mostrar la puntuación, verificar la puntuación más alta
para este nivel y luego restablecer la puntuación. Para hacer todo eso, necesitamos saber algo
sobre cómo guardar y cargar datos, que aprenderemos en
las próximas conferencias. Nos vemos ahí.
39. Sintaxis de Playerprefs: Hola a todos. Este es un video rápido que explica
la sintaxis de las prefs del reproductor. Usando ejemplos simples,
veremos cómo guardar y
cargar datos básicos. Creé un guión de ejemplo. No hace falta que lo escribas. Sólo tienes que seguir y tratar de
recordar la sintaxis. Aquí tengo tres variables
que quiero guardar. Observe que utilicé tres tipos de datos que
podemos guardar con las prefs del jugador. Y esos son integer,
float y string. Entonces para guardar datos,
usamos PlayerPrefs, ese conjunto y luego
elegimos el tipo. El primer ejemplo, usamos
set int entre paréntesis. Primero, escribimos la clave de cadena, que contendrá
el valor que guardamos. Puedes nombrarlo como quieras. Elegí int k, después escribimos el valor a guardar, en este caso ejemplo int. La misma lógica se aplica cuando un flotador de ahorro y valores de
cadena. Entonces, ¿cómo cargar unos valores guardados? Vamos a utilizar este caso. También creé variables en las que cargaremos
los valores guardados. Para cargar los valores, usamos PlayerPrefs que obtienen, por
supuesto, podemos obtener
integer o float o string. Entre paréntesis, escribimos
la clave para cargar valores. Entonces la clave cargará el valor int
ejemplo que guardamos. Solo asegúrate de escribir correctamente la K Si echas de menos algunos
encendedores o algo así, esto no va a funcionar. La segunda parte
entre paréntesis es opcional. Determina el valor predeterminado si no hemos
almacenado nada previamente. En este caso, puede
ser cualquier valor que quieras. Yo solo lo puse a
cero y nada. Para eliminar los valores guardados. Usamos la
función Delete key entre paréntesis, escribimos la clave de cadena
que necesitamos eliminar. Además, hay una
opción para eliminar todos los datos guardados con la función
delete all. Por supuesto, al probar, eliminar todos los datos guardados
del código puede ser poco práctico. Entonces en Unidad, podemos ir a Editar. Y aquí tenemos el comando clear
all player prefs. Eso es todo por esta conferencia. Ahora que conocemos la sintaxis, podemos crear un sistema de
highscore.
40. Guardar y cargar Puntuación/alta: Hola a todos. Ahora que conocemos la sintaxis
del reproductor pref, podemos crear un sistema de guardar
y cargar. El objetivo de esta conferencia
es guardar la puntuación para cada nivel y
determinar una puntuación alta. Vayamos al guión final del manager
del juego. Necesitamos crear una
función que guarde la puntuación y actualice la puntuación más
alta si es necesario. Así que crea la función de
conjunto de puntajes. Vamos a usar player prefs set int. La clave será la partitura combinada con el nombre
de la escena actual. De esa manera, cada nivel
tendrá una clave diferente, y eso es lo que queremos porque cada nivel tiene su propia puntuación. El valor que ahorramos es, por
supuesto, la puntuación. Entonces vamos a crear uno
en la variable highscore. Utilizamos el valor get int. La clave será la puntuación más alta
combinada con el nombre de la escena. El valor predeterminado
debe ser cero. Entonces comprobamos si el puntaje es mayor que el puntaje más alto. Eso es cierto, entonces el puntaje es un nuevo puntaje alto
y podemos guardarlo. Utilice la
clave de puntuación más alta y guarde el
valor de puntaje para esa clave. Lo último que necesitamos
es restablecer la puntuación. Ahora, tenemos que
llamar a esta función en las funciones ganar y perder. Solo asegúrate de llamarlo
antes de que activemos las pantallas. Esto es realmente importante
para el siguiente paso. Esto es todo lo que tenemos que hacer
en el manager del juego Unity. Quiero mostrar la puntuación y
la puntuación más alta en las pantallas de
ganar y perder. Seleccionemos el panel y aumentemos alfa a uno para que podamos ver lo que estamos haciendo
habilitado el parabrisas. Necesitamos organizar esta pantalla y agregar algunos componentes de textos. Cambiemos el color y pongamos el ancla en
la parte superior media. Podemos agregar
efectos extra a este texto. Habilitado el calco base. Voy a usar color blanco
con menor opacidad. Ahora puedes jugar con los
ajustes y cambiar el desplazamiento. Creo que esto se ve bien. Ahora necesitamos el texto para
score y highscore. Duplica este texto, cámbiale el nombre. Tenemos que cambiar los
anclajes al medio. Ajusta un poco el área de texto. Por supuesto que necesitamos
una fuente más pequeña. Cambia el texto para que
tengamos una mejor vista previa. La alineación necesita ser dejada. También podemos desactivar la
superposición si es necesario. Vamos a moverlo hacia abajo. Después duplicarlo. Esta será la puntuación. Cambia el color y cámbiale el nombre. Tu mini reto es hacer lo mismo para la pantalla de Lewis. Este es el resultado final. Como pueden ver, cambié
el color para esta pantalla. Deshabilitémoslos y
devolvamos alfa a cero. Vamos a crear un nuevo guión
C-sharp que se encargará de mostrar la puntuación en las pantallas de
ganar y perder. Y ábrela. Eliminar funciones predeterminadas. Necesitamos incluir los espacios de nombres de TM pro en scene management. Luego crea dos variables de texto, una para la puntuación y
otra para la puntuación alta. Entonces usamos la propia función
enable. Esto significa que el código se ejecutará cada vez que
habilitamos el objeto, y este script irá en los objetos de pantalla de ganar y perder. Primero, creamos una puntuación variable
local en la que cargamos
el valor de puntaje. Usa la función get. La forma más segura de escribir la clave correctamente es copiarla, pegarla, ir al administrador del juego final
y copiar la clave de puntaje. El valor predeterminado puede ser cero. Ahora vamos a actualizar el
texto con esa variable. Haz lo mismo para la puntuación más alta. Solo asegúrate de
copiar la clave correcta. Eso es todo lo que necesitamos para codificar. Vayamos a Unity. Agrega el guión a las pantallas de
ganar y perder. Ahora necesitamos configurar una referencia
para las variables de texto. Usa el
texto de puntaje alto y puntaje que creamos anteriormente. Y eso es todo lo que podemos probar. Se puede ver la puntuación y
la puntuación más alta. Ahora. Es entonces, volvamos a jugarlo. Se pueden ver los valores actualizados. A lo mejor las pantallas son demasiado pequeñas, así que siéntete libre de cambiar
las dimensiones. Nos vemos en el siguiente video.
41. Preparación de escena: Hola a todos. En esta conferencia, preparamos pecados para que podamos crear
fácilmente una escena de apertura, una
escena de capa de selecciones y nuevos niveles. Esto es solo preparación,
nada especial, pero tenemos
que hacer eso para que podamos ser más rápidos y eficientes
en las próximas conferencias. Primero, necesitamos
crear Prefabs, seleccionar los managers,
spawners en controladores. Podemos seleccionar la
condición de ganar Canvas y el jugador los
arrastra a la carpeta Prefabs. Guarda esta escena con Control S. Ir a la carpeta Escenas. Estamos en un nivel uno, así que duplicarlo, renombrarlo
para iniciar la pantalla y abrirla. Esta será la primera escena que el jugador vea al
entrar al juego. Podemos eliminar algunos objetos. Eliminemos spammers, lápiz o
controlador cuando condicione, todo lo que esté conectado
con la cámara virtual. Después el jugador en
una cámara virtual. También eliminemos el componente cerebral
de la máquina de cine de la cámara principal. Voy a usar un texto
del Lienzo. Este será el ganador. Gracias a usarlo, necesitamos desempacar el prefabricado. Ahora estoy arrastrando el texto
debajo del área segura. Podemos eliminar el panel. También podemos eliminar la
puntuación y la barra de salud. Cambiemos el nombre del texto. Este será el nombre del juego. Expande el área de texto, aumenta la fuente y cambia el ajuste preestablecido de anclaje a la mitad superior. Esta es una buena posición ya que no
estamos usando cin y
machine en cámaras virtuales. Seleccionemos la cámara principal
y ajustemos el tamaño a cinco. Veamos cómo se ve. No está mal. Cambiemos el
color del texto. El color del vértice
necesita ser blanco. Ahora habilitado degradado de color. Voy a usar un gradiente
horizontal. El primer color será amarillo, el segundo color será naranja. Genial. Guardemos la
escena y la dupliquemos. Llamó a la nueva
selección del nivel del mar y ábrala. Simplemente voy a cambiar el texto
para que podamos reconocerlo. Este es un nivel de selección. Por supuesto,
puliremos y agregaremos características a estas cosas
en las próximas conferencias. Recuerda que esto es solo
una pequeña preparación. Guarde la escena y abra
la configuración de compilación. Ahora, agreguemos
cosas nuevas a la compilación. Cambiar el orden para que el inicio de ver
sea el primero, luego la selección de nivel
y luego los niveles. Bien, eso es todo por ahora. En la siguiente conferencia, terminamos el empezar a ver.
42. Pantalla de inicio (menú): Hola a todos. En esta conferencia, implementamos la
mecánica de tap para jugar en el pecado de inicio. Así que asegúrate de
abrir la estrella para ver y luego haz clic derecho en el
lienzo y crea una imagen. Llámalo tap para reproducir el gatillo. Tenemos que estirarlo. Luego establece el
valor alfa en cero. Ahora agreguemos el componente
activador de eventos. Lo usamos para crear
un nuevo tipo de evento. Se pueden ver algunos eventos, por ejemplo, el
puntero hacia abajo es cuando
presionamos en la pantalla, más precisamente en la imagen
transparente que creamos. Por supuesto, apuntador hacia arriba es
cuando levantamos el dedo. Úsalo. Crear un nuevo evento. Ahora necesitamos arrastrar el objeto de control de
botón. Usaremos el
nivel de carga de la función string. Después cargue el nivel
de nivel de selección. Genial. Cuando tocamos la
pantalla y el dedo, debemos activar el evento. Derecha. Haga clic en cualquier parte
de la pantalla. Funciona. Ahora, agreguemos algunos
elementos visuales a esta escena para que se vea mejor
en la zona segura, vamos a crear un nuevo texto. Cambia el ancla a
la mitad inferior. Colócala así. Podemos cambiar la fuente, expandir el área de texto,
cambiar la alineación. Se debe tocar la entrada de texto para reproducir. Cambiar el tamaño de fuente. Para hacerlo más interesante, quería crear
este efecto parpadeante. Deberíamos crear un guión, pero usaré animación
para este texto. Importante, como dije, animar los elementos de la interfaz de usuario
es un rendimiento caro y se debe
evitar eso normalmente. Pero para esto, empezar a
ver que tiene muy pocos elementos y estamos sólo en él un par de segundos, podemos salirnos con la suya con cualquier
encuentro un elemento. Así que vamos a crear una animación. Yo lo llamaré animación de tap. Pulsa el botón de grabación y
anima el valor alfa. Veamos la vista previa. Es un poco rápido. Vamos a establecer el tamaño de la muestra en 30. Esto se ve bien. Vamos a probarlo. Toca en la pantalla. Genial. También podemos agregar el
sprite de la nave espacial a este nivel. Establezca la posición en 00 y aumente el
orden en una capa. Disminuir un poco el tamaño. Y ya terminamos. Nos vemos en la próxima conferencia.
43. Configuración de la interfaz de usuario: Hola a todos. En esta conferencia, creamos elementos de interfaz de usuario
para la selección de niveles. Como puedes ver, construimos
un bonito sistema de desplazamiento. Para comenzar, asegurémonos abrir el nivel de selección de nivel, explicó el lienzo, y debajo del área segura,
creamos un botón. Cambiemos la imagen de origen. Usa el sprite de icono de nivel, establece un tamaño nativo. Ahora cambiemos
una configuración de texto. El color tiene que
ser blanco, ¿verdad? Cualquier número, no importa. Serán asignados
automáticamente. Podemos aumentar el tamaño de la fuente. Voy a cambiar el
área de texto un poco genial. Podemos cambiar la fuente. Esta fuente es un poco más grande. Tal vez puedas desactivar el rapeo o simplemente disminuir un poco el tamaño. Esto tal vez sea demasiado pequeño, lo
pondré en 39. Podemos escribir fácilmente números
de tres dígitos
con este tamaño de fuente. Ahora, seleccione el botón. Necesitamos agregar un evento al hacer clic. El botón necesita
usar el controlador de botón. Y necesitamos el
nivel de carga de la función string. Este botón
conducirá al nivel uno. Esto es solo un botón de plantilla. Ahora podemos crear
el área de desplazamiento, hacer clic derecho en el área segura y crear un objeto de juego vacío. Yo lo llamaré nivel base. Ahora, cambiemos
las dimensiones. Estamos estableciendo los límites del área de
desplazamiento. Después haga clic derecho en la
base del nivel y cree una imagen. Lo llamaré fondo de
ventana gráfica. Estirarlo. Para
la imagen de origen, use el sprite de panel grande. Asegúrese de que el tipo de
imagen esté cortado en rodajas. Simplemente voy a cambiar el color. Ahora, haga clic con el botón derecho en la ventana y cree un objeto de juego vacío. Llámalo un contenido de cuadrícula. Configure los Presets de
Anclaje en la parte superior central. Ahora agreguemos el componente de grupo de
diseño de cuadrícula. Este componente organizará
los botones en una cuadrícula. Necesitamos un componente más que se llama filtro de tamaño de contenido. Se ampliará las dimensiones de este objeto es que añadimos botones, ajustamos el
ajuste horizontal y vertical al tamaño preferido. Arrastremos el botón
debajo del contenido de la cuadrícula. Ahora, podemos duplicar
el botón. Y se puede notar que debido al componente de
diseño de cuadrícula, están dispuestos integrar. Cambiemos algunos ajustes. El tamaño de la celda puede ser de 200. Podemos establecer un número fijo
de columna. Usemos tres. Podemos agregar espaciado entre botones y algo de relleno
en la parte superior e inferior. Además, fijemos la alineación
al centro superior. Como puedes ver, podemos
crear fácilmente una cuadrícula de botones. Agreguemos más botones. Observe un problema. Los botones son visibles
fuera del fondo. Tenemos una solución fácil. Seleccione el fondo de la ventana y, a
continuación, agregue máscara directa
al componente. Esto se ve mejor. Solo necesitamos
ajustar el acolchado. Observe cómo los botones se
sobreponen al borde. Ajuste el
acolchado inferior y superior en 15. Genial. Finalmente, podemos seleccionar el objeto base de nivel y agregar el
componente scroll erect o el contenido. Usemos el contenido de la cuadrícula. Podemos desactivar el desplazamiento
en dirección horizontal. Solo necesitamos vertical. Para la ventana gráfica, utilice el objeto de fondo de
ventana gráfica. Vamos a probarlo. Se ve bien. Podemos desplazarnos hacia arriba y hacia abajo. Por supuesto, puedes cambiar la configuración y el comportamiento
del desplazamiento. A mí me gusta poner a cero esta tasa de
desaceleración. Ahora tenemos configuración de interfaz de usuario para
la selección de nivel. En la siguiente conferencia agregamos la funcionalidad
y desbloqueo de niveles. Nos vemos ahí.
44. Selección de nivel: Hola a todos. En esta conferencia, creamos un sistema de
selección y desbloqueo de niveles completamente funcional. Cuando el jugador gane
el primer nivel, el segundo se
desbloqueará y así sucesivamente. Tenemos que ir al guión final del manager
del juego. Como pueden ver mencioné antes eso en la función de
videojuegos, necesitamos desbloquear
el siguiente nivel. Pero primero, vamos a
crear una variable. Este será un desbloqueo público a nivel
String. No queremos
cambiar nunca esta cadena, así que vamos a esconderla
en el inspector. Esta cadena
se utilizará como clave para guardar y cargar datos. Cuando pasamos un nivel, necesitamos obtener el
número de índice del siguiente. Así que vamos a crear una variable de
siguiente nivel entero. El valor será
el nivel actual de índice de construcción incrementado en uno. Entonces comprobamos si ese índice de
siguiente nivel es mayor que el valor que
almacenamos en la clave de desbloqueo de nivel. Establezca el valor predeterminado en cero. Si eso es cierto, entonces guardamos el
siguiente índice de nivel a la clave de desbloqueo de nivel. La clave, tendremos el índice de nivel desbloqueado
más alto. Eso es todo lo que necesitamos para
codificar en el manager del juego. En Unity, crea un
nuevo script C-sharp. Yo lo llamaré iconos de botón. El script a ese nivel
base objeto y abrirlo. Necesitamos usar el espacio de nombres de la interfaz de usuario. Entonces vamos a crear
algunas variables. Necesitamos una matriz de botones. Entonces necesitamos
sprites para botones, uno para desbloquear y
otro para botones Bloqueados. También necesitamos el número
del índice construido de primer nivel. ¿Cuál es ese número? Si echas un vistazo a
la configuración de compilación, puedes ver que
el primer nivel en nuestro caso comienza con
el índice construido dos. Bien, ahora necesitamos
la función despierta. Se llama solo una vez
antes de la función de inicio. Primero, necesitamos obtener un índice del nivel de lista
desbloqueada. Así que el nivel desbloqueado
obtendrá un valor de la clave de cadena que hicimos
al final del juego manager. Es importante establecer el valor predeterminado en el índice construido de
primer nivel. Entonces vamos a crear un
bucle for para pasar por
la matriz de botones. Por cada botón,
comprobamos si el índice I más el primer nivel es menor o igual a la variable de
nivel desbloqueada. Yo empiezo desde cero. Entonces necesitamos agregar ese valor de índice de
primer nivel. Recuerda que la variable de
nivel desbloqueado es el índice del nivel desbloqueado
más alto. Eso significa que cada nivel con un índice más bajo necesita
ser desbloqueado. Entonces primero, establecemos el botón con el índice I a interactable, luego establecemos el sprite de la
batuta en icono desbloqueado. Ahora necesitamos acceder al texto. Necesitamos incluir
el espacio de nombres pro. Cree una variable de texto, luego use el botón y obtenga un componente en la función
hijos. Recuerda que el texto es un objeto
hijo del botón. Entonces tenemos que establecer
el valor del texto. Después de eso, solo
se asegura de que el texto esté habilitado. En otros casos,
los niveles están bloqueados. Así que tenemos que establecer el botón variable
interactable en false. Establezca el sprite
en el icono bloqueado. Además, necesitamos deshabilitar
el componente de texto. Eso es todo lo que necesitamos para codificar. Ir a los iconos de unidad, asignados, desbloqueados y bloqueados. Comprobemos dos veces el
primer nivel, build index. El índice del
primer nivel es dos. Después agrega botones a la matriz. En este punto, cada botón
conducirá al nivel uno. Necesitamos seleccionar botones
uno por uno y cambiar los valores. Este botón conducirá a
un nivel al siguiente, al nivel tres y así sucesivamente. Esto es lo único que
tenemos que hacer manualmente. Es un trabajo de cinco a diez minutos, dependiendo del
número de botones. Hay formas de hacerlo
automáticamente con scripts, pero eso está más allá del
alcance de este curso. Por ahora, no es necesario
cambiar todos los botones. Solo necesitamos botones para dos
o tres capas para realizar pruebas. Antes de probarlo, pasemos al primer nivel. Aquí necesitamos
ajustar algunos botones. El botón de inicio en la vena, y las pantallas más bajas deben conducir
a la selección de nivel. Ahora podemos probarlo. Empezamos el juego. Ir a la selección de nivel. Dado que es la
primera vez que jugamos, solo se
desbloquea el primer nivel y otros están bloqueados. Tratemos de pasar
el nivel personal. Ahora, podemos ver que el
nivel dos ha sido desbloqueado. Genial. En la próxima conferencia, te
mostraré cómo crear
fácilmente nuevos niveles. Entonces podrás conectar
todas las batallas con niveles
creados. Nos vemos ahí.
45. Cómo crear niveles: Hola a todos. En esta conferencia, te
mostraré cómo crear
fácilmente nuevos niveles. Podemos eliminar el nivel dos. Es una copia antigua. Por ahora, tenemos todo
lo que necesitamos en un nivel uno, se pueden
ver todos
los gerentes, controladores y otros prefabs en este nivel. Ahora duplica esta escena y
llámalo cadena de plantilla. Ábrela. Esta escena contiene todos
los objetos necesarios para crear un nivel
funcional básico. Ahora, podemos duplicar
esa plantilla vista. Esto puede ser el nivel dos. Ábrela. Ahora es fácil agregar o
eliminar prefabricados, por ejemplo, podemos eliminar el
socio de medidores en este nivel. También podemos cambiar los números, por ejemplo, esta hora de la libra. Si necesitas enemigos diferentes, puedes reemplazar los prefabricados. Seleccione la condición de ganancia y actualice esta matriz. No tenemos socios medidores, así que borra el campo vacío. También podemos cambiar
el temporizador de viento. Ahora tenemos un nivel completamente
diferente. Vamos a crear un nivel tres. Duplicar esa plantilla
se ve. En este nivel. Se pueden establecer variables
a diferentes valores. Esto es sólo un ejemplo. Entonces los configuraré
al azar sin pruebas. Por supuesto, si tienes algún otro Spanner Prefabs o cualquier otra cosa para este nivel, puedes simplemente
arrastrarlos a esta cosa. Solo asegúrate de
actualizar la configuración de compilación. Y así es como puedes crear
fácilmente unos niveles. Para pruebas. Simplemente crea
dos o tres niveles. No crees demasiado porque
tendremos que actualizar la plantilla vista con
el nuevo contenido
más adelante en el curso. Yo solo quería
mostrarte el proceso, pero hay que
hacerlo cuando tienes todas las cosas conectadas
entre objetos. Posteriormente, creamos
EDS y Power Apps que necesitan estar
conectados al reproductor. Téngalo en mente y nos
vemos en la próxima conferencia.
46. Construye un teléfono Android para probar: Hola a todos. En esta conferencia, con fines de prueba,
construiremos el juego en nuestro dispositivo Android. Tenemos suficiente contenido
para probar el juego y ver cómo se siente
en un dispositivo móvil. Antes de comenzar,
asegúrate de tener instalado
el módulo de Android para la versión de Unity que uses. Luego ve a Configuración de compilación y asegúrate de usar
la plataforma Android. Hicimos todo eso al inicio
del curso, pero solo quería
repetirlo por si te perdiste algo. Ahora, ve a la configuración del jugador. Aquí puedes encontrar algunas opciones como nombre de empresa y juego, versión e iconos para probar. No necesitamos cambiarlos, tal vez solo el nombre de la empresa. Pasemos a la resolución
y presentación. Por defecto, la rotación exterior se selecciona con todas las orientaciones. Limitemos esto
al modo retrato. Después ve a otros ajustes. Para la versión editorial, necesitaremos
cambiar más ajustes. Pero para las pruebas,
vamos a desactivar esta anulación de identificador de paquete. Y para el nivel de API objetivo, elija la que tenga
el número más alto. Ahora, necesitamos conectar nuestro dispositivo
móvil a nuestro PC. En un dispositivo móvil, necesitamos habilitar el
modo de depuración, ir a la configuración. El siguiente procedimiento puede ser
un poco diferente para ti. Depende del dispositivo, pero por lo general necesitamos
encontrar sobre el teléfono. Después abre la información del
software. Ahora, escriba algunas veces
en el número de compilación. Deberías ver una ventana emergente en la
que se
ha activado el modo desarrollador . Ahora, vuelve a la configuración. Desplázate hacia abajo y deberías
ver la opción de desarrollador. Asegúrate de que esté encendido. Entonces encuentra la depuración USB,
actívela , y
ese debería ser todo. En Unity, puedes presionar Refresh y deberías
ver tu dispositivo. Si no lo ve
reconectado y asegúrese tener activado
el uso compartido de archivos
a través de USB. Entonces podemos presionar, construir y ejecutar, crear una
nueva carpeta para la compilación. El nombre del archivo
será Space Shooter. Haz clic en Guardar, y espera unos
momentos cuando lo hagas, la primera vez,
lleva un poco más de tiempo. Bill debería aparecer en tu PC
y en tu dispositivo móvil. Además, debería
iniciar automáticamente el juego en
tu dispositivo móvil. Ahora puedes probar el juego
y tener una mejor sensación. Como puedes ver, todo
funciona tal como debería. Bonito. Además, cuando haces
algunos cambios en Unity y quieres
probar la versión actualizada, luego habilita el desarrollo, la construcción y el hit pitch and run. Genial. Ahora ya sabes cómo probar tu
juego en un dispositivo móvil. Nos vemos en la próxima conferencia.
47. Construye un teléfono iOS para probar: Hola a todos. En esta conferencia, con fines de prueba,
construiremos el juego en nuestro dispositivo iOS. Tenemos suficiente contenido
para probar el juego y ver cómo se siente
en un dispositivo móvil. Observe que estoy usando Windows, pero para construir el juego en iOS, necesitaremos una computadora con micrófono
más adelante en el proceso. Antes de comenzar,
asegúrate de tener instalado
el módulo iOS para
la versión de Unity que uses. Luego ve a Configuración de compilación y asegúrate de usar
la plataforma iOS. Ahora ve a la configuración del jugador. Aquí, puedes encontrar algunas
opciones como compañía en aversión al nombre del
juego e
iconos para probar. No necesitamos cambiarlos, tal vez solo el nombre de la empresa y eliminar espacios
del nombre del producto. Pasemos a la resolución
y presentación. Por defecto, la rotación exterior se selecciona con todas las orientaciones. Limitemos esto
al modo retrato, luego vayamos a otros ajustes. La versión editorial,
necesitaremos cambiar más ajustes. Pero para las pruebas, vamos a desactivar esta anulación de
identificador de paquete. Vuelve a Configuración de compilación. Ahora necesitamos crear una compilación, crear una nueva carpeta y luego iniciar el proceso. Puede tardar algún tiempo en terminar. Aquí está la carpeta
con todos los datos. Ahora, necesitamos transferir esta
carpeta para hacer computadora. Déjame cambiar para hacer. Como puedes ver aquí, tengo la carpeta Build en Mac. Dentro de la carpeta, deberías
encontrar el proyecto Xcode. Si no tienes la aplicación
Xcode, solo tienes que ir a la App Store, buscar Xcode e instalarla. Es completamente gratis,
pero solo está disponible en micrófono. Abrir el proyecto Xcode. Selecciona el iPhone de la unidad, y verás algunos ajustes. La mayoría de ellos serán de Unity. Si falta algo, puedes editar rápidamente. Otra vez. Esto es solo para una compilación de prueba, por lo que no es
necesario entrar en detalles. Lo importante es
ir a la sección de firma. Aquí, necesitamos habilitar la firma
automática. Ahora necesitamos agregar una
cuenta de equipo que puede ser solo usted. Para crearlo, vaya a Xcode, cuentas de
preferencias, y
haga clic en el botón más. Usa tu ID de Apple para iniciar sesión. Después de eso, es necesario agregar
un certificado de desarrollo. Ir a Administrar Certificados. Haga clic en el botón más y agregue el
certificado de desarrollo APL. Volver a la sección de firma. Ahora podemos elegir una
cuenta de equipo que hicimos. Ahora, necesitas
conectar tu iPhone a tu Mac. En tu teléfono. Ve a Configuración, encuentra
privacidad y seguridad. En la parte inferior, deberías
ver el modo desarrollador. En ocasiones para ver esta opción, el Xcode debe estar abierto, lo contrario no lo verás. Habilitemos el modo desarrollador. Tu teléfono se reiniciará. Después de la muerte en Mac. Asegúrate de
seleccionar tu iPhone. Para empezar a construir el juego. Haga clic en el botón de reproducción. Esto llevará algún tiempo. Si obtienes algún
error intenté abrir tu proyecto Unity en Windows
con una versión diferente. En realidad, obtuve algún error
extraño que no
pude resolver con
todas las correcciones posibles. Resulta que es por
la versión Unity 22. Algo anda mal. Estoy seguro que lo
arreglarán en el futuro. A lo mejor no tendrás errores
con la última versión. Pero necesitaba abrir mi proyecto en Windows en la versión Unity 21, construirlo y transferir archivos en Mac y repetir
todo este proceso, entonces todo estuvo
bien sin errores. Si recibes este mensaje emergente, simplemente escribe la contraseña
que usas para iniciar sesión en tu Mac y haz clic
en permitir siempre. Cuando termine la compilación, verá este mensaje. El juego no se pudo abrir en tu iPhone porque necesitamos
confiar en el desarrollador. En el teléfono. Ve a Ajustes. Administración general de dispositivos. Aquí verás esa aplicación
para desarrolladores abrirla, entonces necesitas
confiar en el desarrollador. Ahora puedes encontrar el
juego y probarlo. Juguémoslo un poco para
ver si todo funciona. Bien, Todo está bien. Así es como pruebas tu
juego en tu iPhone. Que tenga un buen día y nos
vemos en la próxima conferencia.
48. Spawner de objetos Scriptable: Hola a todos. En esta conferencia, creamos un
objeto scriptable que nos
ayudará a spam Power Apps. Script double object es un contenedor de datos independiente
de las instancias de clase, algo así como un activo. Son muy útiles para ahorrar
memoria porque son realmente pequeños,
livianos y optimizados. Veamos cómo podemos crear
un objeto scriptable. Primero, vamos a crear una carpeta. Después crea un guión. Lo llamaré ejemplo de
objetos scriptables, y lo abriré. Eliminar todas las funciones. Y en lugar de comportamiento mono, vamos a heredar del objeto
scriptable. Estos
objetos scriptables contendrán una referencia a los prefabs de
Power App. Así que vamos a crear una
matriz de objetos de juego. A continuación, vamos a crear una función que se encontró una
de las Power Apps. Tiene que ser público
y se necesita un vector, tres parámetros para
esta posición de libra. Consigamos un índice aleatorio. Entonces podemos usar la función
Instanciar. Spam, el poder con
ese índice aleatorio. Usa la posición de desove y la rotación. Para crear un script de
un objeto como activo, necesitamos usar el atributo create
Asset menu. Entonces podemos usar un nombre de menú que serán objetos
scriptables. Socio de Power Apps. Te voy a mostrar cuál es
el nombre de este menú en un segundo. Primero, agreguemos un nombre por defecto al objeto que vamos a crear. Yo lo llamaré spawner. No importa. Lo cambiaremos de todos modos. Ir a la unidad. Haga clic con el botón derecho, vaya a Crear. Y ahora deberías ver los objetos
scriptables
encienden spammer, ese es el nombre del menú que elegimos. Así que vamos a crear un Socio
de Power Apps. Como puedes ver, el nombre
predeterminado es Spawner. Lo voy a cambiar para
encender el spamming o básico. Ahora deberías ver la matriz de Power Apps en el inspector. Aquí, agregaremos los Prefabs
que necesitamos para librar. Observe cómo es fácil crear otros objetos scriptables que puedan tener diferentes prefabs. Sólo necesitamos uno. Así que borra esta. Agreguemos algo de
aleatoriedad al escupir. Primero, necesitamos un umbral de span
entero. Entonces en la función podemos
obtener un número aleatorio 0-99. Recuerda, el último
número no está incluido. Después de la muerte. Comprobamos si el número aleatorio de probabilidad es
mayor que este umbral. Si eso es cierto, entonces necesitamos crear una
instancia de una Power App. Vayamos a la unidad. Podemos establecer este
umbral límite en 80. Entonces, cuando obtengamos un número mayor, entonces abarcaremos una
de las Power Apps. Las posibilidades alrededor del 20 por ciento, precisamente en 19%, ya que
el número máximo es 99. Entonces, cuando Power Apps, mi idea es echarlos a chorro cuando el jugador
destruye meteoros, pero también puedes encontrarlos
fácilmente si se destruye cierto enemigo. Y digamos la versión del medidor, vaya al guión de meteoritos. En la secuencia de muerte, necesitamos llamar a una función
que expanda Power Apps. Pero primero, necesitamos un script
de una variable de objeto. Yo lo llamaré power
up como fundador. Es una buena idea comprobar que este parámetro no sea nulo. Entonces podemos llamar a la función desde los objetos scriptables. La función paga la
posición del meteoro. Eso es todo lo que necesitamos para codificar. En Unidad. Seleccione los prefabricados de meteoros. Necesitamos configurar una referencia
para los objetos scriptables. Arrastrar los
objetos scriptables al vacío no pudo probar chispeante. Podemos seleccionar los objetos
scriptables y arrastrar cualquier prefab
a la matriz. Voy a usar la
rejilla enemiga prefab. También modificaré este nivel, una libra más de meteoros. Simplemente borra la llave del enemigo, luego disminuye el tiempo de generación
para obtener más meteoros. Por supuesto, necesitamos seleccionar la condición de ganar y modificar
el tamaño de la matriz. Vamos a probarlo. Cuando lo destruimos, un meteoro, el enemigo puede exponer. Genial. En las siguientes dos conferencias, creamos potenciadores para los objetos scriptables
pounder. Nos vemos ahí.
49. Salud para arriba: Hola a todos. Veamos cómo podemos crear
coleccionables y Power Apps. En esta conferencia, creamos una Power App que
sanará al jugador. Primero, necesitamos una
Power App, sprite. Usa el amarillo. Aumente el orden de clasificación a cuatro. Ahora agreguemos algunos
componentes. Cuerpo rígido 2D. No necesitamos
cambiar ninguna opción. En realidad queremos
gravedad en este caso. Ahora, agreguemos el
box collider 2D. Tiene que ser un detonante. Entonces podemos ajustar el
tamaño del colisionador. Esto se ve bien. Vamos a crear una capa
para coleccionables. Necesitamos cambiar la matriz de
colisión. La capa de coleccionables
necesita chocar solo con el jugador. Ahora, podemos crear una
nueva carpeta y script. Yo lo llamaré poder aquí arriba. Agregue el script al objeto. Vamos a abrirlo. Primero. Necesitamos una
variable entera aquí, cantidad. Entonces podemos usar el On Trigger
Enter para la función. Debido a sus métricas de capa, sé que este objeto
colisionará justo el
camino hacia el jugador, pero tal vez necesites este poder hasta para chocar
con más objetos. Entonces podemos verificar si el
objeto tiene el tag player. Aquí, sanaremos al jugador. Necesitamos crear una función
en el script de estadísticas del jugador. Vamos a abrirlo. En los estados jugador, crear una nueva función pública. Llámenlo agregar salud. Se necesita un parámetro int. Aquí aumentamos la
variable de salud ancho, cantidad de talón. Después verifique si la salud actual es mayor que la salud
máxima. Si eso es cierto, pongamos la salud
en el valor máximo. De esta manera, no podemos tener más saludable que
el valor máximo. También necesitamos actualizar
la Barra de Salud. Volvamos al
Power App Script. Aquí, necesitamos obtener el componente de estadísticas del jugador
de la colisión. Luego llame a la función Agregar
salud. Después de la muerte destruyó
el objeto powerup. Esto es todo lo que necesitamos para codificar. Regresa a Unity. Vamos a sentarnos cantidad de talón. Luego crea un prefabricado. Podemos eliminar uno
de la escena. Ahora vamos a los objetos scriptables que hicimos en la conferencia
anterior. Este enemigo verde era
sólo para probar. Vamos a reemplazarlo con
el prefabricado de talón que hicimos. Entonces solo asegúrate de que los meteoros usen los objetos
scriptables. Eso lo hicimos en la conferencia
anterior, pero por
si acaso te pierdes algo, ya
podemos probarlo. Dañemos al jugador, luego destruyamos medidores y
la Power App debería abarcarse. Genial, todo funciona. Nos vemos en la próxima conferencia.
50. Potencia de escudo: Hola a todos. En esta conferencia, creamos un escudo Power App que
protegerá al jugador. Primero, usemos
un sprite de escudo. Cambiar el nombre, y
el orden en la capa 25. Observe una cosa extraña. La hoja de cálculo se ve en
bloque y realmente mala. Este sprite tiene algún gradiente y causa este problema de
renderizado. Para arreglarlo, seleccionemos
el sprite de escudo. Necesitamos anular algunas
configuraciones para Android e iOS. Habilite la anulación para iOS. Después cambia el formato a esto. Aplica cambios y
verás mejoría. Se ve mucho mejor. Ahora selecciona Configuración de Android
y haz lo mismo. No olvides
cambiar el formato. Pondré un enlace a la lista
de formatos y
configuraciones compatibles para que encuentres las
mejores opciones para tu juego. Ahora, vamos a arrastrar el escudo
debajo del prefab jugador. Ajusta un poco la posición. Entonces necesitamos agregar el colisionador de
polígonos 2D. Tiene que ser un detonante. También podemos editar
el colisionador llamado Control y hacer clic en las
líneas para borrar algunos vértices, menos vértices,
mejor rendimiento. Esto está bien. Puedes dedicar más tiempo
a esto si lo deseas. Vamos a crear una nueva
capa para el escudo. Llámalo escudo. Tenemos que ir a la matriz de
colisión. El escudo necesita
chocar solo con enemigos y proyectiles enemigos. Entonces podemos crear un nuevo script. Yo lo llamaré escudo. El guión al
objeto escudo y ábrelo. Eliminemos las funciones
predeterminadas. El escudo no se habrá mantenido, solo contará golpes para crear una variable de golpes
para destruir, estableceré el valor en tres. Necesitamos una protección de
variable bool pública. Cuando habilitamos el escudo, aseguramos de que
tenemos tres impactos que
destruir y que
la protección sea cierta. Ahora, crea una función que
dañe el escudo. Disminuimos golpes para
destruirlo en uno. Después comprueba si los hits son
menores o iguales a cero. Luego establece la protección en falso
y desactiva el escudo. También podemos
recoger el poder del escudo mientras ya tenemos un escudo. Entonces solo
reparemos el escudo. Establece golpes para destruirlo
al valor predeterminado. Ahora necesitamos el propio Trigger
Enter a la función. Sabemos que el esquisto
para colisionar Sólo un poco, enemigos y proyectiles enemigos. Para que podamos tratar de obtener
el componente enemigo. Esta línea de código
intentará obtener los componentes de la colisión y
almacenarlos en esta variable. Entonces tenemos que
destruir al enemigo. Podemos usar una cantidad insana de daños para
asegurarnos de que destruimos. Después, daña el escudo. El escudo colisionó
con el proyectil, después destruyó el proyectil
y dañó el escudo. Después ve al guión de estadísticas
del jugador. Aquí, necesitamos una
referencia al escudo. Entonces necesitamos prevenir la imagen mientras el
escudo está activo. Entonces, en la función de daño tecnológico, si la
protección del escudo es verdadera, entonces regresa y no
ejecutes el código a continuación. Unidad para probarlo, encendamos la protección. Después selecciona al jugador y
configura una referencia o el escudo. Vamos a probarlo. Tenemos un escudo
que debería
protegernos de tres impactos. 123. Genial. Sólo una pequeña digresión para asegurarnos de que las balas sean visibles
frente al escudo, podemos aumentar el orden de clasificación. Ahora vamos a crear otro script. Yo lo llamaré activador de
escudo de jugador. Seleccione el reproductor
y agregue el script, ábralo y elimine las funciones
predeterminadas. Necesitamos una referencia
al escudo. Entonces vamos a crear un escudo de función de
activación pública. Esta función se llamará
cuando recojamos un power-up. Entonces comprobamos si el
barco ya está activo. Si no, vamos a activarlo. Si está activo,
repare el escudo. Regresa a Unity. Arrastre el escudo
al campo vacío. Ahora seleccione el escudo
y la protección para discapacitados. También se deshabilitó el objeto de repisa. Selecciona el jugador
y aplica anulaciones. Ahora, necesitamos
crear realmente un objeto PowerApp. Ve a la carpeta Prefabs y arrastra el poder de la colina hacia
arriba a la escena. Crearemos otro prefab
ajustando éste. De esa manera, estamos ahorrando tiempo. Primero, cambiemos el sprite. Entonces podemos quitar el
script y cambiar el nombre. Ahora, podemos crear un nuevo prefab. Lo último que tenemos que hacer
es crear un nuevo script. Llámalo encendido, escudo. Seleccione el powerup
y agregue el script. Ábrela. Necesitamos el On Trigger
Enter a la función. Primero, nos aseguramos de que la colisión ocurrió
con el jugador. Colisión. Tenemos que llegar
al activador de escudo. Luego llame a la función activate
shield y luego destruya el objeto
PowerApp. Guárdala, y ve a Unity. No olvides
anular los cambios. Podemos eliminar el
prefab de la escena, luego ir a los objetos
scriptables. Necesitamos agregar un nuevo
prefab a la matriz. Elija el prefab escudo. Vamos a probarlo. Necesitamos que se
encienda un escudo. Ahora, estamos protegidos
por tres hits. Genial. En la siguiente conferencia, creamos iconos de UI para que
podamos ver el estado del escudo. Nos vemos ahí.
51. UI de escudo: Hola a todos. En esta conferencia, creamos una interfaz de usuario para que el
shell se active. La interfaz de usuario mostrará el
estado del escudo. Expandamos Canvas y hagamos
clic derecho en el área segura. Necesitamos crear una imagen. Yo lo llamaré escudo icono de base. Cambiemos la imagen de origen. Usa el sprite base de iconos. Podemos cambiar el color. Después crea otra imagen. Tiene que ser un objeto hijo del icono
de la base del escudo. Este será icono de escudo. Cambia el sprite. Haga clic en el botón Establecer tamaño
nativo. Alejemos el zoom. Seleccione el
objeto icono base y cambie el valor Preestablecido de Anclaje a
la esquina superior izquierda. Ahora, podemos cambiar la posición. Tiene que estar por debajo de
la Barra de Salud. A lo mejor la base es un poco demasiado grande, así que cambiemos el
ancho y la altura. Esto se ve bien. Ahora podemos duplicarlo. Mueva el duplicado a la derecha, luego repita el proceso. Necesitábamos tres íconos porque la protección del escudo
es de tres golpes. Ahora selecciona todos los
iconos basados y deshabilitarlos. Seleccione el prefabricado de lona. En anulaciones, seleccione el icono de escudo y haga clic en el botón Aplicar
seleccione ese. Ahora, en todos los niveles, este prefabricado
tendrá íconos Shield. El siguiente paso es ir
al guión del escudo. Aquí necesitamos una variedad
de objetos de juego. Yo lo llamaré base de escudo. Esto será una referencia
a los íconos del escudo. Cuando habilitamos el escudo, podemos usar el bucle for
para habilitar todos los iconos. Entonces necesitábamos crear
una función que
actualizara los iconos cuando el
escudo tome la imagen. Así que vamos a crear la función de interfaz de usuario de
actualización. Usaremos la función switch. Comprobamos los golpes para
destruir la variable. En caso cero, eso significa que la
variable hits a destruir es cero. Entonces necesitamos
desactivar todos los íconos. Al final de la caja, usamos break para salir de
la función de interruptor. En el caso de uno, necesitamos habilitar el primer icono y
desactivar los demás. En el caso dos,
habilitamos a los iconos. En el caso tres, habilitamos todos los iconos en la función
dañada. Asegurémonos de que
la
variable de golpes a destruir es cero cuando se destruye
el escudo. También en esta función,
actualizamos la interfaz de usuario. También necesitábamos actualizar
estás en la función de reparación. Hagamos una cosa más. En esta función de voz, podemos tener un caso por defecto. Esto sucederá cuando la variable que estamos
comprobando y que es hits para destruir tenga un valor
diferente al de cualquier caso. No tenemos ningún otro
caso que el 012.3, pero podemos poner un registro de depuración. Entonces, si eso sucede,
algo anda mal. Volvamos a Unity. Necesitamos arrastrar los
iconos a la matriz. Vamos a probarlo. Necesitamos el encendido del escudo. Ahora, vamos a ellos como
escudo para que
podamos ver si los
íconos se actualizarán. Como puedes ver funciona. No hemos terminado. Esto es importante. Es necesario actualizar las referencias en la plantilla sin y otros niveles que
hicimos para probar. Observe que si usamos override para el jugador y
pasamos a otro nivel, no
tenemos referencias. Los prefabricados no pueden recordar referencias a otros
Prefabs u objetos. Repito al
final del curso, terminaremos la
escena temporal y luego solo
podrás duplicarla
para crear unos niveles. Después de que actualizaste tus niveles, pasemos a la siguiente conferencia.
52. Potencia de disparo: Hola a todos. En esta conferencia, creamos una aplicación Power de disparo. A medida que lo recogemos, obtenemos más puntos de tiro. Y cuando tomamos la imagen, perdemos puntos de tiro. Primero, vamos a crear puntos de
tiro. Selecciona el que ya
tenemos y cambia el icono. Ahora, podemos
duplicarlo y renombrarlo. Después ajusta la posición, duplícala nuevamente
y cambia de posición. Necesitamos uno más. Este punto
tendrá cierta rotación. Entonces cámbiate el nombre. Ahora, vamos a duplicar puntos y colocarlos en el
lado derecho de la nave espacial. Quita el signo menos
del valor x para
hacerlos simétricos. Para el último, también
necesitamos
cambiar una rotación. Ahora, vamos al guión de tiro
del jugador. Hagamos algunos cambios
y organicemos el guión. Simplemente voy a mover
este punto de disparo por debajo del intervalo de disparo. Entonces podemos agregar un atributo de
encabezado. Entonces vamos a crear un encabezado
para los puntos de actualización. Ahora necesitamos referencias a
cuatro puntos de transformación. Entonces vamos a crear un encabezado
para los dos últimos puntos. Con la rotación, necesitamos
transformar puntos. Entonces necesitamos un nivel de actualización de
variable entera. Ahora, necesitamos modificar
la función de disparo. Voy a comentar esta
línea por un segundo. Usaremos la función switch. Se comprobará la variable de nivel de
actualización. En caso de cero,
solo debemos de un punto. En el caso uno, debemos afirmar
dos puntos, izquierdo y derecho. Cambiar el básico debe apuntar a la izquierda, no se puede posicionar. Después duplicarlo y colocar
el cañón derecho posicionado. En el caso dos, disparamos
desde tres puntos
desde puntos básicos de tiro izquierdo y
derecho. En el caso tres, debemos
afirmar cinco puntos de tiro. Utilice el segundo Canaán arribó y un segundo
cañón derecho posiciones. En el caso cuatro, mostramos
desde todos los puntos de tiro, incluyendo los puntos
con rotación. Es importante usar
la rotación desde
los puntos en lugar de la identidad
cuaternión. También podemos agregar
el caso predeterminado, que no hará nada un registro de
depuración si lo desea. Observe que usamos mucho la función
Instanciar, creando y destruyendo
muchos objetos. En este caso, las balas a veces
pueden afectar
el rendimiento en los dispositivos móviles. Entonces, al final del curso, consulta la sección de optimización
y cómo actualizamos esto. El siguiente paso es crear una función pública que incremente la variable de
nivel de actualización. Después de que
aumentemos el nivel, necesitamos verificar si
es mayor a cuatro, que es nuestro máximo. Entonces sólo tienes que ponerla en cuatro. Ve a Unity, conecta o dispara
puntos con el guión. Entonces podemos aplicar
anulaciones al prefab. Ahora, vamos a crear una PowerApp. Utilice el prefab de encendido de salud. Lo ajustaremos y
crearemos uno nuevo. Cambie el nombre, el sprite y elimine el script. Y vamos a crear un nuevo guión. Yo lo llamaré
power up shooting. El guión a la prefab. Utilice el disparador On, Enter a la función. Comprueba si la colisión
ocurrió con el jugador. Entonces necesitamos que componente de disparo
del jugador se llame la función de aumento de
actualización. Voy a codificar duro para
aumentar la actualización en uno, pero puedes crear una variable y pegarla aquí. Si quieres. Después destruye la Power App. Volvamos a Unity. Cree un prefab de PowerApp, elimine uno de la escena. Entonces necesitamos encontrar nuestros objetos scriptables en
el prefab a la matriz. Para que sea más fácil probar, siempre
podemos vincular esta
Power App. Vamos a probarlo. Como puedes ver, funciona. Hagamos que el jugador pierda
un nivel mejorado cuando recibe daño en el guión de disparo del
jugador, cree la función de
mejora de disminución. Disminuir el nivel en uno. Y también asegúrate de
que pueda ir por debajo de cero. Ir al guión de estadísticas del jugador. Necesitamos una referencia al guión de tiro
del jugador. En el inicio, use
el Get Component. Entonces, cuando el jugador
tome la imagen, llamemos a la función de
mejora de disminución. Esto es todo lo que necesitamos para codificar. Intentemos recoger una Power App, luego recibir daño y el nivel de
actualización debería disminuir. Un placer tener un buen día y
verte en la siguiente conferencia.
53. Actualización de Power Ups: Hola a todos. Actualicemos rápidamente los scripts
de Power Apps. Hay un caso en el que un jugador no recoge las Power Apps, esos potenciadores
caerían en el infinito. Entonces necesitamos usar propiedad
se volvió invisible. Esta es la misma función
que utilizamos para balas y meteoritos y todo lo que
pueda salir de la pantalla. Aquí, necesitamos destruir
el GameObject de Power App, copiar este código en cada script
de Power Apps. Y eso es todo. Gracias por verte y verte
en la próxima conferencia.
54. Concepto y preparación de jefe: Hola a todos.
Veamos el concepto que aplicaremos para
crear al jefe enemigo. La idea es crear estados. Cada estado será
responsable de un tipo de comportamiento. Por ejemplo, la interestatal
será responsable, que aparezca el jefe enemigo. Entonces podemos tener
un estado de tiroteo, un
estado tecnológico de educación especial, y así sucesivamente. Del estado, habrá
crisis infantil de chicos del estado base. Cada estado hereda la función
run state, que contendrá
lógica para ese estado. También tendremos un script de controlador
jefe. El controlador tendrá la
función de cambio de estado que
se encargará de
cambiar los estados. ejemplo, después de que ejecutamos algún
estado y está terminado, llamamos a la
función de cambio de estado para cambiar el estado. Esta es la lógica que usaremos. Por supuesto, pasaremos el jefe al
final de nuestro nivel. Ahora, vamos a crear
nuestro jefe GameObject. Ve a los sprites enemigos, usa el morado grande, cambia el orden en capa, luego cambia el nombre. Agreguemos algunos componentes. Necesitamos un componente 2D de
cuerpo rígido. Que sea cinemático. Entonces agreguemos un colisionador de
caja 2D. Da clic en el botón Editar
y ajusta el tamaño. Vamos a necesitar un colisionador más. También ajusta el tamaño. Salir del modo de edición y, a continuación, añadir el colisionador
compuesto 2D. El colisionador de caja allí es
necesario ser utilizado por composite. Además, activemos la opción
Is Trigger. Tenemos que cambiar la capa, seleccionar enemigo para
evitar algunos errores. Por ahora, necesitamos
desactivar los colisionadores. Ahora que tenemos cosas básicas
hechas en la próxima conferencia, crearemos un estado base
y ambos scripts de controlador. Nos vemos ahí.
55. Estados de jefe y controlador: Hola a todos. En esta conferencia, creamos una base para que
el sistema estatal y el controlador se mantengan
organizados en guiones. Vamos a crear una carpeta de caja
morada. Ahora podemos crear dos scripts. El primero
será a la vez estado base, y el segundo
será ambos controlador. Los guiones a jefe morado. Yo sólo los voy a mover hacia arriba en el inspector Estado
base abierto . Aquí, podemos eliminar
la función de actualización. Ahora necesitamos variables
y límites de KMer. Pero en lugar de escribirlos, puedo ir a
los controles del jugador y copiarlos. No necesitamos esta variable
offset. Esta es una clase base. Entonces las clases infantiles tal vez
necesitarán una de estas variables. Por eso necesitamos cambiar los modificadores de
acceso para protegerlo. En la función despierto, set Main llegó a
nuestra cámara principal. Vamos a los controles del jugador. Desplácese hacia abajo y copie esta parte. Cuando definamos variables, ponerlas en inicio. Podemos cambiar un poco los números
porque el autobús es un poco más grande y necesita estar en la mitad superior de la pantalla. Además, start necesita ser una función virtual
protegida. Entonces vamos a crear una función pública de estado de ejecución
virtual. Déjalo vacío, luego
crea otro público. Estamos parados de la función de estado. O los dos estados, usaremos corrutinas
y esta función de
estado de
parada valores Stop Paul cortinas. Ahora vamos al controlador de bus. No necesitamos la función de
actualización. Fuera de la clase. Vamos a crear enums. Utilizaremos enums para
identificar ambos estados. Así enum público, ambos estatales. Y ahora escribimos los
estados que vamos a tener. Necesitamos una interestatal
cuando aparezca el jefe. Necesitamos n al mensaje de texto
que yo llamo fuego. Necesitamos un estado de ataque especial. Y ese estado, puedes agregar
tantos estados como quieras. Entonces vamos a crear un
cambio público una función estatal. Tomará tanto
estado como parámetro. Utilizaremos esta función
para cambiar estados. Usemos la
función switch para verificar el estado. Si el estado es entrar,
entonces hay algo. Podemos copiar esta
parte del código y pegarla para
cada estado que tengamos. Ahora, solo revisa
diferentes estados. Genial, tenemos suficiente para
comenzar a crear estados. En la siguiente conferencia, creamos la interestatal.
Nos vemos ahí.
56. Ingresa al estado: Hola a todos. En esta conferencia, creamos
el ingreso estatal para el jefe. La interestatal definirá
tener el autobús aparecerá. Y mi idea es hacer que
vaya a cierto
punto de la pantalla. Después cambiar el estado. Vamos a crear un nuevo guión. Yo lo llamaré a las dos. Ingresa el guión
al jefe y ábrelo. Primero. En lugar del comportamiento
moderno, heredemos de
ambos estados base. Recuerda en la clase padre, tenemos dos funciones virtuales
que podemos anular. Además, podemos anular
la función start. Vamos a crear una variable
vector dos, llamarlo enter point. A este vector, le asignaremos una posición y el autobús
volará a esa posición. A continuación, necesitamos una variable de velocidad. Anulemos la función de
inicio. Podemos usar Bayes start para definir variables para límites
de pantalla. Entonces tenemos que elegir un punto donde aparezcan los
dos sevillanos. Iré con 0.5 en el
x y 0.7 en el eje y. Podemos eliminar la función de
actualización. Como dije, valoramos las funciones de raíz
cuadrada para
definir comportamientos de estado. El enumerador de ojos ejecuta la función
interestatal. Entonces usamos el bucle while. Entonces, mientras que la distancia
entre el jefe y punto de
entrada es mayor que
un número realmente pequeño. Tenemos que mover el autobús a ese punto usando el
movimiento hacia la función. Primero, escribimos la
posición del autobús, luego la posición que
necesitamos alcanzar. Y luego elegimos
la velocidad que se multiplica por el tiempo.Deltatime. Entonces esperamos
el final de un marco. Repetimos esto hasta que
cumplamos esta condición. Después de salir del bucle while, necesitamos cambiar el estado. Entonces vayamos a la clase de padres. Ambos estado base. Cree una
variable protegida de
ambos controladores en la función de activación. Y vamos a por el componente. Recuerda, en el script del
controlador de bus, tenemos la
función de cambio de estado que estamos buscando. En el autobús ingrese guión. Podemos usar el controlador y llamar a la función de cambio de estado. Después de la interestatal,
vamos al estado del fuego. Ahora tenemos que llamar a esta función anular
el estado aleatorio. Aquí, empiezas a corregir. Anulemos el estado de parada. Sólo podemos usar
la función base. Para recordarte, esa función
detendrá la queratina. Ahora, vaya a ambos controladores. Crear una referencia para
la interestatal de autobuses. En la función de interruptor. Cuando estamos en la interestatal, usamos run state para probar estados. Vamos a crear una prueba
de variable de bola. Y el estado de prueba de enum. En el inicio. Si
la prueba es verdadera, entonces cambiamos
al estado de prueba. Vayamos a la unidad. Arrastre el script
de entrada de jefe al campo vacío. Aquí puedes elegir el estado. Por supuesto, necesitamos a Enter. Vamos a mover al jefe
fuera de la pantalla. Cuando iniciemos el juego, el jefe debe ir
a nuestro punto de entrada. Por supuesto, no te olvides
de establecer la velocidad. Como se puede ver, aparecerá el
autobús. Si salimos del modo de reproducción, podemos ver el mensaje de depuración. Hagamos doble clic en él. Se puede ver que es
una depuración de la línea 33. Ese es el estado del fuego. Y si recuerdas, al final de nuestra interestatal, cambiamos el estado a fuego. Entonces todo funciona. En la siguiente conferencia, Vamos a crear el estado de fuego.
57. Estados de prueba: Hola a todos. Esta es una conferencia rápida que
decidí colocar aquí. Quería mostrarles
cómo probar adecuadamente los estados y discutir ambas restricciones de
movimiento. Antes de comenzar, puedes eliminar el script del estado base del jefe si aún no lo hiciste. Esta es una clase base y no necesita
estar en el objeto. Sólo un tonto error. No va a romper nada, solo que no es necesario. Vamos a abrir el guión del estado
base del jefe. Como puedes ver en la función de inicio
virtual, obtenemos restricciones de movimiento. Esto va a funcionar bien
porque solemos responder el autobús
al final de un nivel. Sin embargo, al probar, lo
giramos al principio y esas restricciones no se establecen correctamente debido al pecado
de una máquina. Si recuerdas, en los controles
del jugador, usamos una cortina para establecer
límites para el jugador. Se puede ver que
esperamos un poco de tiempo antes de establecer
restricciones. Le expliqué por qué hacemos eso en la conferencia de límites de cámara
debido a la máquina de cine. Entonces si vamos a ambos enter, se
puede ver que utilizan la función de inicio base
para establecer restricciones. Recuerda que esta clase es una clase hijo de
ambos estados espaciales. Entonces, si abarcamos
al jefe al inicio de un nivel, podemos obtener los
límites equivocados que todos siendo dicho para probar correctamente el autobús con correctamente
establecidos los límites, debemos hacer lo siguiente. Asegúrese de que la variable
de prueba sea verdadera y elija el estado de sabor. Después se deshabilitó el objeto jefe. Ir al simulador. Elegí jugar en ventana, iniciar el juego, y
luego habilitar al jefe. De esta manera, las restricciones de
movimiento para el autobús están correctamente establecidas. Recuerda, todo esto es
solo para probar en un juego real con libra el
autobús al final de un nivel. Entonces no tenemos ese problema. Y eso es todo para esta conferencia. Gracias por ver
y hasta pronto.
58. Incendio de jefe: Hola a todos. En esta conferencia, creamos un
estado de tiroteo para el autobús. Como pueden ver, el autobús
comenzará a disparar después de que termine la interestatal que
hicimos en la conferencia anterior. Primero, vamos a crear puntos de
tiro. Tienen que ser un
objeto hijo del jefe. Necesitamos para disparar puntos, los
colocamos frente a
los cánones. A continuación, vamos a crear un nuevo guión. Llámalo a los dos, dispara el guión
al jefe y ábrelo. Esta clase necesita ser una
clase hijo de ambos estados base. Podemos eliminar las funciones
predeterminadas. Entonces necesitamos algunas variables. Necesitamos un flotador de velocidad variable. Después flotar, disparar a la velocidad. Necesitamos una
variable de objeto de juego para el prefabricado de bala. Para organizar el script,
usemos encabezado. Ahora necesitamos una matriz de transformación
para almacenar los puntos de disparo. Podemos crear la
función de enumerador de ojos alrededor de un estado de fuego. Necesitamos un flotador,
disparar el temporizador,
un temporizador de estado de fuego flotante y un tiempo de salida
del estado de fuego flotante. Y eso obtendrá
un valor aleatorio, 5-10 s. creo que es una buena idea
aleatorizar la duración
de este estado de fuego. Entonces usemos vector
para apuntar a la posición. El autobús tendrá que
desplazarse a esa posición, que fue aleatoriamente entre
nuestros límites máximos. Vamos a usar un bucle while. Mientras que el temporizador de estado de incendio es menor o igual al tiempo de salida
del estado de incendio. El jefe necesita moverse a la posición objetivo
y disparar balas. Si la distancia
entre el jefe y la posición objetivo es mayor que un número
realmente pequeño. Después continuar moviéndose. De lo contrario. Eso significa que llegamos
al punto objetivo. Entonces elegimos otra
posición, otra vez, que era al azar entre
nuestros límites máximos. Recuerde, definimos estas
variables en la clase base. Por supuesto, mientras
el autobús se
mueve, necesita disparar balas. Vamos a aumentar debe
cronometrar por tiempo.DeltaTime. Si debería temporizador es mayor
o igual a la velocidad de disparo. Entonces disparamos desde puntos de
tiro. Use un bucle for para
pasar por todos los puntos. Entonces el reinicio debe cronometrar. Entonces esperamos
el final de un marco. Entonces aumentar el
dímero estatal comprador por tiempo.Deltatime. Pasado el tiempo suficiente,
saldremos del bucle while. Ahora, vamos a anular la función de estado de
ejecución. Use la corutina de inicio
para iniciar el estado de incendio. Luego anule el estado de parada
y use la función base. Justo como antes. Pasemos al script del
controlador de bus. Crear una referencia
al fuego de ambos. En esta función de voz
bajo el caso del fuego, utilice el fuego del autobús que
alrededor de una función de estado. Ir a Unity. Vamos a establecer la velocidad. Entonces, establecer la tasa de
tiro en uno, lo que significa que cada segundo
o el prefab de bala, podemos usar el mismo que
usamos para los enemigos morados. A continuación, vamos a arrastrar los
puntos de tiro que hicimos. Lo último, arrastrar
el guión de alardear fuego. Podemos dejar la interestatal
como el estado de prueba, ya que al final de la misma, el jefe debería cambiar el
estado a fuego. Vamos a probarlo. Vemos la interestatal y
cambiamos al estado de fuego. Observe que después de que el
estado de incendio termine las paradas del autobús, necesitamos repetir el estado de incendio o cambiarlo a algún
otro estado, por ejemplo el estado ético especial. Regresa al guión del jefe de fuego. En la función de enumerador de ojos. Fuera del bucle while, llamamos a la función change
state. Cambiarlo al estado espacial. Si te gusta, puedes
agregar algo de aleatoriedad. Podemos obtener un número aleatorio. Esto puede ser cero o uno. Si el número es igual a cero, entonces repita el estado de fuego. De lo contrario,
cámbielo demasiado especial. Para facilitar las pruebas,
siempre lo cambiaré al estado especial. Y eso es todo. En la siguiente conferencia, creamos el
estado de ataque especial. Nos vemos ahí.
59. Ataque especial: Hola a todos. Vamos a crear una tecnología de educación
especial para el jefe. El jefe disparará un gran proyectil lento
que puede dañar al jugador. El proyectil también
estallará después de algún tiempo y enviará proyectiles más pequeños
en dirección circular. Primero, vamos a crear
otro objeto de juego infantil. Yo lo llamaré punto especial, porque a partir de ese punto, el autobús va a disparar
un ataque espacial. Vamos a moverlo frente
al Canaán principal. Entonces vamos a crear un nuevo guión. Esto será a la vez espacial. Agrega el guión al
jefe y ábrelo. Tenemos que heredar de
la clase estado base jefe. Entonces vamos a crear variables. Necesitamos una variable de velocidad de flotación. Después un tiempo de espera de flotación. Esta variable
determinará cuánto tiempo esperará
el autobús después
del ataque especial. Entonces hicimos una bala
especial GameObject. Por supuesto, necesitamos
un punto de tiro. Entonces necesitamos un vector para
apuntar al punto para
la primera posición. Anulemos la función de
inicio. No necesitamos usar
la función base. Simplemente establezca el punto objetivo. Si usamos una ventana gráfica a punto
mundial para determinar
desde qué punto el jefe
despedirá al Special Ed Tech. Iré con 0.5
en x y 0.9 sobre por qué. Tal vez puedas ir un poco más bajo. Ahora, vamos a crear el
enumerador ojo ejecutar la función de
estado espacial. Primero, el autobús necesita
moverse al punto objetivo. Usamos un bucle while y verificamos la distancia entre el jefe
y la posición objetivo. Si bien la distancia es
mayor a 0.01, necesitamos mover al jefe. Usamos el movimiento hacia la
función igual que antes. Entonces esperamos el final de un fotograma fuera
del bucle while, lo que significa que el jefe
está en la posición objetivo. Instanciamos una bala especial. Entonces esperamos un poco y luego cambiamos el estado a fuego. Ahora, necesitamos anular
las funciones run state y
stop state. Use inicio carótida. Vaya al script del controlador de bus. Aquí necesitamos una referencia
al jefe especial. Entonces en la función de
estado de cambio, use el estado de ejecución espacial del bus. Ir a Unity. Y vamos a establecer variables. Velocidad. También puede serlo. Podemos esperar 5 s. Todavía no tenemos la prefabricada de bala
espacial,
pero podemos conectar el punto de disparo
que hicimos antes. Ahora, vamos a crear un prefab de bala
especial. Ve a los sprites enemigos. Usa el sprite de bala grande. Cambia el nombre, o
están en una capa. Después establece la
capa de colisión a los proyectiles enemigos. Podemos hacerlo un poco más pequeño. Esto es bueno. Agregue un
componente 2D de cuerpo rígido, hágalo cinemático. Entonces necesitamos un colisionador
circular 2D. Tiene que ser un detonante. Podemos ajustar el tamaño, disminuir un poco el radio. Como dije, esta
bala estallará y muchas balas en dirección
circular. Por ejemplo, quiero pasar balas de
seis minutos, así dividiré 360 por seis. El resultado es 60. ¿Lo recuerdas? Y luego vamos a crear un objeto hijo de
la bala espacial. Yo lo llamaré punto de desove. La idea es cambiar la
rotación sobre el eje z. Duplicemos
este punto de libra. Cambie la rotación a 60, luego duplique nuevamente y
aumente la rotación en 60. Eso quiere decir que
será de un veinte. Repita el proceso hasta
el último punto de span, la rotación tiene un valor de 300. Deberías tener seis puntos. Observe cómo
cambia el eje verde a medida que cambiamos la rotación. Esto es importante. Ahora, vamos a crear un nuevo script. Bala espacial. Agrega el script al
objeto y ábrelo. Primero, necesitamos algunas variables. Necesitamos un flotador, daño, velocidad y velocidad de rotación porque
esta bala girará. También necesitamos una referencia 2D de
cuerpo rígido. También necesitamos una referencia al prefab
de bala minuta. Lo último, necesitamos
una matriz de puntos. En el inicio, vamos a establecer la velocidad en vector
dos hacia abajo multiplicado por la velocidad en la función de actualización. Y vamos a rotar la bala
con la transformación que gire. Gire la bala en el eje z. Utilice la velocidad de rotación
multiplicada por el tiempo.DeltaTime. Entonces vamos a crear la función de explosión
del enumerador de ojos. Aquí, necesitamos destruir la bala espacial e
instanciar muchas balas. Primero, fijemos el tiempo de explosión
aleatorio. Entonces esperamos ese tiempo aleatorio. Use un bucle for para
pasar por todos los puntos de exposición. Instanciamos una bala de minuto
en la posición del punto de generación. Y ahora esto es importante. Utilizamos la rotación
de este punto encuadernado. Después destruimos el objeto bala
espacial. En la función start, llamamos a la función explode
con start corroutine. Por supuesto, esta bala también
puede dañar al jugador. Así que vamos a crear
su propio Trigger. Entrar a la función. Comprobamos por el jugador tecnológico, luego dañamos al jugador. Después de eso destruyó la bala. En este caso, no
respondemos balas minuciosas. Igual que antes. Vamos a usar en se volvió invisible. Regresa a Unity. Establezca el daño. La velocidad debe ser amarilla. Luego establece, Velocidad de rotación. Arrastre el cuerpo rígido 2D. Aún no tenemos muchas balas, pero podemos arrastrar
puntos de exposición a la matriz. Para acelerar el proceso
de creación de muchas balas, podemos usar el prefabricado de
bala púrpura. Este es el que usamos
para los enemigos morados. Cambia el nombre,
elimina el script y luego crea uno nuevo. Llámenlo mini bala. El guión para el objeto
mini bullet. Y ábrelo de nuevo para
agilizar el proceso, copiemos el código
del script bullet morado. Si no lo tienes abierto, puedes encontrarlo a través de
Solution Explorer. Vamos a copiar todo el guión. Haremos dos cambios. Péguela. Primero, solo agregaré campo
serializado y quitaré
la parte componente de la puerta. Entonces la parte importante, reemplazar el vector dos abajo
con transformar eso hacia arriba. Si miras la descripción, este es el eje verde
de la transformación. Recuerda, cuando
giramos objetos, también se gira
la x verde. Por lo que el minuto de bala se
moverá en esa dirección. Regresa a Unity. Vamos a establecer el daño y la velocidad. No olvides el cuerpo rígido. Ahora crea un nuevo prefab. Eliminar uno de la escena. Seleccione la viñeta espacial. Arrastre el prefab mini bullet. Ahora vamos a crear un prefab de bala
especial. Eliminar uno de la escena. Seleccione el jefe. Arrastre el prefab de bala espacial y arrastre ambos
estados espaciales al campo vacío. Vamos a probarlo. Iniciaré la prueba
desde la interestatal. Podemos ver la interestatal, luego el estado del fuego. Y deberíamos ver
el estado espacial. Entonces después de esperar algún tiempo, el autobús va al estado de incendio. Otra vez. Muy bonito. Gracias por verte y verte
en la próxima conferencia.
60. Estadísticas de jefe y muerte: Hola a todos. En esta conferencia, nos enteramos de cómo dañar
y destruir el autobús. Antes de empezar
a codificar cualquier cosa, vamos a crear animaciones rápidamente. Ya sabes, el procedimiento es el
mismo que para otros enemigos. Selecciona el autobús y ve a
la Ventana de Animación, crea una nueva animación. Esto será tanto
usar el sprite predeterminado. Entonces vamos a crear
otra animación que será tanto la imagen. Establezca la frecuencia de muestreo en 30 y use el sprite blanco. Tenga en cuenta que al
final de la conferencia, reemplazaremos este amplio
sprite por otra cosa. Se verá mejor. Vaya a la carpeta Animaciones. Selecciona tanto la imagen
como desactiva un tiempo de bucle, abre el animador
y selecciona el jefe. Crea transiciones. Necesitamos un
parámetro de disparo de daño. Al igual que otras animaciones, desde el inactivo hasta el daño, deshabilitó el tiempo de salida. Y el parámetro de uso. Después de daños a cualquiera use el tiempo de
salida con el valor de uno. Lo último, seleccionar tanto
la imagen como agregar una etiqueta. Será el mg. Ahora
podemos crear un nuevo script. Llámenlo a ambas estadísticas. Este guión heredará
de la clase enemiga. Solo para recordarte, en la clase enemiga, tenemos muchas variables y funciones que todos los enemigos usan. Ahora necesitamos una referencia
al controlador de bus. Podemos eliminar las funciones
predeterminadas. Anulemos la secuencia escuchada. Aquí, iniciaremos
la animación de daños y desactivaremos la activación
si ya se está ejecutando. Ya usamos esta
técnica en el curso, así que voy un poco más rápido. A continuación, tenemos que
anular esa secuencia. Aquí, necesitamos
cambiar el estado a la muerte e instanciar
la explosión prefab. Sólo voy a establecer una
rotación aleatoria para la explosión. Además, el jugador necesita tomar la imagen si
choca con el jefe, use el On Trigger
Enter para la función. Este es el mismo
procedimiento que antes. Ir a la unidad, el
guión al jefe. Entonces necesitamos establecer
algunas variables. Esto es daño por contacto. Usa el animador
de este objeto. No olvides arrastrar
ambos controladores. Ahora vamos a crear otro script. Llámenlo a la vez muerte y ábrelo. Necesitamos heredar de ambas funciones de eliminación de estado
base. Ahora vamos a anular el estado de ejecución. Cuando el jefe muere, usamos End Game Manager e
iniciamos la secuencia de resolución. A continuación, desactivemos
el objeto de juego jefe. Ahora ve a ambos controladores. Cuando el jefe está
en estado muerto, entonces tenemos que detener a
todos los demás estados. Por lo tanto, use estado parado
para cada estado. Entonces como siempre, necesitamos
crear una referencia. Deuda jefe. En este caso. En la función switch, use ambos estados de ejecución de deuda. Vamos a la unidad, al autobús, a ese
guión al jefe. Ahora podemos habilitar colisionadores
y arrastrar la muerte del jefe
al campo vacío. Vamos a probarlo. Como pueden ver, podemos
dañar y destruir al jefe. Pero creo que lo
generalizado es un poco demasiado. Entonces cambiemos la animación. Seleccione el jefe,
vaya a la animación y abra tanto la animación
de imagen. Reemplaza el extendido
por el predeterminado, luego presiona el botón de grabación
y cambia el color. Puedes experimentar y ver
qué se verá mejor. Intentemos con un poco de amarillo
y un valor Alfa menor. Veamos cómo se ve. Creo que es mejor. La explosión es un poco pequeña, así que vamos a crear una más grande. Usa el prefab, tenemos. Renombrarlo y cambiar el tamaño. Luego crea un nuevo prefab. Seleccione el jefe y
reemplace el prefab. Podemos eliminar uno
de la escena. Bonito. Lo siguiente que
tenemos que resolver es una colisión entre el
jefe y el escudo. En este punto, el escudo destruirá instantáneamente al jefe. Cambiemos eso. Seleccione el jefe, cree una nueva etiqueta. Yo lo llamaré jefe. Utilízala para el objeto bus. Entonces necesitamos abrir
el script shell. Como puedes ver, el escudo infligirá mucho
daño
porque está diseñado para
destruir instantáneamente a enemigos más pequeños. Ahora, podemos comprobar
si la colisión ocurrió con un objeto
que tiene el gran jefe. Tú eliges, ¿qué pasará? Destruiré el escudo
en lugar del jefe. Así que establece golpes para destruirlo a
cero y dañar el escudo. Después regresa y no
ejecutes el código a continuación. Pero vamos a probarlo. Bonito. Funciona. Nos vemos en la próxima conferencia.
61. Jefe de Spawn: Hola a todos. En esta conferencia, te
mostraré
cómo recorrer el autobús
al final de un nivel,
seleccionar al jefe. Entonces podemos desmarcar
la variable de prueba. Abra el
script del controlador de bus En la función de inicio, y vamos a establecer el
estado para ingresar. Vuelve a Unity y
selecciona una condición de victoria. Aquí tenemos la duración
del nivel y
las referencias a los reproductores. Abra el guión. Necesitamos una bola
variable, su jefe. En la función de actualización, una
vez que expire el tiempo, utilizaremos la
secuencia resuelta de inicio para determinar el
resultado del nivel. Hagámoslo sólo si no
hay jefe en el nivel. Comprobamos la variable bull. Si tiene ambos es falso, entonces inicia la secuencia. Observe que siempre
deshabilitamos a los reproductores. Esta es la parte importante. Regresa a Unity. Este nivel tiene al jefe. Así que pongamos la
variable a true. La idea es abarcar al jefe cuando la
llave enemiga esté desactivada. Así ensalada enemigo llave
y abrir el guión. Vamos a crear una
variable de objeto de juego para el prefab Boss. Usemos la propia función
deshabilitada, que se llama cuando el objeto, en este caso,
Spanner, está deshabilitado. Primero, comprobamos que el prefab
Boss no sea nulo. Esto lo hacemos porque en otros niveles y a lo mejor no
vamos a tener un jefe. Por lo que esto evitará errores. Pero si lo tenemos, entonces vamos a crear un
vector para librar la posición. Se asegura de que se encuentre
fuera de una pantalla. Para el eje y, use un
número mayor que uno. Luego instanciar el
prefab Boss en esta posición. No obstante, on disabled
también se llama cuando vamos a otro nivel o
reiniciamos exponiendo
objetos mientras cambiábamos, ya que puede provocar errores. Para arreglarlo, necesitamos
agregar una condición más. Ir a la condición de ganar, crear un bool público, puede exponer boss
y establecer false como el valor predeterminado cuando
el temporizador haya expirado. Y tenemos un jefe en el
nivel que es el caso, entonces set puede abarcar tanto a true. Necesitamos conocer este valor antes de que se desactiven los reproductores. Así que mueve la declaración if else hacia arriba antes de desactivar
los generadores. En Enemigo Spawner. Crear una referencia
para cuando condición. En la función no desactivada. Compruebe si la condición del viento
puede exponer el jefe es falsa. Entonces una vuelta y no ejecutes. El código a continuación. Eso es todo lo que necesitamos para codificar. Vuelve a Unity, crea un prefab Boss morado. Elimina uno de esta escena, selecciona la llave enemiga y
arrastra el prefab Boss. También arrastrando el objeto de
condición de victoria. Ahora, seleccionaré una
condición de victoria para las pruebas. Vamos a establecer la duración de
este nivel a 5 s. Después de 5 s, los spammers se desactivarán
y aparecerá el jefe. Vamos a probarlo. Sobrevive a 5 s.
y puedes ver al jefe. Vamos a destruirlo. Ahora, deberíamos ver parabrisas. Genial, funciona. Nos vemos en la próxima conferencia.
62. Sonido de fondo: Hola a todos. Aún no mencionamos el
sonido y la música. Entonces en esta conferencia, te
mostraré cómo
tocar música de fondo. No vamos a adentrarnos demasiado en los ajustes y técnicas de
sonido. Te mostraré ejemplos sencillos a través de esto en
la próxima conferencia. Entonces se obtiene una idea básica
de cómo funciona el sonido. Primero, voy a importar
la carpeta de sonido. Lo puedes encontrar
en los recursos. Aquí tenemos unos
clips de sonido que usaremos. Para comenzar,
organicemos la jerarquía, creemos un nuevo objeto de juego, renombrémosle el nombre y restablezcamos el componente de
transformación. Entonces vamos a crear
otro objeto de juego. Llámalo
sonido de fondo o música. Restablecer el componente de transformación. Ahora necesitamos agregar el
componente de fuente de audio al objeto. La fuente de audio tiene una referencia
al clip que necesitamos
reproducir en algunos ajustes. Arrastremos el clip de música de
fondo al campo vacío. Asegúrate de que
el juego al despertar esté habilitado. Esto asegurará
que el clip de audio comience a reproducirse cuando se cargue
la escena. Dado que se trata de música de fondo, necesitamos habilitar
la opción loop. Sé que esta
música es un poco ruidosa, así que disminuiré
el volumen a 0.3. Antes intentamos seleccionar la cámara principal y asegurarnos de que tenga
un oyente de audio. Debería estar ahí. Por defecto. Este oyente de audio
escuchará sonidos de fuentes
de audio y
los reproducirán a través de altavoces. Después selecciona simulador,
cámbialo para ganar una ventana. Después, asegúrate de que el
audio esté habilitado. Vuelve al simulador
y empieza el juego. Deberías escuchar música en
cuanto empiece el nivel. Bonito. Puedes descargar más música para diferentes reproductores y
repetir este proceso. En la siguiente conferencia, agregamos efectos de sonido de disparo y
explosión. Nos vemos ahí.
63. Efecto de sonido de tiro: Hola a todos. Vamos a crear algunos efectos de sonido. El primero
será filmar sonido. Seleccione el jugador. Agregue el componente de fuente de audio. Utilice el clip de pistola láser. Desactivar, Reproducir despierto porque comenzaremos con este
sonido a través de un guión. Yo sólo bajaré
el volumen. Después ir al guión de
tiro del jugador. Crear una referencia de
fuente de audio. Yo lo llamaré fuente. Después ve a la función de disparo. Aquí usamos fuente que juegan. Esto reproducirá el efecto de sonido cuando un jugador dispara balas
láser. Regresa a Unity. Arrastre el componente de fuente de audio. No olvide anular
los ajustes en el prefab. Vamos a probarlo. Como se puede oír funciona. Lo siguiente, vamos a crear
un efecto de sonido de explosión. Ir a prefabs. Seleccione la explosión. El componente de fuente de audio. Usa la explosión AudioClip. Se asegura de que
el juego al despertar esté habilitado. Este efecto también es demasiado fuerte, así que estableceré el volumen en 0.3. Cada vez que
explotan es libra, deberíamos escuchar los efectos de
sonido. Genial. Ahora vamos a crear una Power
App, efectos de sonido. Aquí tenemos una situación
diferente. Te voy a mostrar por qué. Agreguemos la fuente de audio
a cualquier aplicación de potencia Prefab. Después abre el guión. Necesitamos reproducir el efecto de sonido cuando un jugador colecciona
esta Power App, eso estaría aquí. Pero si tratamos de reproducir
el efecto de sonido usando la fuente de audio
que es propiedad de este objeto, nada va a pasar es porque
destruimos este objeto. En la siguiente línea de código
es que destruimos el objeto. También se destruirá la fuente de audio. Entonces necesitamos un enfoque diferente. Podemos crear algún tipo de gestor de sonido y
sortear esto. Pero también tenemos
una solución simple con opciones limitadas. Usemos un enfoque sencillo. Regresa a Unity. Podemos eliminar esta fuente de audio. Después vuelve al guión. Ahora, necesitamos una referencia
para por ahí clip. Yo lo llamaré clip para reproducir. Para reproducir el clip, usamos la clase de fuente de audio
en lugar de una instancia, llamamos a la fuente de audio
con mayúscula y usamos reproducir clip en el punto. Primero, elige el
clip y luego posiciona. Y también podemos
elegir el volumen. Este clip es un poco silencioso, así que elegiré
el volumen máximo. Déjame explicarte cómo va a funcionar
esto. Esta clase de fuente de audio, vamos a crear un nuevo objeto con el componente de fuente de audio. El nuevo objeto,
tocaremos el sonido y se
destruirá a sí mismo
después está restando importancia. Guarda esto y ve a Unity. Eligió el clip de Power App. Puedes repetir el proceso
para otras Power Apps. Entonces probémoslo. Se puede escuchar el efecto de sonido Power
App. Si logras pausar el juego justo después
de recogerlo, puedes ver que uno
disparó su objeto de juego. Este objeto se crea con el componente fuente de audio y
reproduce el efecto de sonido. Como dije, esta es una solución sencilla
con opciones limitadas. Realmente no tenemos control sobre estas opciones
excepto el volumen. Así que tenlo en mente. Si necesitas usar mezcladores de audio y algunos efectos avanzados, debes ir con las opciones del administrador de
sonido. Para este proyecto,
utilizamos un enfoque sencillo. Esto es todo por esta conferencia. Nos vemos en la siguiente.
64. Configuración de anuncios: Hola a todos. Importemos
anuncios a nuestro proyecto. Antes de entrar en detalles, necesitamos hacer una configuración básica. Observe que estoy en
la escena de inicio, que es nuestra primera
escena en el juego. Vaya a Window Package Manager, asegúrese de que Unity
Registry esté seleccionado y busque publicidad. Como puedes ver al momento
de grabar este video, el nombre es
Advertisement Legacy. Esto se debe a que Unity
está en medio de la transición a una nueva forma
de agregar implementación. Pero ahora mismo la
documentación es realmente pobre y no
hay ejemplos. No te preocupes, este paquete estará disponible por algún tiempo. Además, habrá una actualización este curso cuando el paquete
publicitario
quede dessoportado Por ahora, mi consejo es que lo
utilices todo el tiempo que puedas hasta que obtengamos más documentación y ejemplos para la
nueva implementación. Dicho esto, da clic
en el botón de instalar. Unity te preguntará, ¿quieres usar el paquete
nuevo o heredado? Usemos el paquete heredado. Ahora necesitamos vincular
nuestro proyecto Unity a un ID de proyecto de
Unity Services. Puede hacer clic en el
enlace que lleva al de Unity o simplemente al panel de
Google Unity. Deberás iniciar sesión
con tu ID de Unity. Continuaremos con
esto en un momento. Por ahora, volvamos a Unity, vamos a Configuración del proyecto,
Seleccionar servicios. Entonces tenemos que elegir
una organización. Si no lo tienes, probablemente tendrás un
botón para crearlo. O cuando inicies sesión en
tu cuenta de Unity, encuentra organizaciones
y tendrás un botón para crear
una nueva en Unity. Seleccione su organización. Mi será el desarrollo de
pruebas de juego, y crear un ID de proyecto. Podemos decir que
este juego no va a apuntar
principalmente a niños
menores de 13 años. A continuación, seleccione anuncios en
versiones más recientes, Unity eliminó la pestaña D. No es visible. Si
no lo ves, no te preocupes. Sólo tienes que seguir la conferencia. Conectamos
los ID del juego a través del código. Aquí puedes notar los ID de juego de
Android e IOS. Necesitamos obtenerlos a
través de los servicios de juego. Ahora volvamos al tablero
de Unity. Después de iniciar sesión, asegúrese de seleccionar
la organización correcta. Las organizaciones tienen proyectos,
tenemos que elegir el proyecto móvil Space
Shooter. Ir a Unitización. Haga clic en Comenzar. Solo planeo usar anuncios de Unity. Elige un Nuevo comienzo. Nuestra app aún no está viva. Entonces podemos crear proyecto de
monetización. Puedes ver los ID de juego IOS y
Android. Ir a Ad Units. Aquí puedes ver tres tipos
de anuncios Para IOS y Android. Podemos usar banners premiados y anuncios
intersticiales
más sobre ellos En las próximas conferencias, volver a la Unidad. Deberías ver los ID de juego
aquí si no los ves. Reinicia Unity. Anuncios geniales para usar, pasamos por tres pasos. Necesitamos inicializar anuncios, cargar anuncios y luego mostrar anuncios. Hagamos el primer paso, inicialización con fines de
organización Vamos a crear un objeto de
juego vacío, Ds. Entonces vamos a crear
un nuevo objeto de juego. Yo lo llamo controlador de anuncios. Crear una nueva carpeta para scripts. El primer script será agrega, inicializador, agregar el script
al objeto y abrirlo. También proporcionaré un enlace
a la documentación. Aquí está la parte de inicialización. Puedes copiar y pegar
todo el guión si quieres. Lo crearé paso a paso y agregaré una modificación
al final. Primero, limpiemos
lo que no necesitamos. Entonces necesitamos incluir el anuncio del motor
Unity. Después de que necesitamos una interfaz llamada Unity es el oyente de
inicialización, entonces necesitamos implementar
esa Esto creará la propia función
completa de inicialización Eso se llama cuando se
completa
el proceso y una función
cuando no se completa. Usemos los registros de bolsas
para que sepamos qué pasa. Voy a copiar y pegar esta bolsa D
del script de ejemplo. Vamos a crear algunas variables. Necesitamos ID de juego de cuerdas, uno para Android y otro para IOS. Entonces necesitamos un modo de prueba
variable bull. El último es
el ID del juego de cuerdas que necesitamos asignar. Vamos a crear una
función pública inicializada ya que es pública, porque a lo mejor la
llamarás en otra clase Aquí necesitamos asignar ID de
juego a Android o IOS. Voy a usar una versión corta de la sentencia if entre paréntesis Comprobamos si la aplicación esa plataforma es igual a la plataforma de tiempo de
ejecución, ese reproductor de iphone luego
escribimos un signo de interrogación. Si estamos en iphone, entonces usa la ID del juego IOS.
Después escribe dos puntos. Si no estamos usando el teléfono, entonces usa el ID del juego de Android. Ahora podemos usar la función de
inicialización de anuncios. Usa el ID del juego que establecemos. Después elige el modo de prueba. Tenemos que pasar el oyente de
inicialización, que es este objeto Ahora vamos a crear
la función despierta. Aquí llamamos anuncios de inicialización. Tenemos que hacer la inicialización
sólo una vez en el juego. El mejor momento para hacerlo
suele ser cuando empezamos el juego. Ten en cuenta que no necesitas
tener este objeto en cada escena. Hazlo una vez que estés listo para ir. Sin embargo, si la inicialización falla y quieres
probarla en otras escenas, entonces es una buena idea verificar
si la inicialización
ya está hecha, luego regresa Y no vuelvas a intentarlo. Regresa a Unity. Aquí necesitamos establecer IDs. Puedes copiarlos desde el panel de
Unity o ir a Configuración
del proyecto y
copiar y pegar valores. Tenga cuidado de no mezclarlos
entonces ya que estamos probando, habilitemos el modo de prueba. No olvides desactivar
esto antes de construir la versión de publicación
del juego. Vamos a probarlo. Se puede ver en la consola que la inicialización está completa Todo esto es para el primer paso. En la siguiente conferencia, cubrimos
anuncios de banner. Nos vemos ahí.
65. ACTUALIZACIÓN: Unity Cloud: Hola chicos. Esta es
una actualización rápida sobre servicios de juegos de
Unity
o ahora Unity Cloud. Si tienes problemas para encontrar Unity ayuda a la monetización
en la nueva nube de Unity, este video te ayudará, necesitas iniciar sesión en
Unity Verás el
nuevo tablero aquí. Encontrarás tus proyectos. También puedes crear otros nuevos. Pero necesitamos Space
Shooter Mobile. Vamos a abrirlo. Entonces puedes hacer clic en el botón
Atajos Más, buscar Ayudas y elegir Monetización de
Unity Aids Aquí tienes todas las cintas que necesitamos, incluyendo los bloques de anuncios. Otra forma de encontrar la sección de monetización
es abrir productos, buscar anuncios de Unity
y abrir Agradable, Ahora puedes continuar
con el curso de monetización. Nos vemos en la próxima conferencia.
66. Anuncios publicitarios: Hola otra vez. En esta conferencia, creamos anuncios de banner. Vamos a preparar algunas cosas. Podemos copiar un objeto vacío, ir al nivel que quieras
para habilitar el banner. Lo haré en el
nivel de oscilaciones. Tin, pega el objeto vacío, crea un nuevo objeto vacío, llámenlo banner ocho. Entonces podemos crear un nuevo script. El nombre también será banner ad, el script al objeto. Ahora bien, si abres el enlace que puedes encontrar
en los recursos, hay una sección
para anuncios de banner. Hay un
script de ejemplo sobre cómo implementar
anuncios de banner con botones. Usaremos un enfoque
diferente. Así que sólo podemos copiar
y pegar el código, como en la conferencia anterior. Usaremos algunas partes. Al implementar ayudas. Necesitamos conocer Ed IDs
para Android e iOS. Entonces, ¿cómo conseguimos unos? Vaya a su panel de control, seleccione monetización
y unidades de ed abierta. Aquí tenemos todos los tipos. Podemos seleccionar anuncios de banner. Se puede ver el nombre
y la identificación del anuncio. Tenemos uno para Android
y otro para iOS. También podemos crear
nuevos bloques de anuncios. Elige un nombre y firma aplicada. Entonces puedes elegir
qué tipo de unidad. Ahora deberías ver tu unidad de
edición en la lista. Solo para mostrarte,
puedes ir a editar ajustes. Aquí si es necesario, puede
cambiar algunos ajustes. No vamos a utilizar este anuncio de banner. Yo sólo quería
mostrarte el proceso. Vamos a enviarlo al archivo. Usaremos los predeterminados. Recuerda, es importante
conocer los ID de nuevo en el guión. El objetivo es cargar y
mostrar el anuncio de banner. Primero, necesitamos incluir el espacio de nombres de
anuncios. Entonces vamos a crear dos variables de cadena de
identificación, una para Android y otra para iOS. Podemos establecer valores predeterminados. Ten en cuenta que es mejor idea
copiar y pegar para que no
cometas ningún error. Entonces necesitamos una
cadena, un ID de unidad. A continuación, podemos crear una variable de posición de banner para
que podamos elegir
dónde mostrar el anuncio. Al inicio, vamos a
establecer una identificación de unidad. Usamos hash si Unity, iOS, lo que significa que estamos
usando un dispositivo iOS, luego establecemos el ID del anuncio del IRS, luego un hash L si Unity Android. Por supuesto, aquí usamos ID de bloques de anuncios de
Android. Cierra esto con hash. Y si no necesitamos
la función de actualización, crear un vacío público, cargar el anuncio de banner. Primero, fijemos la posición. Luego crea opciones de carga de banner. Aquí usamos una devolución de llamada de carga que activará su propia función de carga de
banner. Lo crearemos en un momento, usaremos un coma y crearemos callback de
error que activará su propia función de error de banner. Vamos a crear esas
dos funciones. Error de banner propio ocurrirá
cuando algo anda mal. Así que solo podemos usar
el bug Datalog. carga de pancarta propia se activará cuando la Tierra haya
terminado de cargarse. Antes de hacer algo aquí, necesitamos
llamar realmente a la función load. Así que de vuelta aquí, después de
las opciones que
hicimos, usamos banner publicitario que permitía y pegamos el
ID con las opciones. Entonces, cuando el anuncio de banner
esté cargado y listo, lo
mostramos usando
la función show. Por supuesto, tenemos que pasar la identificación. Ahora, solo tenemos que llamar a esto un anuncio de banner de carga en alguna parte. Depende del
juego y de tu elección. Voy a llamar a esta
función en el inicio. Entonces cuando iniciemos el nivel, deberíamos ver la pancarta. En Unidad. Se
asegura de que las ideas sean correctas y elija
la posición del banner. Vamos a probarlo. En editor de Unity. Es difícil verlo. En un juego real. Será más grande. Déjame acercarme un poco. Se puede ver aquí. Si ve algún error, asegúrese de que el
paso de inicialización esté completado. Así que intenta probarlo
iniciando el juego
desde la primera escena. Aquí hacemos inicialización, vamos a Selección de Nivel, y el banner está aquí. Ahora puedes crear un prefab. Se puede colocar este prefab
en cualquier unidad de nivel. Se puede colocar
en múltiples niveles y todo va a
funcionar bien. Solo vamos a crear uno, una medida de seguridad en el script antes de
cargar y mostrar el anuncio, Comproquemos que el
anuncio esté inicializado. Bonito. Tenga en cuenta que todo lo que
habíamos hecho en este script, puede hacerlo en el script de
inicialización. Yo solo quería separar el contenido para que sea
más fácil de entender. Gracias por verte y
verte en la próxima conferencia.
67. Anuncios para Skippable: Hola otra vez. En esta conferencia,
creamos anuncios intersticiales. Esos son anuncios de los que un
jugador puede escapar. La idea es crear
un anuncio que
aparecerá después de jugar
algunos niveles, por ejemplo jugamos un nivel cuando
reiniciamos o vamos
a otro nivel, se juega
una ed intersticial. Por supuesto, puedes elegir con
qué frecuencia aparecerá un anuncio. Ahora, podemos comenzar con
la implementación. Todavía estamos en el equipo de soluciones de
nivel. Vamos a crear un nuevo objeto de juego. Yo lo llamo ayuda intersticial. Después crea un nuevo guión. También llámalo intersticial, agrega el
objeto script y ábrelo. También contamos con documentación para
implementar anuncios intersticiales. Aquí hay mucho contenido. Voy a copiar una parte
y luego la
modificaremos e iremos paso a paso. Copiemos esta parte que
incluye el ID de Ayuda. Solo asegúrate de que los ID coincidan con los de la monetización de
Unity. Si vas a monetización, puedes seleccionar intersticial. Y aquí puedes ver IDs
para Android e iOS. Si quieres, puedes
crear nuevos bloques de anuncios aquí, pero voy a usar los predeterminados. Ahora, echemos un
vistazo a la función despierta. Asignamos un id comprobando si estamos en un dispositivo iPhone
o Android. Hay que tener cuidado con una
cosa. En el editor de Unity, esto siempre usará Android ID, ID, incluso si
eliges iOS built, el ID será para Android. Porque no estamos usando iPhone. Estamos en Mac o PC. Repito, esto es sólo
en editor de Unity. En un juego real,
funcionará bien, pero eso dificulta probar anuncios para iPhones en el editor. Entonces, si quieres probar Ed's para dispositivos
iOS en el editor Unity, necesitas usar un método
que usamos en Banner Ads. Vamos a copiar y pegar esta parte. Entonces, comente esta parte. Por supuesto, no hace
falta que hagas esto. Esto es solo una pequeña
digresión para pruebas. Vamos a continuar. Necesitamos el espacio de nombres de
anuncios. Aquí necesitamos dos interfaces. El primero está permitido LA Center, y el segundo es el escenario de
Chablis. Implementemos funciones. Tenemos una función que se
llama cuando se
completa la carga y otra cuando no
se completa. Implementemos funciones
para el oyente. Este es cuando hacemos
clic en el Agregar. A éste se le llama cuando
se completa la ayuda. Entonces cuando el no se muestre y cuando la
cabeza empiece a mostrarse, modificaremos algunos
de ellos posteriormente. Simplemente voy a mover
estas funciones hacia abajo. Ahora, vamos a crear una función ed de carga
nula pública. Comprobamos si el anuncio
está inicializado. Si eso es cierto, entonces cargue el ED con el ID de ED. Y esto permitió al oyente. A continuación, crear un espectáculo
vacío público función Ed. Aquí usamos la función show, pegamos el ID, y
este show listener. Vamos a usar una carga ed en despierto. Se puede elegir cuándo
mostrar el ED. Lo mostraré inmediatamente
después de que se haga la carga. Vamos a probarlo. Iniciamos la prueba desde la primera escena porque
aquí inicializamos Eds, vamos a Selección de Nivel. Y se puede ver la ed. No obstante, tenemos que
resolver tres cuestiones. Primero, el juego sigue
funcionando en segundo plano. Tenemos que detenerlo. Lo segundo,
tenemos que esconder la pancarta. Lo último que tenemos que elegir con
qué frecuencia aparecerá esto. No quieres que lo
juegue cada
vez que el jugador
cambie de obrero. Para facilitar las pruebas
desde el principio, viendo, vamos a crear
el controlador de ayudas. El controlador prefabricado es
responsable de la inicialización. Ir a un nivel de selección. Reproduce el prefab en la escena. Si lo pruebas directamente
desde Selección de Nivel, aún así la ayuda no se ejecutará. Tampoco tenemos
el anuncio de banner. Esto se debe a que
hacemos inicialización, cargando y mostrando al
mismo tiempo en despierto o inicio. La inicialización tarda algún
tiempo en completarse y carga se llama antes de que termine
la industrialización. Por eso no solemos inicializar en
la primera escena. Así que tenlo en mente. Necesitamos crear el
intersticial, un Prefab. Entonces podemos copiarlo. Objetos, ve al
nivel uno y
pegarlos para colocar estos
tres objetos en cada escena en la
que quieras anuncios. Vamos a probarlo. Comience desde el selector de nivel. Ir al primer nivel. Se puede ver. Observe que puede escuchar disparos
en el fondo. Ahora tenemos que abordar los
tres temas que mencioné. En el intersticial, un guión encuentra en las ayudas de Unity, show start. Cuando iniciemos el ED, detengamos el tiempo. Y al establecer la escala de
tiempo a cero, esto impedirá que el
juego se ejecute en segundo plano mientras se juega
el DEA. Cuando se completa el DEA, restablecemos la escala de tiempo a uno. Entonces deshabilitemos el banner. Cuando iniciemos el DEA, usa publicidad,
esa pancarta que esconden. Muéstralo de nuevo, necesitamos una referencia a la clase
banner ed. Después en Show complete, use un anuncio de banner de carga. Ir a la unidad, seleccionar ed
intersticial y
arrastrando anuncio de banner. Después degustarla desde el nivel de
selección hasta el primer nivel. Observe que no hay ningún anuncio de
banner. También. No se oye el tiroteo. Por alguna razón, el lugar de la música de
fondo, pero esto es un error
en el editor de Unity. Vamos a saltarnos el anuncio. Y ahora se puede ver la pancarta. Bonito. Lo último,
no queremos mostrar anuncios
intersticiales después de
cada nivel de cambio. Así que vamos a crear un tiempo
entero para saltar y establecer el valor
predeterminado en uno. Este número determinará
cuántas veces podemos recargar o cambiar el nivel
antes de mostrar el anuncio. Siguiente en despierto, crear un
entero, saltar número, y utilizar prefs jugador, entrar en el k
será intersticial. El valor predeterminado es el
tiempo para omitir el número. Después comprueba si el número
es diferente a cero. Si eso es cierto, disminuirlo en uno. A continuación, guarda ese número. De lo contrario. Eso significa que el
número de salto es un cero. Entonces necesitamos cargar
y mostrar el ED. Después restablece el valor de
la clave intersticial. Vamos a probarlo. Desde empezar a ver
vamos a Selección de Nivel. Normalmente
tendríamos la cabeza aquí, pero el número de salto era uno. Ahora se reduce a cero. Entonces después de la siguiente carga, deberíamos ver que los anuncios van al
nivel uno y tenemos anuncios. Ahora, vamos a destruir al jugador. Deberíamos recargar sin ayudas
porque el número de salto
se restableció a uno. Si
volvemos a perder el juego y lo
reiniciamos, lo veremos. Bonito. Todo funciona. Tenga en cuenta que puede
ajustar el tiempo para omitir número en Unity
o en el script. Eso es todo por esta conferencia
y nos vemos en la siguiente.
68. Anuncios recompensados [1]: Hola a todos. Vamos a crear un
complemento de recompensa que dará opción de continuar el juego después de que el jugador sea destruido. Se ve así. Perderemos el juego. Obtenemos un panel con
el botón Reproducir. Vemos uno, Ed, y luego podremos
seguir jugando. Por supuesto, vamos a
limitar cuántas veces un jugador puede hacer eso. Comencemos a crear un
nuevo objeto de juego vacío. Yo lo llamaré ed recompensado. Después crea un nuevo script
con el mismo nombre. El guión al
objeto y abrirlo. También podemos abrir documentación de
Unity. El enlace está en los recursos. Hay un guión de ejemplo. Vamos a cambiar ligeramente
la implementación. Así que no se limite a copiar
y pegar todo el guión. Podemos copiar esta
parte para ID de Ayuda. Simplemente borra la parte
con el botón. Ahora asegúrate de que yo
estos son correctos. Vaya a la
monetización de su panel de control, seleccione anuncios recompensados y podrá ver ID para Android e iOS. Por supuesto, puedes
crear unidades de ayuda personalizadas. Aquí. Usaremos
los predeterminados de nuevo en el script. Para usar el espacio de
nombres de anuncios. También necesitamos un listener de carga y mostrar interfaces de escucha. Como antes, implementemos
funciones desde interfaces. Vamos a limpiarlo primero. Si lo desea, puede usar el
backlog en las funciones. Esta vez me saltaré eso. Vamos a mover esas
funciones a la parte inferior del guión. Bonito. Ahora, vamos a crear un público. Cargar, una función. Es público porque
tal vez necesites
llamarlo en algún lugar
fuera del guión. Entonces podemos usar la carga de
anuncios con un ID y este oyente
permitido. Antes de cargar, comprobemos que el anuncio
está inicializado. Podemos llamarlo despierto. Entonces vamos a crear un
espectáculo público, la función. Aquí, utilizamos
anuncios que muestran con un ID y este
show oyente. Ahora tenemos que elegir
cuándo llamaremos a este show función Ed y
qué pasará, entonces. Parte de la lógica estará en el inicio del espectáculo y mostrará funciones
completas. En la función show complete, le
damos una recompensa al jugador. En nuestro caso, reviviremos al jugador y él
seguirá jugando. Cada juego es diferente, así que cada implementación
es diferente. Es por ello que decidí hacer la implementación real
en una conferencia separada. Esto es solo una plantilla
y preparaciones básicas. Entonces nos vemos en la siguiente conferencia en la que implementamos
la lógica principal.
69. Anuncios recompensados [2]: Hola a todos,
bienvenidos a la segunda parte de implementar un anuncio gratificante. Ahora que tenemos una base
sólida, en realidad
podemos crear
un dominio, una lógica. La idea es tener
la posibilidad de
ver uno en un anuncio saltable después que el jugador sea destruido y
luego continuar el juego. Esta conferencia
será un poco más larga porque necesitamos
abordar muchas cosas, no solo el ED. Entonces concentración máxima
para ésta. Primero, necesitaremos una referencia al jugador y al banner publicitario. Cuando empezamos a mostrar
una educación gratificante, necesitamos ocultar la pancarta. También establezca la escala de tiempo en
cero para congelar el tiempo. Entonces escojamos qué sucede cuando se complete la gratificante
ayuda. Usamos la
declaración if y usamos este ID de ubicación para
verificar el ID o el ED. Así que nos aseguramos de trabajar con lo correcto recompensándolo. Después verificamos el Estado de
finalización, que es el estado del anuncio. Usa las ayudas de Unity, muestra el estado de
finalización. Como puede ver, podemos verificar
el guión completado
o estado desconocido. Necesitamos terminado. Esta condición asegurará
que ejecutemos el código solo si se completa la correcta ed
recompensada. Luego, reanude el tiempo
estableciendo la escala de tiempo en uno. Entonces podremos activar al jugador. Tenga en cuenta que tendremos que
cambiar el código en estadísticas
del jugador para que no
destruyamos el objeto del jugador. En lugar de destruirlo, lo deshabilitaremos y
lo habilitaremos. Aquí. Necesitamos, de nuevo una carga y
mostrar el ID del banner. A continuación, podemos preparar y
permitir el siguiente, recompensándolo. En Unity, arrastrando el
banner publicitario y el reproductor. Entonces podemos ir a las estadísticas de los jugadores. Como dije, aquí, no
queremos
destruir al jugador. Así comente destruir. Desactivaremos al jugador. Por supuesto, necesitamos resolver
cómo restablecer las variables cada vez que habilitamos al jugador, por ejemplo, necesitamos restablecer la
salud, la barra de salud, etc. Por eso reemplazamos
start con ONE enable. Simplemente mueva el disparo del jugador, obtenga componente en
la función de inicio. Vayamos a la unidad. Ahora, vamos a crear una pantalla
que tendrá un botón. La pantalla aparecerá cuando
desactivemos al jugador. Ve a Canvas, selecciona panel y cambia alfa a uno. Después selecciona Pantalla
y duplícalo. Renombrarlo. Entonces habilitarlo. Haga doble clic en el
panel y amplíe. Vamos a crear un nuevo botón. Yo lo llamaré, jugarlo. Eliminar el texto,
no lo necesitamos. Entonces podemos cambiar el sprite. Ir a sprites. Tú eliges este botón
naranja de reproducción, lo
arrastras al campo de imagen de
origen. Haga clic en Establecer tamaño nativo. El tamaño es bueno. Ahora tenemos que
arreglar los elementos. Ampliemos un poco el
fondo. Mueve la puntuación y la
puntuación más alta hacia abajo, y mueve el botón de suma hacia arriba. Esto se ve bien. Ahora vamos a abrir el script del
controlador del panel, que controla las pantallas de
ganar y perder. Tenemos que agregar la pantalla
ed que hicimos. Entonces necesitamos otra variable de objeto de
juego. Yo lo llamo una pantalla suelta. Como antes, vamos a crear una función pública
que la active. Establece Canvas alfa en uno y activa el objeto del juego. En este caso, necesitamos una función más que
desactive la pantalla. Establece alfa en cero y desactiva el objeto del juego. De vuelta en Unity. No olvides arrastrar
la pantalla de Ed Lewis al script del controlador
del panel. Ahora selecciona el botón de reproducción. Necesitamos agregar funciones
a este botón, Crear a eventos onclick. Para el primero arrastre
el controlador del panel. Aquí, necesitamos
desactivarlo, perder. Entonces, cuando presionemos este botón, desactivaremos esta pantalla. Después arrastrando el objeto Ed
recompensado llamado The Show add function. Podemos desactivar la pantalla. Ahora. Seleccione panel y
devuelva alfa a cero. Vamos al guión final del gestor de
juegos para implementar más lógica. Desplázate hacia abajo y crea una nueva función pública, el juego de
Ed Lewis. Aquí usamos el controlador de panel y activamos la pantalla de edición. Hay que tener cuidado porque un jugador puede decidir no
verlo y reiniciar el juego
o salir al menú principal. Por lo tanto, necesitamos usar la función de conjunto de puntuaciones que guardará la puntuación
en la puntuación más alta. Pero también restablecerá la variable de
puntaje a cero. Esto causará
problemas si un jugador decide ver un anuncio
y seguir jugando. Tengo n es una solución para esto. Cambiemos el modificador de
acceso de la variable score,
hagámosla pública. Después ve a ed premiada. Cuando arranca la cabeza, podemos cargar la partitura. Usa PlayerPrefs que obtienen int. La mejor idea es
copiar y pegar la clave. Entonces aquí guardamos la partitura
antes de borrarla. Vamos a copiar la clave
y pegarla aquí. Bien, no hemos terminado, pero podemos probar esto. En End Game Manager. Cuando perdemos un juego, llamemos a la función de juego Aide
Louis. Tenga en cuenta que vamos a cambiar esta declaración
if else en un momento. Esto es solo para pruebas. Empecemos desde
el nivel de selección. Ir al nivel uno, y vamos a perder el juego. Puedes ver esta puntuación, la puntuación más alta y
el botón Agregar. Vamos a darle un click sobre él. Vemos un anuncio, y cuando esté terminado, podremos continuar el
juego un poco a plena salud. Observe que el puntaje solo sigue aumentando,
no es cero. No obstante, en este punto, podemos ver el anuncio cada
vez que perdamos el juego. Eso no es lo que queremos. Tenemos que limitar esta opción. Necesita aparecer tal vez
solo una o dos veces. Sólo quiero una pequeña digresión. En ocasiones si intentas probar esto directamente desde el nivel uno, obtendrás un error es
porque en la función Enable, End Game Manager aún no
se crea la instancia y tratamos de
usarla para resolver esto. Ir a Configuración del proyecto. Después ejecución de script, orden. El final, el
script del administrador del juego a la lista, luego moverlo por encima del tiempo predeterminado. Debe tener un valor negativo. Ahora el script se
ejecutará antes que otros scripts. Eso significa que la instancia se
creará antes que intentemos llamarla en su
propia función enable. Ya se puede ver
que no hay errores. Genial. Antes de continuar
con otras cosas, agreguemos algo de
tiempo de protección al jugador. Cuando termine el ayudante, vaya a estados de jugador,
cree un público. Bool, puede tomarlos como variables, establecer el valor predeterminado en true. Entonces vamos a crear una función de enumerador de
ojos. Set puede recibir daño a false. Entonces esperamos un poco. Voy a ir con 1.5
s. después de eso, nos fijamos puede tomar daño a true. En la función de etiqueta
dañada del jugador, comprobamos si puede recibir
daños es falso. Después regresa y no
dañes al jugador. En la propia función enable. Utilice la corutina de inicio para
llamar a la función de
protección contra daños. Bonito. Ahora, quiero darle protección
adicional
al jugador cuando mostramos el parabrisas. En End Game Manager, vamos a crear la variable de
estados del jugador, que llamo jugador. A continuación, vamos a crear una función
para registrar las estadísticas de los jugadores. Este es el mismo procedimiento que para otras funciones de registro. Establecer jugador dos estados, jugador, luego ir
a estados de jugador. Y en la función de inicio, vamos a registrar las
estadísticas de este jugador ante el manager. En Juego Final, Gerente. En el juego, un conjunto de funciones
puede recibir daño a false. Cuando mostramos el parabrisas, nada le puede pasar
al jugador. Ahora, necesitamos actualizar esta declaración if else con
algunas condiciones. Sólo para recordarte, esto es importante
para este concepto. Cuando derrotamos al jefe
o llegamos al cronómetro. Primero, esperamos un poco de tiempo antes de resolver el juego. Es por balas y enemigos que aún pueden
estar en la pantalla. Ahora, cuando implementamos ayudas, hay un
caso en el que el jefe y jugador pueden ser destruidos
al mismo tiempo. Además, el jugador
puede ser destruido al final de un nivel por debajo de estos 2.5 s. Estamos
al final de un nivel. No queremos
mostrar un la pantalla. Tenemos que mostrar una pantalla suelta. En ese caso. Por eso introducimos
una nueva variable. Vamos a crear una
variable bool pública, posible viento. Entonces, ¿cómo usamos esta variable? Pasemos al guión de
las condiciones del viento. Cuando el temporizador ha
caducado y no
tenemos un jefe entonces establecer
posible cuando a true. Cuando tenemos un jefe, entonces tenemos que ir a
su jefe ese estado. Cuando destruimos al
jefe, establecer posible, cuando el verdadero de vuelta
al gerente. Cuando es posible, ¿cuándo es verdad? Eso significa que derrotamos al
jefe o el temporizador ha caducado, y GameOver es falso, lo que significa que no lo hicimos, ellos activan al jugador, entonces queremos el juego. Siguiente caso. De lo contrario, si es posible,
cuando es falso, lo que significa que no estamos
al final de un nivel, sino que desactivamos a los jugadores
ya que el juego terminado es cierto, entonces queremos mostrar una pantalla. Necesitamos otra más. Si es así, si es posible, cuándo es verdad y el
juego terminado es cierto. Eso significa que el jugador es el activado al final de un nivel. Entonces no uses una pantalla, solo una pantalla suelta. Yo sólo voy a poner comentarios para
que sea más fácil de entender. Desde fin el manager del juego
es estético singleton. Necesitamos restablecer la variable
cuando posible en otro script. Podemos ir a las estadísticas de los jugadores. En inicio. Podemos establecerlo en falso. Entonces cada vez que iniciemos un nivel, será falso. Ahora, tenemos que limitar
el número de anuncios. Vamos a crear una referencia
para el anuncio recompensado. Después crea una función
para registrarla. Yo lo llamo registro recompensado en. El procedimiento es
el mismo que antes. Ir al guión del anuncio recompensado. En la función start, vamos a registrar este objeto. Entonces vamos a crear un número int
público. Por defecto, puede ser uno. Eso significa que solo podemos
ver uno, lo recompensamos. Back to End Game Manager. En la función de juego de Ed Lewis, verificamos el número de anuncios. Si es mayor que cero, entonces muestra la pantalla del anuncio y
disminuye el número en uno. De lo contrario. No nos queda ninguna. Así que usa el controlador de panel
para activar la pantalla de pérdida. Ahora podemos probarlo. Voy a tener un solo anuncio. Juguemos el juego
y lo perdamos. Una vez. Ver el anuncio. Entonces sigue jugando y vuelve
a perderlo. No nos queda ninguna. Entonces vemos la pantalla de Louis. Bonito. Puedes crear un prefabricado
gratificante. Además, no olvides anular
los cambios en el lienzo. Y ya terminamos. Si necesitas, puedes agregar
algo de lógica cuando la ayuda no logra demostrar que esto es
específico para cada juego, pero ahora tienes una idea
de lo que debes hacer. Cosas por ver y
verte en la próxima conferencia.
70. Notificaciones de Android: Hola a todos. Veamos cómo podemos crear notificaciones para dispositivos
Android. Primero, asegúrate de
usar la plataforma Android. Luego ve a Package Manager,
selecciona Unity Registry y busca notificaciones, selecciona notificaciones móviles
y haz clic en Instalar. Ahora, vamos a crear un
nuevo objeto de juego vacío. Lo llamaré notificación
Android. Entonces necesitamos crear un script. Para mantenerse organizado. Crearé una nueva
carpeta de notificaciones, crearé un nuevo script y lo llamaré notificación de
ejemplo de Android. El guión al
objeto y abrirlo. Primero, necesitamos la unidad en notificación
android namespace. Ahora, vamos a crear
algunas variables. Necesitamos un ID de
notificación de número entero y un ejemplo de ID de
canal de cadena. A continuación, vamos a crear una función de
ejemplo de notificación de anulación pública. Tomará un
parámetro, fecha y hora. Con fecha y hora,
podemos manipular la hora y determinar cuándo
enviar una notificación. Para entenderlo mejor, podemos depurarlo. Puedo decir por ejemplo esa vez. Ahora, lo que me dará
la fecha y hora actuales. Simplemente conviértalo en una
cadena para que podamos verlo. Comienza el juego. Y en la consola, deberías ver la
fecha y hora actuales como una cadena. Bonito. Entonces tenemos que hacer dos pasos. El primero es crear
un canal de notificación, y el segundo es crear
una notificación real. Empecemos por el canal
de notificación. Usa el canal de
notificación de Android y crea una nueva instancia. Primero, establecemos el ID del canal. Aquí. Podemos pegar
la variable de
ejemplo id de canal
que creamos. Entonces podemos darle un
nombre al canal. A continuación, podemos tener una descripción. No es realmente importante
para lo que hacemos. Entonces podemos establecer importancia. La importancia de la
notificación se utiliza para determinar cuánto
debe interrumpir
la notificación al usuario. Se puede ver lo que hace
cada opción. Iré con el predeterminado. Después de crear un canal de
notificación, necesitamos registrarlo. Así que usa el centro de
notificaciones de Android, ese canal de
notificación registrado paga el canal
que creamos. El segundo paso es crear una notificación de
Android. Crear una nueva instancia. Primero, podemos establecer el título, luego el texto de
la notificación. También podemos elegir iconos
pequeños y grandes. Para la notificación. Voy a usar el icono por defecto, que es logo unitario. Entonces, ¿cómo cambiarlos? Ve a Unity, configuración del proyecto
y notificaciones móviles. Aquí puedes agregar
icono de notificación soporte Android. Puede elegir pequeños iconos
agrandados, y cada icono tiene un identificador de
cadena. Entonces, por ejemplo, si
estableces un pequeño icono con el identificador de
ejemplo, entonces escribirías ese
identificador en el script. Lo último que
necesitamos es un tiempo de fuego. Esta es la fecha y hora en que se enviará la
notificación. Aquí utilizamos el
parámetro time to fire. Se realiza la notificación. Ahora tenemos que dispararlo. Utilizamos el centro de
notificaciones de Android que envió una notificación, pegamos el ID del
canal de notificación. Ahora, necesitamos determinar cuándo y cómo
programar la notificación. Para nuestro propósito, vamos a
utilizar en el enfoque de la aplicación. Su propia función de
enfoque de aplicación tiene un enfoque de parámetro de perno. Esta función se llama cuando la aplicación pierde
o gana foco. Eso significa que cuando
minimizamos la aplicación, el parámetro focus
será falso. Cuando maximizamos o
ingresamos a la aplicación, enfoque se hará realidad. Entonces nuestra idea es programar la notificación cuando el jugador minimice
la aplicación. Después de algún tiempo, le diremos al jugador que
regrese y juegue. Entonces, si el foco es falso, podemos usar fecha, hora, configurarlo a
la hora que ahora, y luego podemos agregar tiempo. Como puede ver, podemos agregar días, horas, minutos,
segundos, y así sucesivamente. Agreguemos un día a partir de
la hora actual, que será cuando el jugador
minimice la aplicación. Entonces llamamos ejemplo de
notificación y paga fue al fuego fecha hora. Si el jugador regresa y abre la aplicación antes de que se envíe la
notificación, entonces necesitamos cancelar la notificación
programada. Podemos cancelarlo con un centro de notificaciones rojo que puede vender todas las
notificaciones programadas. Y nuevamente, cuando un jugador
minimice la aplicación, agregaremos tiempo y programaremos
otra notificación. Tenga en cuenta que esto cancelará
todas las notificaciones programadas. Te voy a mostrar cómo cancelar solo esta notificación aquí arriba. Cuando enviamos la notificación, podemos usar enviar
notificación con Id explícito,
pegar el ID del
canal de notificación. Entonces necesitamos pegar
el ID de notificación. Si recuerdas, creamos
una variable para esto. Así paga el ID de notificación. Entonces, en lugar de cancelar
todas las notificaciones programadas, podemos usar la
notificación programada y paga el id de notificación. genial. Para fines de prueba. No utilicemos esto. En cambio, solo agrega 10
s. No hemos terminado. Tenemos una
cosa importante que hacer porque vamos a construir este
juego para Android e iOS. Este código nos dará errores a la
hora de construir para iOS. Para resolver este problema, necesitamos compilar el script solo si estamos usando Android. Entonces primero, resolvamos el espacio de nombres de
Android Notification. Usamos si Unity Android
y lo cerramos con hash. Y si. Ahora esta línea de código se
compilará solo para dispositivos
Android, también
necesitamos hacer lo
mismo dentro de la clase. No necesitamos el bloque que registra antes de la función de
ejemplo de notificación. Si Unity Android y ciérrelo después de la propia función de enfoque de
aplicación. Ahora ya terminamos. Si lo desea, puede
crear variables con valores
predeterminados y
pegarlas en la función. En Unity, puedes cambiar valores, luego crear un prefab y
colocarlo en cada pecado que desees. Construyamos la aplicación en
el teléfono para probarla. Edificio a teléfono está cubierto
en conferencias anteriores. Así que compruébalo si no lo hiciste. Bien, ahora estamos al teléfono
y abramos el juego. Ir al nivel
de selección pecado. Entonces podemos minimizarlo. Y en 10 s, deberíamos
ver la notificación. Como pueden ver, está aquí. Da clic en él, y
estamos de vuelta en el juego. Puedes usar este
conocimiento para crear diferentes tipos
de notificaciones. Y eso es todo por esta conferencia. Gracias por verte y
verte en la siguiente.
71. Notificaciones de iOS: Hola a todos. Vamos a crear notificaciones para dispositivos iOS. La lógica será la
misma que para los dispositivos Android. Simplemente la sintaxis es diferente. Si no viste la conferencia de notificación de
Android, te
sugiero que la hagas
antes de ver esta. Nota. Solo una cosa importante para probar las notificaciones
en tu iPhone. Necesitas tener una cuenta de desarrollador de
Apple. Costaba 99 dólares al año. Así que tenlo en mente. Bien, primero, cambiemos
la plataforma a RS. Luego ve a Package Manager, selecciona Unity Registry
y busca el
paquete de notificaciones móviles, luego instálalo. Si no lo hiciste. Lo hicimos en la conferencia
anterior. Luego ve a Configuración del proyecto, selecciona Notificación móvil
y ve a iOS. Habilite la autorización de solicitud
en un lanzamiento por lanzamiento. Eso abrirá una ventana emergente de
diálogo cuando un jugador ingrese al
juego por primera vez, luego un jugador puede
permitir notificaciones. Esto nos ahorrará mucho trabajo. De lo contrario, tendríamos que
hacerlo nosotros mismos en el código. Ahora, vamos a crear
un nuevo objeto de juego y llamarlo notificación de iOS. Después crea un nuevo script, que llamaré ejemplo de
notificación de iOS. El guionó el
objeto y lo abrió. La idea es crear una
notificación que invite a un jugador a regresar y jugar el juego después de algún
periodo de tiempo. Primero, usemos la unidad en la
notificación, el espacio de nombres de iOS. No necesitamos funciones predeterminadas. Vamos a crear una
variable de cadena, ID de notificación. A continuación, cree un ejemplo de
notificación de nulidad pública. Aquí creamos una instancia de
notificación de iOS. Lo primero que
asignamos es identificador, pega el ID de notificación. Entonces podemos establecer el título
de nuestra notificación. También tenemos el subtítulo. Entonces tenemos cuerpo. Este será un texto
para la notificación. La siguiente propiedad se
muestra en primer plano. Si se establece en true
, mostrará una notificación. Incluso si la aplicación está abierta, nuestra notificación invitará a un jugador a regresar y jugar. Entonces tenemos que establecerlo en falso. Solo para mostrarte si planeas
hacer otro tipo de notificación y estableces
esa variable en true, entonces puedes elegir la opción de
presentación en primer plano. Si eres tipo de opción de
presentación, puedes ver alerta, placa, ninguno y sonido. Básicamente, eliges qué tipo de notificación será. También puedes usar combinaciones. Así que puedes, por ejemplo, elegir Alerta y luego escribir una
vertical alineada. Usamos dos de ellos
para OR lógico, pero aquí escribimos solo uno. Entonces también puedo usar el sonido. La siguiente propiedad es el identificador de
categoría. Puedes agrupar las notificaciones
en categorías y luego realizar algunas operaciones que afectarán a todas las notificaciones
del mismo grupo. No es tan
importante en nuestro caso, así que ponlo en la categoría a. lo siguiente es
el identificador de
hilo. Además, no es importante
para lo que estamos haciendo. Así que vamos a seguir
la documentación. Será hilo uno. Entonces tenemos una propiedad
importante. Es gatillo. Determina cuándo
enviaremos la notificación. Así que vamos a crear un nuevo desencadenador de
intervalo de tiempo de
notificación de iOS . Luego establezca el intervalo de tiempo en el
nuevo sistema, ese lapso de tiempo. Aquí, podemos optar por agregar días, horas, minutos,
segundos, y así sucesivamente. Para elegir un día, cambiamos esto a uno. Pero para propósitos de prueba, usemos 10 s. Entonces necesitamos establecer repeticiones en false para
que no lo repitamos. Esta notificación cada 10 s. Después de que creamos la
notificación, programémosla. Utilice el
centro de notificaciones de iOS que programa notificación y pegue
la notificación. Entonces usaremos la propia función de enfoque de
aplicación. Para más detalles
sobre esa función, consulta la conferencia de
notificaciones de Android. Pero esencialmente,
este parámetro de enfoque se vuelve falso cuando
minimizamos el juego. Y cierto cuando
maximizamos el juego. Cuando minimizamos el juego, queremos llamar
al ejemplo de notificación que programará la notificación. Si el jugador
regresa al juego antes de que se enviara la
notificación, entonces tenemos que eliminarla. Quita la
notificación programada y paga el ID de notificación. Ya casi terminamos. Si quieres, puedes
crear las variables y luego pegarlas
en la notificación. Lo último que tenemos que
hacer para evitar errores es compilar este script solo
si estamos construyendo para iOS. Primero, resolvamos
el espacio de nombres. Usamos hash si Unity iOS y lo
cerramos con efectivo. Y si. Ahora esta línea se compilará
solo para dispositivos iOS, necesitamos hacer lo mismo
dentro de la clase. Ir a la unidad. Podemos establecer las variables
en el Inspector, luego crear un prefab y
colocarlo en cada escena que desee. Como dije a estas
notificaciones para iOS, necesitamos tener una cuenta de
desarrollador de Apple, que actualmente no tengo
una.Si tienes una, puedes construir el juego por
teléfono y probarlo. Construyendo en el
teléfono se cubrió en conferencias anteriores del curso. Eso es todo por esta conferencia. Nos vemos en la siguiente.
72. Perfilador: Hola a todos. En esta conferencia, echamos un vistazo a
cómo usar el perfilador y detectar posibles problemas de
rendimiento. También aprenderemos a usar profiler directamente
con tu teléfono. Empecemos a ir a
Análisis de Ventanas y Perfilador. Deberíamos ver
algo así. Primero, se asegura de que
el botón de grabación esté activado. A continuación, habilite el perfilado. Perfilado profundo habilitado. El perfilador
analizará cada parte de su código de script y
grabará todas las llamadas a funciones. Entonces podemos elegir
cómo queremos ver Jerarquía de Selección de Datos. A continuación, coloca esta pestaña
en algún lugar abajo así. Y podemos extenderlo. Cuando presionamos el botón Reproducir, deberíamos ver algunos
datos en la gráfica. Los datos se miden fotograma a fotograma. Si presionamos sobre algún fotograma, el juego posará y podremos ver detalles sobre
ese fotograma específico. Debes buscar picos ya que indican
una caída de rendimiento. Solo recuerda que
los picos son normales hora de cargar y
cambiar los niveles. Cosas que debes buscar para nuestra recolección de basura
y tiempo en milisegundos. Tenga en cuenta que puede
ignorar el bucle del editor. Esto es del editor de Unity. No existirá cuando
construyas el juego. Incluso podemos eliminar
esos datos de la gráfica deshabilitando otros. Observe que cada dato es
presentado por un color, por ejemplo, scripts o azul oscuro. Además, puedes estar atento a los FPS
en el lado izquierdo. Ahora sobre los datos, nos
interesa player loop. Así ampliado para más detalles. Aquí puedes ver datos de todo tipo de scripts
y paquetes. Podemos encontrar los
guiones que hicimos. Vaya a actualizar ese script, ejecutar comportamiento, actualización de comportamiento. Solo fíjate que aquí no
tenemos ningún problema. No hay recolección de basura y el tiempo es muy corto. Puedes ver las
llamadas de actualización desde nuestros scripts. Por ejemplo, aquí está
la actualización de meteors pounder. Hay
controles de jugador y así sucesivamente. Por supuesto, puedes
ampliarlo para obtener más detalles. Recuerda, es importante
comentar o eliminar, depurar registros antes de construir
y publicar el juego. Para mostrarte por qué creé un objeto con el
guión, encuéntrame. Solo tiene la actualización del registro de
errores n. Vamos a correr el juego. Seleccione cualquier fotograma,
busque el guión. Se puede ver que el backlog
crea algo de basura y toma 0.13 milisegundos
para deshacerse de ella. Téngalo en mente. No obstante, estamos haciendo
un juego para teléfonos. Por lo que probar en una PC no te
dará la imagen real, sobre todo si tienes
un PC realmente bueno. Te mostraré cómo usar
profiler con dispositivos Android. Para iPhone, es
un poco diferente. Entonces pondré el enlace a la documentación para usar el
perfilador con tu teléfono,
ir a Archivo, Build Settings, conecta tu teléfono y lo
seleccionaré como dispositivo. Tengo un viejo que
se va a hacer pruebas. Luego, habilite el desarrollo
construido a partir del perfilador de
conexión y
perfilado profundo del soporte. Entonces puedes hacer clic en Build
y el run o pitch and run. Espera a que todo esté hecho. El juego debería ejecutarse
en tu teléfono y el perfilador debería ejecutarse
automáticamente. Si no ve ningún dato,
expanda el modo de visualización, vaya a los dispositivos locales
y elija su teléfono. Si tu juego se está ejecutando, deberías ver datos. Tenga en cuenta que estos datos son de
su juego en el teléfono. Esperamos algunos picos
y caídas en el rendimiento al pasar de nivel en
nivel y ese tipo de cosas. Eso es normal. Seleccione cualquier
fotograma y defina el guión. ¿Dónde está el registro de puntos de depuración? Puede ver encontrar el registro de
actualización y depuración. Crea basura y se
inclina por el juego en el teléfono. Así que no olvides
eliminar los registros de depuración. Es una buena idea probar
el juego en más teléfonos. Así que invita a tus amigos y ve cómo se siente en
diferentes dispositivos, más teléfonos, mejor. El objetivo es detectar la recolección de
basura
y otros problemas. Si los encuentras, entonces necesitas pensar en cómo mejorar y optimizar los scripts. A veces es posible
y a veces no lo es. Cada juego es diferente. Eso es todo por esta conferencia. Nos vemos en la siguiente.
73. Pooling de objetos: Hola a todos. Optimizemos un poco
el juego. Como saben, cuando disparamos, se
crean y destruyen muchas balas. Eso puede ser un pequeño
problema para los dispositivos más antiguos, por lo que tenemos que abordarlo. La idea es crear tirar de
objetos. Imagínese que tenemos una
piscina con objetos de juego, en este caso balas. Están instanciados
pero inactivos. Cuando disparamos, obtenemos una bala de la piscina y la activamos. Entonces no destruimos balas. Los regresamos a la
alberca y los reutilizamos. Veamos cómo podemos
aplicar esto en nuestro juego. Selecciona el jugador y el jugador
al que vas a disparar. Vamos a utilizar la unidad está construida
en el método de tracción de objetos. Es relativamente nuevo. Usamos el espacio de nombres
del pool del motor Unity. Necesitamos reemplazar este tipo de objeto de juego con
el guión que usan las balas, y eso es una bala láser. Recuerda el nombre de esta
variable, blazer bullet. Siguiente. Para crear una variable de
grupo de objetos. Dentro de corchetes puntiagudos,
elegimos el tipo de este poste. ejemplo, puedes tener un
grupo de objetos de juego, pero necesitamos un charco
de balas láser. Yo lo llamaré polo. Entonces necesitamos crear una
nueva instancia de ese pool. En la función despierto, use un nuevo polo de objeto y un tipo de bala láser entre
los soportes puntiagudos. Después abre y cierra
el paréntesis. Notarás que tenemos un error es porque necesitamos crear algunas funciones
para el pool y las paga
entre paréntesis. Entonces la primera
función es en la que instanciamos el
objeto que necesitamos. La segunda función se utiliza para tomar el objeto que creamos. Lo llamamos escribiendo
el nombre de la encuesta, que es polo en nuestro caso, entonces que obtiene la tercera
función se usa para devolver el objeto
al polo y lo
llamamos con Paul ese lanzamiento. Vamos a crear la
primera función que creará objetos
para la encuesta. Esta función necesita devolver el mismo tipo que el tipo de sondeo, que es bala láser. Yo lo llamo crear un objeto de sondeo. Aquí. Una instancia de
la bala láser. Así que instanciar bala láser
con la posición y rotación del jugador
al crear un objeto. posición y la rotación no
son importantes en nuestro caso porque las
cambiamos más tarde. A veces puede ser
importante y es una buena idea crear objetos
fuera de la pantalla. Así que tenlo en mente. Después devolvemos la bala. Pegue esa función en el
pool dentro del paréntesis. Ahora, vamos a crear
una función
que tome objetos de la encuesta. Yo lo llamo, coge
bala de Paul. Necesita tomar un
parámetro, bala láser. Cuando cogemos un balazo, entonces vamos a activarlo. Aquí. En ocasiones se puede establecer
la posición de la bala ,
pero como usaremos
múltiples posiciones, déjelo así. Entonces vamos a crear
una función que devolverá objetos a la encuesta. Yo lo llamo en una
bala de retorno de Paul. Además, tiene un
parámetro, bala láser. Aquí, necesitamos
desactivar la bala. Ahora, pega estas
funciones al polo. A continuación, tenemos que decirle a
balas para usar esta encuesta. Así que ve al guión de
balas láser. Ahora, no destruimos balas, así podemos comentar destruir. Aquí. También necesitamos el espacio de nombres del polo. Crea una variable polar
de balas láser. Yo lo llamo polo de referencia. Necesitamos conectar esta variable de
pool con la instancia pole que creamos en el guión de
tiro del jugador. Para crear una función de sondeo de conjunto de
vacíos públicos que tomará como un
conjunto de parámetros de balas láser. Después establece una piscina de referencia para
juntar el guión de tiro del jugador. Cuando creamos una bala láser, usemos bala que decía Paul y paga la piscina
de este guión. Ahora, cada bala tiene una
referencia a la encuesta. Veamos cómo disparamos y sacamos
las balas de la encuesta. No necesitamos instanciar. Aquí solo usamos tirar de esa puerta. Esto llamará a la función encendida. Toma una bala de la piscina, lo que activará la bala. Ahora tenemos que establecer la posición de
tiro. Sólo podemos decir que transformar,
esa posición equivale a dos posiciones básicas de punto de
tiro. Entonces activamos la bala y colocamos en la posición
deseada. Por ahora, hagamos
caso omiso de otros casos. Volvamos al guión de las balas
láser. Ahora necesitamos implementar
la activación de balas y
devolverlas al poste. En lugar de destruir, usa polo de
referencia que suelte. Y queremos
liberar este objeto. Esto llamará a una bala de
retorno de la piscina, que desactivará
la bala. Por supuesto, tenemos que
repetir esto en la propia función se convirtió en
invisible. Aquí hay que tener cuidado
porque no queremos llamar a la función o al objeto que ya ha sido liberado. ejemplo, cuando la bala es
la activada, aquí, se vuelve invisible y volvemos
a llamar a un release. Aquí. Esto nos dará un error. Para evitar esto. Primero, comprobemos que
la bala está activa. Ahora, cuando lo desactivemos aquí, esto no se llamará. Pero cuando la bala sale de la pantalla, sigue activa. Después lo activan. Entonces todo debería
funcionar. Vamos a intentarlo. Se. Solo se asegura de tener asignado
el
prefabricado de bala láser. Como pueden ver,
podemos gastar balas, pero hay un problema. Cuando creamos balas
por primera vez. Tienen velocidad, pero cuando
reutilizamos esas balas, no
se mueven. Vamos a arreglarlo. Ir al guión de balas láser. Reemplace, comience con ONE enable. Esto se llama cada vez
que habilitamos la bala, probémosla ahora. Como puede ver, reutilizamos las
mismas balas y se mueven. Si todas las
viñetas creadas están activas, crearán una nueva. Bonito. Agreguemos más
funciones para la encuesta. También podemos definir una función a la
que se llamará cuando
necesitemos destruir una bala
del poste y eso pueda suceder. Te mostraré un
ejemplo en un momento. Crear objeto onDestroy Paul que toma el parámetro de
balas láser. Aquí. Destruyamos el objeto de juego de
balas. Pega esa función al poste. Entonces podemos elegir true o false para la variable de
comprobación de colección. Si se establece en true, el pool comprobará las llamadas de
doble lanzamiento
que mencioné. Déjame mostrarte. Podemos comentar esta línea
de código y probarla. Esperamos que aparezcan errores
debido a las llamadas de doble lanzamiento. Juega un poco el juego y
podrás ver el error. Tratando de liberar un objeto que ya
ha sido
liberado al poste. Por eso tenemos
esta condición. Más tarde descubrí que si una bala golpea a más
enemigos al mismo tiempo, entonces esta versión
también puede causar errores. Así juega lo mismo
if declaración aquí. Lo haré más tarde. Entonces podemos elegir la capacidad predeterminada y el tamaño
máximo de la encuesta. Vamos con diez como
defecto y 30 como máximo. El valor predeterminado determina cuánta memoria
queremos reservar. Reserva memoria para diez
objetos desde el poste. Y el máximo que
podemos reservar es de 30. Es importante
entender que si
usamos los tres objetos
y necesitamos uno más, ese objeto se creará
con esta función. Pero cuando
lo devolvamos a la alberca, se destruirá
con esta función. Para que puedas tener más objetos
que tu valor máximo, pero serán destruidos. Necesitas encontrar el saldo
adecuado para valor
predeterminado y máximo para tu juego. Ahora, terminemos
la función corta. Reemplazar instanciar
con Paul que se utilizan las mismas posiciones que para el Canaán Instanciar y
escribir posiciones de cañón. Aceleraré este proceso
hasta el último caso. El último caso, necesitamos un enfoque diferente para que la lista
instancie funciones. Ya que también necesitamos
cambiar la rotación. Vamos a guardar la instancia en una variable cuando la
obtengamos del polo. Entonces estableceremos la posición. Y luego rotación. Después de que
cambiamos una rotación, necesitamos establecer la velocidad
y dirección de una bala. Así que ve al guión de
balas láser. Aquí, creamos un conjunto público, dirección y velocidad de
la función. Repita el código desde la
propia función enable. Para las balas láser
que tienen algún tipo de rotación en Enable se
llamará, pero se llama antes
de establecer la rotación. Entonces necesitamos llamar a esta función después de que se establezca la rotación. Aquí, usamos una bala que
establece la dirección y la velocidad. Para repetir el proceso para
la segunda rotación, 0.1. Lo último, tenemos que restablecer
la rotación de balas. Usar al deshabilitar. Aquí, solo establecemos una
rotación a cero. Antes de que terminemos, sólo
colocaré otra declaración if
que mencioné antes. Vamos a probarlo. A medida que juegas el juego, puedes ver que las balas
se vuelven activas e inactivas. No los destruimos, solo deshabilitamos y habilitamos. No tenemos errores. Todo funciona bien. Puedes usar este objeto tirando del método en otros
lugares de tu proyecto. ejemplo, si
gastas muchos meteoros, puedes ir a metros pounder y crear una encuesta para meteoros. Eso es todo por esta conferencia. Gracias por ver.
74. Construye Android para publicar: Hola a todos. Después de terminar el juego, es momento de publicarlo. El primer paso es
crear una compilación de Android que podamos subir a
Google Play Store. Empecemos. Vaya a Archivo, Configuración de compilación. Asegúrate de usar la plataforma
Android. No olvides agregar las escenas que quieres
estar en el juego. Luego abre la configuración del reproductor. Aquí puede establecer el nombre de
su empresa. El nombre del producto será
el título de tu juego. Cambiémoslo al espacio. Curso más corto. Podemos ignorar la
versión por ahora. Aquí es necesario
agregar un icono por defecto. Si vas a iconos, puedes ver niveles específicos de API y anulaciones para el icono. Amplía uno de ellos y
verás los tamaños para tu icono. Pasemos a resolución
y presentación. Aquí, puedes elegir la
orientación para tu juego. En este juego, necesitamos retrato. Después ve a splash image. Aquí puedes agregar tu logo. Cuando empiece el juego. Simplemente haz clic en el
botón más y agrega el sprite. Rápidamente
te mostraré cómo se ve esto. Bonito. Hay muchas opciones. Puedes cambiar el color de
fondo, puedes cambiar la duración. Además, puedes mostrar logotipos
uno por uno y así sucesivamente. Así se ve
uno por uno logo. A continuación, vaya a otros ajustes. Aquí tenemos muchas opciones
importantes. Desplácese hacia abajo y encuentre la subsección de
identificación. Primero, necesitábamos
asegurarnos de que
tenemos el formato de nombre de
paquete correcto. Por lo general va así. Com dot el nombre de tu empresa, ese nombre de tu
juego. Es correcto. Puedes ver solo una advertencia de que se
han eliminado personajes
no válidos, que son espacios
en el nombre del juego. También puede anular nombre de
su paquete predeterminado si lo desea. Lo dejaré así. Entonces tenemos versión. Si se completa el juego, usa 1.0 o si es la versión beta, entonces puedes usar
punto cero. Algún número. La versión del paquete debe ser una. Ahora, esto es importante
cuando planeas actualizar tu juego. Es necesario cambiar
la versión, por ejemplo, a 1.1 o algo así. Solo tiene que ser
diferente a la anterior. Y también necesitas aumentar la versión
bundle en una. Si no cambias números, no
podrás publicar
una actualización en Google Play. Téngalo en mente. Después eliges el nivel
mínimo de API que tu juego soportará. Dejaré la API
mínima tal como está. Entonces tienes la opción de nivel
API objetivo. El Google Play tiene un nivel
mínimo de API objetivo. Cambia con el tiempo. Puedes consultarlo
en línea, solo buscarlo en google. El punto de crear
esta conferencia, esto es lo que dice Google. El mejor enfoque es elegir la
API de más alto nivel que puedas. El siguiente requisito
para Google Play es que las aplicaciones necesitan tener arquitectura de destino
ARM 64. Como puede ver,
podemos habilitarlo. Así que cambia el backend de scripting, y ahora está habilitado. Entonces vayamos a Configuración de
publicación. Necesitamos crear un KeyStore. Y clave. La clave es algún tipo de
certificado de que eres el
dueño de la aplicación. Haga clic en Key Store Manager, luego KeyStore, Crear nuevo. Y voy a elegir en cualquier lugar, elegir un nombre para la estrella K. Ahora agregamos una nueva clave, creamos una contraseña,
luego elegimos alias. Es algún tipo de
identificación para la k. Entonces puedes usar la misma
contraseña. Haga clic en Agregar. Kay. Genial. Volvamos a Build Settings. Tenemos que comprobar construido
un paquete, Google Play. Ahora hacemos clic en Construir, elige tu ubicación
y nombre de archivo. Esto llevará algún tiempo, sobre todo si
lo estás haciendo por primera vez. Cuando termine la compilación, tendrá un archivo AAB. Lo usamos para publicar el juego Google Play que se trata
en las próximas conferencias. Entonces nos vemos ahí.
75. Política de privacidad: Hola a todos. Antes de llegar a la conferencia
editorial, vamos a crear una
política de privacidad para nuestro juego. Si planeas tener
anuncios en tu juego o tu grupo de público objetivo
es niños menores de 13 años, Google Play requiere
que tengas una política de privacidad. Hay muchos sitios generadores de
políticas. Te voy a mostrar un ejemplo. El enlace estará
en los recursos. Primero, pondrás el
nombre de tu solicitud. Entonces tu correo electrónico es información de
contacto. A continuación, puedes poner
la información que
recopilas para nuestro juego directamente. No estamos cobrando nada, sino que estamos cobrando servicios de
terceros, lo cual resolvemos en la siguiente
sección de este generador. Entonces voy a dejar esto vacío. Elija su tipo de aplicación y,
a continuación, elija su plataforma de
destino. Este juego es para Android. Entonces eliges si eres un particular o una empresa, e ingresa tu nombre
o nombre de compañía. Haga clic en el botón Siguiente aquí. Deberías ver la lista
de servicios de terceros. Si usas algunos de ellos, solo marca las casillas. Usamos Unity. Haga clic en Siguiente. Ahora deberías ver los
términos y condiciones
y el generador de
documentos de política de privacidad. Necesitamos la política de privacidad. Entonces este es el texto
de nuestra política. Tenga en cuenta que se incluye un enlace a sus servicios de terceros y su póliza. Tenemos que publicar esta política. Entonces copiemos todo el texto. Búsqueda de Google Sites. Nuevamente, el enlace
estará en los recursos. Crear un nuevo espacio en blanco, citar. El título puede ser política de privacidad. El nombre del sitio puede ser el
nombre de su aplicación. Después pega el texto. Comprueba que todo está
aquí y haz clic en Publicar. Elija su dirección web y termine el proceso. Ahora, podemos ver esta página. Genial, tenemos una
política de privacidad para nuestro juego. Es una buena idea crear un botón en tu juego que abra este enlace y lleve a
un jugador a este sitio. Pero ese es otro tema. Nos vemos en la próxima conferencia.
76. Formularios de Google Play: Hola a todos. En esta conferencia, llenamos y pasamos por los foros de
Google Play. Este es un paso necesario
en el proceso de publicación. Entonces primero, debes ir a
la consola de Google Play. Se ve algo así. Ve a Play console. Necesitarás crear
una cuenta de desarrollador. Cuesta 25 dólares y es
un pago único. Después de crear su cuenta, se
le dirigirá
a esta página. Haga clic en Crear aplicación. Después ingresa el nombre de tu aplicación y elige
el idioma predeterminado. Tenemos que seleccionar juego. ¿Es gratis o de pago? Es gratis. Después acepta los términos
y haz clic en Crear. Serás redirigido
al panel de control. Aquí tienes tres secciones
principales, degustación, configuración y lanzamiento. Primero, pasemos por
la sección de configuración. Pasaremos paso a paso
por esta lista de viñetas. Tenga en cuenta que
ingresaré información basada en el juego que
hicimos en el curso. Cada juego es específico, por lo que algunas opciones e información pueden ser
diferentes para tu juego. Empecemos con
la política de privacidad. Instrucciones. Digamos, debemos agregar una política de
privacidad si nuestro público objetivo
incluye a niños menores de 13 años, no
voy a apuntar al público. Pero al usar EDS, todavía
tenemos que hacer esto. Entonces en la conferencia anterior, hicimos una política de privacidad, copiamos el enlace a esa página. Luego haz clic en Guardar. Vuelva al tablero de instrumentos. Puedes notar la marca de verificación
verde cuando se complete el paso. Pasemos al siguiente acceso IP. Los usuarios no necesitan crear
una cuenta para jugar el juego. No tenemos ningún
modelo de suscripción o algo así. Así que elige que toda
la funcionalidad esté disponible sin ninguna restricción de
acceso. Guárdalo y
vuelve al tablero. A continuación se encuentra la sección EDS. Sí, nuestra app contiene Edi's. Algunas de estas formas son realmente cortas y otras son un poco más largas. Lo más complicado es la seguridad de los datos. Así que no te pierdas eso. Vamos a la clasificación de contenido. Esta es una tarea un poco más larga. Además, ingresa tu correo electrónico
y elige una categoría. Después haga clic en Siguiente. Ahora, tenemos que responder
algunas preguntas. Esto es específico para
cada juego de nuestro juego. Si no tenemos
violencia ni sangre. No hay factor de miedo. Ahora bien, la sexualidad y el juego, básicamente, todas estas
respuestas serían no. Haga clic en Siguiente. Y presentar. Ir a Público objetivo. Elige grupos de edad. Solo tenga en cuenta que para este juego, podríamos incluir
niños menores de 13 años, pero luego asegúrese de que en
la unidad que es sección, elija la opción correcta. A continuación, vamos a que este juego sea
atractivo para niños menores de 13 años. Digamos que no, eso es un poco
cuestionable, pero bien. Google lo revisará
y podrás cambiar tu respuesta a continuación y guardarla. Esta no es una app de noticias. Entonces COVID-19, no
tenemos nada con eso. Ahora vamos a Seguridad de Datos. Sí, recopilamos y compartimos datos a través
de servicios de terceros. Estos datos están encriptados. Sí, los usuarios pueden
solicitar su eliminación. Toda ayuda para la inmunidad tiene este icono en una de las esquinas. Si los usuarios hacen clic en él, pueden solicitar a
UNITAID que elimine datos y algunas otras opciones. A continuación, aquí necesitamos seleccionar
todos los datos que se recopilan. ¿Cómo sabemos que si
usas la unidad las ayudas, entonces podemos echar un
vistazo a la documentación de Unity Esta es la sección de seguridad de
datos de Google Play para anuncios unitarios. Pondré el enlace
en los recursos. En esta página, puede ver qué tipos
de datos se recopilan. Por ejemplo, echemos un vistazo a
esta sección de ubicación. Recopilamos ubicaciones aproximadas y no recolectamos ubicaciones
precisas. De vuelta en Google Play Console. Seleccione la ubicación aproximada. A continuación se encuentra la sección de
información personal. Ir a la documentación de Unity. Mira la tabla de
datos personales. Los únicos datos que
se recopilan son los identificadores personales del usuario. Así que selecciona los ID de los usuarios. Ahora solo sigue las tablas de la documentación de Unity y
lograrás seleccionar las opciones
correctas. Tenga en cuenta que si utiliza algunos
otros servicios de terceros, debe encontrar
tablas y datos similares en sus sitios. Para que puedas
rellenar correctamente este formulario. Después de terminar
esto, haga clic en Siguiente. Ahora estamos en la sección de
uso de datos en manejo. Por cada opción que la
seleccionemos, necesitamos brindar
más información. Por Ejemplo, comencemos con la ubicación. Otra vez. Miramos a la mesa. La ubicación es recolectada
y compartida. Esto no se
requiere recolección de datos y se puede ver el propósito de esa recopilación de
datos. Así que marca ambas casillas. Esto es ahora y esto es sí. Después marque propósitos y seleccione las casillas que
coincidan con la tabla. Guárdalo. Puedes continuar con otros datos, ir a información personal, buscar la tabla y
repetir el proceso. Después de terminar, haga clic
en Siguiente y envíe. Esta no es una app de gobierno. Las siguientes dos tareas son para presentar tu app
en Google Play. Ir a la primera. Esto es, nuevamente,
elige tu categoría. Nuestro juego iría en la categoría de
acción. Supongo. Aquí puedes agregar
etiquetas. Yo me lo saltaré. Después ingresa tus datos de contacto. También puedes agregar tu sitio web. Guárdalo. Abre la última tarea. Aquí tienes el nombre, descripciones
cortas y completas que aparecerán en
Google Play Store. Entonces necesitas
subir tu ícono. Este icono debe coincidir con el
icono que estableces en unidad. También necesitamos subir
la imagen de portada. Ten en cuenta que puedes ver las dimensiones correctas para
cada imagen en la parte inferior. Si tienes un
video de YouTube sobre el juego, puedes colocar el enlace aquí. Entonces necesitas colocar capturas de pantalla
o teléfonos y tabletas. Voy a acelerar esto, guardarlo, y ya
terminamos con los foros. En la próxima conferencia, aprenderemos a configurar pruebas
internas
para nuestro juego y ayudaremos a publicarlo realmente
en la tienda. Nos vemos ahí.
77. Prueba interna y publicación de Google Play: Hola a todos. En esta conferencia, aprenderemos a agregar
catadores para que puedan descargar el juego antes que otras personas
y por supuesto probarlo. Entonces aprenderemos
a publicar el juego. Bien, primero, ve a pruebas
internas. Seleccione el paso del catador. Vamos a crear una nueva lista de correo electrónico, un nombre para la lista. Entonces puedes agregar los
correos electrónicos de tus probadores. Puedes agregar el tuyo, por
supuesto. Guardar los cambios. Entonces goto lanzamientos. Crear una nueva versión. Aquí necesitamos subir
el archivo AAB que
creamos en la
conferencia anterior, arrástralo adentro. Esto llevará algún tiempo. Cuando esté terminado. Asegúrese de que el
nombre más antiguo tenga los números correctos. Puedes escribir algunas notas de lanzamiento y dar información
sobre esta versión. A continuación, haga clic en Siguiente. Notarás un error. Tenemos que completar
una declaración más. Si usa unidad el EDS, esto debería ser sí. Después selecciona estas tres
opciones y guárdala. Volver a las pruebas internas. No tenemos ningún error, por lo que podemos iniciar un despliegue
a pruebas internas. Nuevamente, vaya a catadores. Aquí abajo, debes
copiar el enlace. Este es el enlace que debes
enviar a tus probadores. Usando ese enlace, los probadores pueden descargar tu juego y probarlo. Para publicar el juego. Ir a producción. Abra la pestaña Países. Ir a Editar países. Aquí puedes seleccionar en qué países quieres
publicar tu juego. Seleccionemos todos ellos. Después, vaya a soltar la pestaña. Crear una nueva versión. Como ya
subimos el paquete de aplicaciones, no
necesitamos volver a hacerlo. Haga clic en Agregar de biblioteca. Elija el paquete que subimos
para pruebas internas. Asegúrese de que toda
la información sea correcta. Haga clic en Siguiente y, a continuación, inicie el
despliegue a producción. Confirma el despliegue aquí. No lo haré porque en realidad no
voy a
publicar este juego. Pero cuando presionas este
botón, ya está hecho. Entonces esperas unos días. Y si todo está bien, el juego se publicará
en Google Play Store. Si quieres publicar el
juego en una fecha específica, entonces ve a la publicación de resumen. Aquí. Encienda la publicación
gestionada. En este caso, una vez que Google
apruebe tu juego, no
se publicará
automáticamente. Tendrás que
publicarlo manualmente. Y eso es todo chicos. Ya sabes cómo publicar
un juego en Google Play. Copia creará juegos increíbles y que este curso te ayudó. Gracias por mirar
y que tengas un buen día.