‫Oye, bienvenido de nuevo.
‫En este video, nos preocupamos por las condiciones de ganar y perder.
‫Esta es una de las últimas cosas que vamos a manejar en este proyecto de juego.
‫Ahora echemos un vistazo a nuestro plano de sección.
‫Ahora, ya hemos marcado los primeros cinco elementos de nuestro plan de secciones, y los dos últimos son los
‫efectos especiales y las condiciones para ganar y perder.
‫Y me gustaría cambiar estos dos últimos y manejar las condiciones de ganar y perder solo
‫porque esta es la última de nuestra lógica de programación de juego y los efectos especiales son cosméticos y más como
‫toques finales para que podamos manejarlos al final.
‫Entonces, en este video, vamos a crear una función de finalización del juego para que sepamos cuándo se ganó
‫o se perdió el juego.
‫Y para ganar el juego, necesitaremos contar la cantidad de torres en el mundo, porque una vez
‫que hayamos destruido todas las torres, sabremos que hemos ganado el juego.
‫Y si el tanque en sí se destruye, entonces podemos considerar que esa es la condición de pérdida.
‫Así que estoy de regreso aquí en el modo de juego y lo primero que me gustaría hacer es crear otro evento implementable
‫de plano.
‫Tenemos esta función de inicio de juego, a la que podemos llamar desde C++, pero estamos implementando su lógica en el modo de
‫juego.
‫Blueprint Gracias a Blueprint Implementable Event, me gustaría crear otro de estos por perder el
‫juego.
‫Así que voy a crear una función nula llamada Game Over.
‫Y para este, me gustaría tomar un parámetro de entrada booleano llamado B one game.
‫Y, por supuesto, este será un evento implementable de blueprint porque lo único que me gustaría
‫manejar con esta función es mostrar que hemos perdido o ganado el juego y que podemos hacer a partir de blueprints.
‫Así que tenemos una función de fin de juego.
‫Ahora necesitamos saber cuándo debemos llamar a esta función.
‫Bueno, antes que nada, sabemos que podemos llamar a esta función cuando hemos perdido el juego, y
‫eso será si el tanque ha muerto.
‫Entonces, vayamos a nuestra función de actor muerto aquí en el modo de juego CP de tune tanks. Y vemos que si el
‫actor muerto es el tanque, entonces estamos manejando la destrucción del tanque y configurando el estado habilitado
‫en falso.
‫Otra cosa que podemos hacer aquí es finalizar el juego simplemente llamando a game over y este booleano es un juego que podemos
‫pasar como falso para esto.
‫Entonces eso se encarga de perder el juego, al menos desde el lado de C++.
‫Ahora necesitamos saber cuándo debemos ganar el juego.
‫Ahora aquí murió un actor.
‫Si el actor muerto puede ser arrojado a una torre, sabemos que acabamos de destruir una torre.
‫Ahora, este sería el lugar perfecto para actualizar un conteo de torres o una variable de tipo entero que lleve
‫un registro de cuántas torres hay actualmente en el mundo.
‫Ahora.
‫Para hacer eso, necesitamos una variable para realizar un seguimiento de la cantidad de torres, de modo que podamos
‫agregar una variable privada aquí en el archivo H.
‫Y me gustaría hacer eso aquí abajo.
‫Así que voy a crear un INT 32 y lo llamaré torres de destino.
‫Ahora podemos inicializar esto de inmediato a un valor de cero, pero debemos actualizarlo a medida que disminuye
‫la cantidad de torres.
‫Y también tenemos que ajustar esto al número de torres que hay en el mundo.
‫Ahora podríamos codificar esto a cuatro, pero ¿qué sucede cuando comenzamos a agregar más torres a nuestros niveles?
‫Bueno, entonces se vuelve un poco más complicado.
‫Entonces, lo que me gustaría hacer en cambio es ver cuántas torres hay en el mundo.
‫Ahora, podría crear una función para esto que devuelva 32 y esta función puede averiguar cuántas torres hay en
‫el mundo y devolver el número.
‫Así que voy a llamar a esta función, obtener un conteo de torre objetivo.
‫Así que sigamos adelante y demos cuerpo a esta función en el archivo CP.
‫Voy a ir hasta el final y crear el cuerpo de la función y no puedo olvidar poner el nombre
‫de la clase antes del nombre de la función.
‫Ahora esto va a devolver un extremo 32 y tenemos que decidir cómo vamos a averiguar cuántas
‫torres hay.
‫Ahora hay una función que existe en las estadísticas del juego llamada Obtener todos los actores de clase.
‫Aquí está la documentación.
‫Dice Encuentra todos los actores en el mundo de la clase especificada.
‫Entonces necesitamos especificar una clase en particular.
‫Ahora esta función tiene tres entradas.
‫Primero es un objeto de contexto mundial.
‫Ese es fácil.
‫Sabemos cómo manejar eso.
‫Pero a continuación tenemos una subclase PT de un actor y se llama Clase de actor.
‫Ahora hemos visto que las funciones que requieren una subclase PT pueden aceptar una clase u como entrada y el tercer
‫parámetro es una matriz T.
‫Requiere una matriz t de punteros de actor y esto se pasa como una referencia y no es una
‫referencia constante que parece sugerir que esta función podría cambiar este parámetro de entrada llamado acto.
‫Aquí hay otra pista de que este es el caso, es que llama a los actores.
‫Es un parámetro de salida, lo que significa que lo pasamos y luego, después de que se haya llamado a la función, tiene
‫valores que la función le ha asignado.
‫Entonces podemos pensar en ello como una especie de salida para la función.
‫Ahora dice aquí abajo para los parámetros, la clase de actor es la clase de actor a buscar que debe especificarse o la
‫matriz de resultados estará vacía.
‫Queremos encontrar todas las torres y los actores son una matriz de salida de actores de la clase especificada.
‫Entonces, una vez que hayamos llamado a esta función y la hayamos pasado en una matriz, cuando
‫la función haya terminado, esa matriz contendrá punteros a todos los actores en el mundo de la clase especificada.
‫Entonces sabemos que esta función requiere un objeto de contexto mundial.
‫Ahora, si vamos a llamar a esto desde el modo de juego, podemos pasar esto a continuación.
‫Necesitamos la subclase PT para especificar el actor A y sabemos que esto puede ser un nuevo puntero de clase.
‫Ahora necesitamos especificar la clase a buscar.
‫Si especificamos un actor, obtendremos una gran matriz llena de indicadores para cada actor en el mundo.
‫Pero no necesitamos a todos los actores.
‫Solo necesitamos las torres para poder usar una clase estática de torre que nos devolverá una nueva clase que representa
‫la clase A Tower C++.
‫Ahora el tercer parámetro es una matriz T de punteros de actor.
‫Entonces, si creamos una variable local de tipo matriz T especificando el puntero de un actor en los paréntesis angulares,
‫entonces podemos llamarlo estática del juego.
‫Haga que todos los actores de la clase pasen esas tres entradas, y el resultado de esta acción será que
‫nuestra matriz de torres debería contener punteros a todas las torres de nuestro mundo.
‫Ahora, la bandeja es una buena clase de contenedor que puede contener una cantidad de elementos siempre que todos compartan el
‫mismo tipo.
‫Y esta clase tiene una gran cantidad de funciones que podemos usar al almacenar artículos en una bandeja.
‫Ahora voy a desplazarme completamente hacia abajo y mostrarles esta función aquí llamada Num Short four number y dice
‫Devuelve el número de elementos en la matriz.
‫Entonces podemos usar esta función para obtener la cantidad de elementos en nuestra matriz una vez que tengamos todas las torres del
‫mundo.
‫Entonces, si llamamos al número de Tower, podemos usarlo como el valor de retorno para nuestra función.
‫Y como vimos, establecemos nuestro valor de retorno para esta función a la que llamamos obtener el recuento de la torre de destino como
‫un n 32, podemos devolver el número de elementos en la matriz de nuestra torre.
‫Así que me gustaría desafiarlo a que implemente esta función de obtención de recuento de torres objetivo.
‫Así que cree una matriz t local del actor tipo A.
‫Puedes llamarlo torres o lo que quieras.
‫Ahora use la función you game, play statics, obtenga todos los actores de la clase y asegúrese de pasar los
‫parámetros de entrada correctos.
‫Ahora, después de llamar a esta función, su bandeja contendrá punteros a todas las torres de nuestro
‫mundo, por lo que simplemente puede devolver el número de torres usando esa función num que pertenece a la
‫clase de bandeja.
‫Así que adelante, pausa el video e implementa.
‫Obtenga el recuento de torres objetivo ahora.
‫Bueno.
‫Así que aquí está el recuento de torres objetivo.
‫Ahora, lo primero que voy a hacer es crear una matriz t local especificando un puntero de actor como el tipo
‫de elemento que debe almacenar esta matriz.
‫Y voy a llamar a esto torres ahora, necesito llamarlo estática de juego, así que necesito asegurarme de que
‫ese encabezado esté incluido.
‫Ahora veo que lo es porque lo estamos usando en algunas de nuestras otras funciones, pero es bueno hacer esa
‫verificación.
‫A continuación, puedo usar sus estadísticas de juego y llamaré a todos los actores de la clase.
‫Ahora, la primera entrada es un objeto de contexto mundial que voy a pasar en esto y lo siguiente es la subclase de
‫representación de la clase de actor.
‫Y mencioné que podemos usar una clase estática de torre que devolverá una clase U que representa la clase
‫de torre.
‫Ahora, de nuevo, es una buena idea asegurarse de que estamos incluyendo torres, que es lo que estamos haciendo.
‫Ahora, el tercer y último parámetro va a ser la bandeja y podemos pasar en torres.
‫Entonces, una vez que se haya llamado a esta función, las torres ahora contendrán punteros a todas las torres del
‫mundo.
‫De hecho, si existen objetos de una clase que deriva de torres, también los obtendríamos.
‫Entonces, dado que tenemos una matriz de torres, simplemente podemos devolver la cantidad de elementos en esa matriz.
‫Así que voy a usar una declaración de retorno y usaré el número de puntos de las torres y ahora tenemos un recuento de torres de destino.
‫Así que esto es genial.
‫Podemos usar esto para inicializar nuestro conteo de torres, que llamamos torres objetivo y podemos hacerlo cuando comenzamos
‫el juego.
‫Así que voy a colocar eso aquí y manejar el inicio del juego.
‫De hecho, me gustaría que sea lo primero que hagamos.
‫Así que voy a tomar las torres de destino y establecerlas igual al valor de retorno de obtener el recuento de torres de destino.
‫Ahora las torres objetivo deben inicializarse con el número de torres en nuestro mundo.
‫Así que esto es genial, pero necesitamos actualizar este conteo cada vez que muere una torre, lo que significa
‫que debemos entrar en nuestra función de actor muerto.
‫Y aquí, si lanzamos un actor muerto a una torre destruida, luego de manejar la destrucción, debemos
‫actualizar nuestra variable de torres de destino para que podamos decir torres de destino y podamos usar el operador de decremento.
‫Podemos usar el operador de decremento posterior o el operador de predicamentos.
‫Ambos darán como resultado la misma acción que es tomar torres objetivo y restarle una.
‫Ahora, tan pronto como hayamos restado uno de las torres objetivo, ahora debemos verificar si las Torres objetivo
‫han llegado a cero.
‫Así que voy a colocar una verificación de si aquí para ver si las torres de destino han llegado a cero.
‫Ahora, tan pronto como lo haga, sabemos que el juego debe terminar, por lo que podemos llamar a la
‫función de fin del juego pasando en un juego 4b1 verdadero, ya que hemos destruido todas las torres y podemos considerar esto como una victoria.
‫Ahora sigamos adelante y compilemos nuestro código.
‫Ahora, de vuelta aquí en el editor, lo que me gustaría hacer antes de terminar este video es ir a nuestro modelo de
‫modo de juego.
‫Así que aquí está la melodía del pitido.
‫Gracias modo de juego y tenemos este juego de inicio de evento.
‫Y lo que estamos haciendo es crear nuestro widget de inicio de juego, agregándolo a la ventana gráfica para que podamos ver el
‫temporizador de cuenta regresiva de inicio de juego.
‫Entonces sabemos que se está llamando al inicio del juego, pero también necesitamos implementar nuestro evento implementable de juego sobre
‫plano.
‫Así que voy a hacer clic con el botón derecho y escribir game over y aquí está nuestro evento, game over y mira esto.
‫Observe que tenemos este juego y es un booleano.
‫Entonces, cuando llamamos a esta función desde C++, estamos pasando un valor booleano para B un juego.
‫El nodo de evento blueprint elimina esa B minúscula y coloca un espacio entre uno y el juego como una especie de
‫cortesía para nosotros.
‫Ahora vamos a crear algunos widgets para que podamos ver cuándo ganamos o perdimos el juego, pero eso lo
‫haremos en un video futuro.
‫Por ahora, solo quiero confirmar que esto se está llamando y llamando correctamente para poder hacerlo con un nodo de
‫cadena de impresión y podemos imprimir el valor en función de este valor booleano.
‫Si hago clic y arrastro este booleano directamente a la entrada de cadena, veremos que hay una conversión de
‫booleano a cadena.
‫Este es otro nodo de conversión conveniente que convertirá un valor booleano en una cadena para nosotros, y su funcionalidad
‫es tal que convertirá la palabra verdadero o falso en función del valor de verdad del valor
‫booleano.
‫Entonces, ¿por qué no probamos esto?
‫Voy a compilar y darle al play.
‫Muy bien, ahora estoy listo para tratar de ganar el juego.
‫Espero no perder antes de poder hacerlo.
‫Y perdí el juego y puedes ver falso impreso en la parte superior izquierda de la pantalla.
‫Entonces, ahora sabemos que perder el juego da como resultado que el evento game over sea llamado y se pase falso, debemos
‫asegurarnos de que se pase verdadero cuando ganemos el juego.
‫Así que tratemos de matar todas las torretas.
‫Así que realmente necesito tratar de no recibir un golpe.
‫Oh, ya me golpearon.
‫Esto es bastante desafiante.
‫Y ahí vamos.
‫Y verdadero está impreso en la parte superior izquierda de la pantalla.
‫Solo aparece durante unos segundos, por lo que es posible que te lo hayas perdido.
‫Ok genial.
‫Así que ahora tenemos condiciones para ganar y para perder.
‫El siguiente paso es mostrar esto en forma de un widget en la pantalla para que no dependamos del nodo
‫de cadena de impresión.
‫Entonces, en resumen, ahora tenemos condiciones para ganar y perder, y solo hay algunas cosas que
‫debemos hacer para pulir esto, como crear widgets que informen al jugador que ha ganado o perdido el juego.
‫También contamos el número de torres usando una bandeja y la función estática del juego.
‫Consigue todos los actores de la clase.
‫Gran trabajo.
‫Este juego realmente está avanzando.
‫En el próximo video, crearemos esos widgets y luego estaremos listos para comenzar a agregar efectos especiales
‫y pulir nuestro juego.
‫Te veré en el próximo video.