‫Hola y bienvenido.
‫En esta lección, vamos a presentar algo nuevo en el árbol de comportamiento, los servicios.
‫Vamos a descubrir qué son los servicios, cómo nos ayudan con el comportamiento de ejecución persistente y cómo
‫podemos escribir los nuestros en C++.
‫Vamos a sumergirnos.
‫Ahora solo quedan algunas piezas de lógica en nuestro controlador de aire que no están en nuestro árbol de comportamiento.
‫Uno de ellos es establecer la ubicación de inicio.
‫Esto todavía lo quiero configurar aquí desde el controlador de aire.
‫Pero cosas como tic, ahora que me gustaría hacer desde dentro de un árbol de comportamiento.
‫¿Qué quiero hacer aquí?
‫como hago para llegar a.
‫Para agregar a nuestra ubicación de jugador.
‫Para actualizar la última ubicación conocida del jugador.
‫Podemos hacer ambas cosas con algo llamado servicio de planos.
‫Así que vayamos a nuestros planos y veamos qué está pasando.
‫Entonces, si voy a mi aliado y abro el árbol de comportamiento, lo hablo a la ventana principal, entonces necesito mostrarle
‫qué servicios hemos usado antes.
‫Y es esencialmente una forma de ejecutar algo en cada toma o cada cierto tiempo cuando una ruta en particular está
‫activa.
‫Entonces, si tuviera un servicio aquí sobre el comportamiento de Chase, entonces algún código podría ejecutarse todo el tiempo que el comportamiento de
‫Chase esté activo, ya sea que nos estemos moviendo, disparando, ponderando cualquiera de
‫estas cosas, siempre sería corriendo.
‫Pero si estamos dentro, investigar, no sería.
‫Este es exactamente el tipo de situación que buscamos para usar un servicio.
‫Ahora vamos a tener un servicio de ejemplo.
‫Una cosa que notamos cuando estamos jugando es que una vez que el aire entra dentro de
‫nuestro alcance y nos movemos, no gira para mirarnos y podemos arreglar eso con un servicio ya incorporado aquí.
‫Así que haga clic derecho en esta nota y vaya a agregar servicio y busque el servicio de enfoque predeterminado.
‫Puedes ver que es de otro color, es verde.
‫Y si seleccionamos ese servicio predeterminado, también va debajo de los nodos de secuencia en lugar de encima de ellos, que es
‫lo que hacen los decoradores.
‫Entonces, con el enfoque predeterminado seleccionado, puede elegir en qué desea enfocarse.
‫En este caso, queremos centrarnos en la ubicación del jugador.
‫Continúe y presione guardar, presione reproducir.
‫Y ahora, si echamos un vistazo y nos movemos, pueden ver que gira para seguirnos.
‫Cosas interesantes.
‫Ahora queremos poder implementar un servicio similar en C++ que actualice la ubicación de nuestro jugador
‫todo el tiempo y actualice la ubicación de nuestro último jugador conocido mientras estamos persiguiendo.
‫Vamos a hacerlo como dos servicios separados.
‫Y puede ver cómo eso también sirve automáticamente para hacer las cosas un poco más
‫eficientes que hacerlo en tecnología porque solo puede ejecutar la última ubicación de juego conocida cuando está en la parte correcta del árbol
‫de comportamiento.
‫Así que volvamos al navegador de contenido Sandbox.
‫Agregue una nueva clase de C++ nueva, vaya a mostrar todas las clases y busque cuáles son nuestras opciones aquí.
‫Estamos buscando un mejor servicio.
‫Y luego hay un par de opciones, como tuvimos con B. t Tarea.
‫Tenemos Blackboard Base, y en realidad vamos a querer Blackboard Base porque
‫queremos saber qué clave debemos actualizar.
‫Por ejemplo, ¿debería ser la ubicación del jugador?
‫¿Debería ser la última ubicación conocida del jugador?
‫Así que vamos a ir y presionar a continuación en este con Blackboard Base, seleccionarlo
‫y vamos a llamar a este servicio beta, subrayar la ubicación del jugador así e ir a cómo crear esa clase.
‫Entonces, una vez que hayamos terminado de compilar, vamos a pasar al código de Visual Studio y pueden ver que
‫tenemos esta ubicación del reproductor de servicio BT que se hereda del Tribunal base de Service Blackwood.
‫Eso es lo que queremos ahora.
‫¿Qué funcionalidad vamos a mover en esto?
‫Bueno, voy a tratar de mover la funcionalidad más simple posible, que es simplemente establecer el valor
‫de la última ubicación conocida del jugador.
‫Aunque esta tecla se configurará en el árbol de comportamiento, no aquí en un texto sin formato, obtendrá la
‫ubicación del jugador y la configurará como una tecla de pizarra.
‫Y no va a hacer ninguna de las razones de verificación de la línea de visión, ya que si lo estamos ejecutando en
‫nuestro árbol de comportamiento, solo cuando estamos persiguiendo eso, no necesitamos la verificación de la línea de visión.
‫Podemos ver el jugador que es automáticamente sabemos que ese es el caso.
‫Así que hay otra simplificación para hacerlo en un servicio.
‫Entonces, esto debería ser bastante sencillo si sabemos cómo obtener una llamada de método aquí en el servicio BT.
‫Así que vamos a echar un vistazo a BT Service Dot para ver qué hay disponible allí.
‫¿Cuál es la documentación, qué podemos hacer?
‫Los métodos principales que puede ver aquí se vuelven relevantes en el nodo de marca relevante de C y en el inicio de la
‫búsqueda.
‫Al iniciar la búsqueda.
‫No nos interesa especialmente pero toma nota.
‫Sí, ahí es donde vamos a recibir actualizaciones todo el tiempo que este servicio esté en una ruta activa.
‫Así que ese es uno que vamos a querer implementar.
‫Vamos y buscamos en este archivo para encontrar la firma completa.
‫Aquí podemos ver es aquí.
‫Vamos a ver en qué sección está.
‫Está bajo la sección protegida.
‫Así que vamos a superar el servicio que hemos creado y crearemos una sección protegida.
‫Y péguelo, es automáticamente una anulación aquí porque BT Service lo estaba heredando de una clase principal, pero
‫no hay daño en anularlo nuevamente nosotros mismos.
‫Podemos hacer un cambio de control P para crear la implementación y luego queremos llamar a super.
‫Así que queremos un nodo supertick y queremos pasar nuestra propia compilación y nuestra memoria de nodo.
‫Y veamos, hay algunas otras cosas aquí.
‫También tenemos un segundo Delta.
‫Eso es lo que tenemos que dejar pasar también.
‫Y finalmente terminar con este punto y coma debería desaparecer la implementación del nodo de marca.
‫Ahora aquí básicamente queremos hacer ese comportamiento desde el controlador de aire.
‫CP, en el que obtenemos el componente de pizarra y luego establecemos un valor como vector.
‫Bueno, sabemos cómo obtener componentes de pizarra de las referencias de componentes del propietario.
‫Eso es bastante sencillo.
‫Solo vamos a hacer el punto de compensación del propietario y luego vamos a obtener los componentes de la pizarra
‫recordando que necesitamos incluir el hash aquí para el componente de pizarra con barra inclinada del árbol de comportamiento.
‫Entonces podemos usar nuestro operador de flecha.
‫Y lo que deberíamos poder hacer aquí es simplemente establecer el valor como vector y que necesitamos una clave.
‫Bueno, sabemos cómo lidiar con esto, pero refresquemos nuestra memoria.
‫Si vamos a nuestro servicio de BT subrayado Blackboard Base, puede ver lo mismo que con la tarea,
‫tenemos la tecla de pizarra seleccionada.
‫Eso es lo que vamos a usar.
‫Obtener clave de Blackboard seleccionada obtiene la clave que se seleccionó en el árbol de comportamiento.
‫Y luego queremos nuestro valor de vector donde vamos a obtener ese pozo exactamente igual que el controlador de aire.
‫Vamos a obtener el grupo de jugadores.
‫Y antes que nada, aquí arriba en la parte superior, debemos verificar si esto es nulo o no.
‫Y también necesitamos incluir ese juego estático.
‫Así que asegurémonos de tener el juego.
‫La estática incluye desde el controlador aéreo, mantenga incluido en nuestro reproductor una ubicación de servicio del reproductor.
‫Entonces vamos a hacer y si el jugador -- es igual a un puntero nulo, entonces vamos a querer hacer
‫es regresar antes de tiempo aquí regresa nulo para que podamos hacer un retorno temprano rápido.
‫Entonces podemos usar nuestro reproductor -- aquí para simplemente obtener la ubicación del actor y es posible que necesitemos hacer una inclusión aquí.
‫Veremos cómo nos va.
‫Bueno, no está de más estar seguro, ¿verdad?, y ser explícito sobre estas cosas.
‫Así que vamos a hacer una inclusión para el marco del juego y luego una barra inclinada va a ser: punto H para
‫que podamos asegurarnos de que tenemos todo en orden aquí y luego simplemente establecemos el valor como volver a eso
‫debería ser todo lo que necesitamos.
‫Vamos a compilar y ver si esto funciona.
‫De hecho, una cosa más.
‫Probablemente queramos un nombre bonito y bonito, así que deberíamos tener un constructor aquí.
‫Así que voy a crear una sección pública con el constructor, que será el nombre de la
‫clase, y luego continuaremos y crearemos esa implementación.
‫Voy a llevar mi implementación por encima de la implementación para el nodo de marca
‫y luego vamos a establecer el nombre del nodo igual a él, debería actualizar la ubicación del reproductor y vamos a construir y ver si eso
‫funciona.
‫Parece que me falta un punto y coma.
‫Intentémoslo de nuevo.
‫Una vez que se haya compilado con éxito, podemos pasar a nuestro enemigo y, además del enfoque
‫de configuración, quiero agregar un nuevo servicio que aparece aquí como la ubicación del jugador donde el nombre
‫bonito aparece básicamente como ubicación de actualización. .
‫Puedes ver que quiere decirte la frecuencia de marcar cada punto por 2. 6 segundos
‫Eso es mejor que usar tick porque sabemos que tick ejecuta cada cuadro aquí.
‫Esto se ejecuta con menos frecuencia, lo cual es bueno.
‫Y podemos ir a los detalles y crear una clave de pizarra, desplegar y seleccionar que queremos actualizar
‫no solo como la ubicación de juego sino también como la última ubicación conocida del jugador, porque eso sucederá en
‫cada cuadro mientras estemos persiguiendo y eso es el comportamiento que queremos.
‫Entonces, un nodo de servicio más que queremos seguir adelante y crear va a hacer el comportamiento de los controladores.
‫Bajaremos a tomar y ver lo que queda.
‫Lo que hacemos aquí es actualizar la ubicación del jugador dependiendo de si tenemos línea de visión.
‫Así que queremos que actualice la ubicación de juego.
‫Si tenemos líneas como borrar la ubicación si no las tenemos.
‫Así que va a ser un nuevo servicio.
‫Observe que es un comportamiento ligeramente diferente.
‫Vamos a agregar una nueva, nueva clase de C++.
‫Vamos a ir a mostrar todas las clases.
‫Y nuevamente, vamos a ser el servicio subrayado Blackboard Base como nuestra clase base
‫y lo llamaremos B. t Servicio de subrayado.
‫Ubicación del jugador si se ve.
‫Y sigue adelante y crea esa clase.
‫Y debido a que esto es todo lo que en su mayoría ha visto antes, su desafío será implementar
‫este servicio.
‫Así que vas a implementar el nodo tic usando el código en el controlador de aire.
‫Como guía, necesitará obtener el puntero del controlador aéreo desde el servicio BT.
‫Ahora, esto es exactamente lo mismo que hicimos en las tareas de ritmo, así que utilícelo como guía para
‫obtener ese puntero del controlador.
‫Necesitará el puntero del controlador de aire para verificar la línea de visión.
‫Recuerde, la línea de visión es un método en el controlador de aire y luego debe actualizar o
‫borrar la clave según su verificación de línea de visión y luego colocar este nodo en el árbol de comportamiento.
‫¿Dónde cree que estará el nivel correcto del árbol de comportamiento para que se ejecute este servicio?
‫Piense un poco en eso y rasque un poco la barbilla, haga una pausa, grabe un video y pruébelo.
‫Bueno.
‫Bienvenido de nuevo.
‫Entonces, esto ha abierto un nuevo servicio de remolacha en el código de Visual Studio.
‫Ahora será prácticamente idéntico en el encabezado.
‫Así que voy a continuar y copiar eso en un encabezado recién generado.
‫La excepción es que necesitamos cambiar el nombre del constructor para que coincida.
‫Ahora vamos a crear una implementación para el constructor y le daremos un nombre de nodo para actualizar la ubicación
‫del jugador si se ve.
‫Y agrega un punto y coma.
‫El final aquí.
‫No olvidemos que esta vez.
‫Luego de vuelta a C++.
‫Voy a implementar el nodo tick también.
‫Y solo voy a copiar si podemos encontrar la ubicación del jugador CP. Y solo voy a copiar la
‫llamada a super y la obtención del peón del jugador y la verificación de la devolución nula.
‫De hecho, voy a copiar todo el cuerpo y lo modificaremos desde allí.
‫Entonces copiamos eso y también vamos a copiar el acceso al componente de pizarra con la inclusión para
‫el componente de pizarra, las estadísticas del juego y el peón, porque necesitamos acceso a todos
‫ellos.
‫De hecho, gran parte de la funcionalidad se comparte aquí.
‫Podría pensar en hacer que de alguna manera compartan este código, pero creo que no hay tanta duplicación como para que
‫nos importe lo suficiente.
‫Entonces, lo que vamos a tener que hacer aquí también es verificar que tengamos un controlador de aire.
‫Así que voy a hacer un si la composición del propietario de los componentes del propietario no obtiene un puntero de propietario igual a nulo, entonces vamos
‫a querer continuar y regresar en esta etapa.
‫Luego, lo siguiente que vamos a querer hacer es verificar nuestra visibilidad.
‫Así que vamos a hacer un si el punto de compensación del propietario obtiene el propietario del aire y luego vamos a hacer una
‫flecha aquí y necesitamos incluir un controlador aquí.
‫Así que va a incluir hash.
‫Y va a ser yo el controlador.
‫Entonces, queremos hacer una línea y ver cuál es el uso correcto aquí si pasamos al controlador de aire.
‫CP Su línea de visión dos es lo que queremos, así que la línea de visión entonces necesitamos hacer la línea de visión de la
‫obra.
‫Un peón en este caso.
‫¿Tenemos línea de visión al peón del jugador?
‫¿Es eso lo que estamos haciendo en el CPA?
‫Vamos a comprobarlo dos veces.
‫Sí somos.
‫Entonces vamos a querer seguir adelante y establecer los valores de manera diferente.
‫Así que estamos configurando el valor del vector para la ubicación del actor de captura del peón del jugador.
‫Sí, eso es si tenemos otra línea de visión.
‫Si no tenemos línea de visión, sabemos que necesitamos estar despejando ese valor.
‫Así que seguiremos obteniendo el componente propietario, obtener el componente de pizarra.
‫Entonces va a ser un valor claro y todavía vamos a estar borrando el valor de la
‫tecla de pizarra seleccionada, y eso debería cubrirnos en gran medida para la implementación de la ubicación del jugador.
‫Si se ve, vamos a compilar y ver si funciona bien.
‫La compilación tuvo éxito.
‫Vayamos al árbol de comportamiento.
‫Ahora, el nivel que quiero que se ejecute está básicamente en el nivel superior en el selector inicial, porque quiero
‫que actualice la ubicación del jugador básicamente todo el tiempo porque necesitamos poder abortar cualquiera de estos otros
‫comportamientos según el jugador. ubicación que se está configurando.
‫Por lo tanto, debemos poder configurarlo y desarmarlo en cualquier momento.
‫Así que voy a ir y hacer clic con el botón derecho en el selector de nivel superior y el servicio en la ubicación de reproducción si se ve.
‫Y luego vamos a seleccionar ese nodo de servicio y seleccionar su tecla de pizarra, que será
‫nuestra ubicación de juego.
‫Entonces, uno establecido en la ubicación de reproducción, la ubicación actualizada del jugador, el más tonto es actualizar
‫la última ubicación conocida del jugador.
‫Y ahora deberíamos poder pasar a nuestro controlador aéreo y esencialmente eliminar todo este código en tecnología
‫porque en su lugar ha sido reemplazado por nuestros servicios.
‫Y podemos seguir adelante y compilar y ver si eso funciona.
‫Vayamos al editor y juguemos y veamos si todavía tenemos a nuestro enemigo acercándose a nosotros.
‫Viene corriendo hacia nosotros, pierde la vista, luego vuelve hacia nosotros y comienza a disparar.
‫Sí.
‫Básicamente, todo funciona como antes, excepto que ahora lo hace completamente a través de servicios
‫que escribimos para nosotros en C++.
‫En la próxima lección, corregiremos ese molesto error en el que la IA continúa
‫disparando y eventualmente logra suicidarse.
‫Veré eso.