‫Hola y bienvenido de nuevo.
‫Ahora tenemos movimiento para --, pero no estamos girando la parte superior de --, que llamamos
‫torreta.
‫Así que nos gustaría poder hacer eso usando nuestro mouse.
‫Ahora, echa un vistazo a lo que está pasando aquí.
‫A medida que muevo el cursor del mouse por el mundo, obtengo esta esfera roja.
‫Esta es una esfera de depuración que estoy dibujando en el espacio 3D.
‫Ahora observe que mientras me muevo contra una pared, esa esfera se mueve contra la superficie de la pared.
‫Entonces, donde sea que se mueva el cursor de mi mouse, tengo este miedo que corresponde a cualquier objeto que
‫esté golpeando según la ubicación de mi cursor.
‫Y esto nos será útil para que podamos tener una ubicación en el espacio hacia la que podamos rotar
‫nuestra torreta.
‫Ahora, para hacer esto, hay algunas funciones que necesitamos en el controlador, por lo que debemos acceder a esas
‫funciones en el controlador.
‫Y en este video vamos a trabajar en configurar eso y también vamos a discutir cómo
‫esto va a involucrar un concepto conocido como casting.
‫Ahora, la razón por la que queremos el controlador es porque hay funciones en el controlador que nos permiten
‫obtener el resultado del éxito debajo del cursor.
‫Ahora estamos hablando del cursor del mouse.
‫Así que digamos que esta es nuestra pantalla y aquí está el cursor de nuestro mouse.
‫Y el punto en la punta del cursor corresponde a una ubicación en la pantalla.
‫Ahora, si movemos el cursor, nuestro objetivo es que la parte de la torreta de nuestro tanque, la
‫parte superior de nuestra malla, gire de modo que mire en la dirección de ese cursor.
‫Ahora, si movemos el cursor, hay una función en el controlador que podemos usar para obtener
‫la ubicación correspondiente a ese cursor.
‫Si tuviéramos que dibujar una línea recta desde la cámara hacia el cursor y golpear
‫algún objeto en el mundo, podemos obtener esa ubicación y usarla para establecer la rotación de la torreta del tanque.
‫Déjame mostrarte lo que quiero decir.
‫Ahora, para obtener esta ubicación de golpe correspondiente a nuestro cursor, necesitamos usar el controlador.
‫Ahora, hablemos del controlador por un breve momento.
‫Digamos que tenemos nuestro peón en el mundo.
‫Un peón tendrá un controlador.
‫Este es un objeto invisible que está asociado con el peón.
‫Ahora, para nuestro peón, nuestro controlador tendrá el controlador de jugador tipo A y al
‫comienzo del juego, el controlador poseerá el peón.
‫Es por esto que podemos ver desde el punto de vista de la cámara que pertenece a nuestro tanque de peones.
‫Ahora podemos acceder a este controlador.
‫Nuestra clase de tanque hereda una función llamada Obtener controlador.
‫Se hereda de la clase --.
‫Entonces, lo que nos gustaría hacer es obtener ese controlador y almacenarlo en una variable para que podamos usarlo para acceder
‫a la función que necesitamos para obtener el resultado de éxito debajo del cursor.
‫Así que preparémonos para eso.
‫Ahora estoy aquí en la clase de tanques y el lugar donde necesitamos acceder a nuestro controlador es comenzar a jugar.
‫Si lo hacemos en el constructor, es demasiado pronto y es posible que aún no tengamos un controlador válido.
‫Así que vamos a necesitar la función de inicio de juego aquí en la clase de tanque.
‫Ahora lo tenemos aquí en la clase base pong y hasta ahora no estamos usando realmente comenzar a jugar en la
‫clase base pong.
‫Entonces, lo que me gustaría hacer es moverlo a la clase de tanque.
‫Así que voy a resaltar el comienzo de la reproducción, incluido el comentario y la sección protegida aquí,
‫y simplemente lo cortaré.
‫Y luego, de vuelta en la etapa de tanque, voy a pegarlo.
‫Agreguemos esta sección protegida aquí justo encima de la sección privada con comenzar a jugar adentro.
‫Ahora hemos eliminado Begin Play del peón base.
‫Ya no lo tenemos aquí, pero también debemos eliminarlo de base pond cpp.
‫Aquí está.
‫Podemos continuar y eliminarlo aquí y ahora lo tenemos declarado aquí en el tanque H, pero también debemos
‫definirlo en el tanque CPP.
‫Así que voy a definir la función justo debajo del componente de entrada del reproductor de configuración.
‫Por lo tanto, será nulo comenzar a jugar sin parámetros de entrada.
‫Está el cuerpo de la función y también necesitamos un tanque que prefije el nombre de la función.
‫Ahora sabemos que es importante llamar súper grande en el juego.
‫Entonces, de esa manera, se seguirá llamando a cualquier funcionalidad en la función de inicio de reproducción y cualquiera de las
‫clases principales.
‫Así que aquí hemos comenzado a jugar.
‫Aquí es donde podemos obtener nuestro controlador y almacenarlo en una variable.
‫Así que volvamos al Tanque H y creemos una variable.
‫Ahora, esto será privado y lo pegaré aquí abajo en la parte inferior
‫de la sección privada y será un tipo de puntero de controlador de jugador y podemos llamar a este controlador de jugador ref.
‫Esta será nuestra referencia al controlador del jugador.
‫Ahora no estamos hablando de una referencia de C++.
‫Esto sigue siendo solo un puntero, pero lo usaremos para referirnos al controlador del reproductor.
‫Así que ahora tenemos una variable de referencia del controlador de jugador de tipo A controlador de jugador y estamos listos para
‫almacenar el controlador en este puntero.
‫Así que volvamos a Tank Dot CP aquí y comencemos a jugar e intentemos hacer esto.
‫Asi que.
‫Lo que voy a hacer es decir jugador, controlador, ref es igual y voy a intentar llamar a obtener controlador.
‫Ahora obtenga el controlador, como mencioné, está en la clase --.
‫Hagamos clic derecho y vayamos a la definición y observemos que esta función devuelve un controlador A.
‫Ahora nuestra variable es de tipo A jugador controlador, no un controlador.
‫Entonces, lo que intentamos hacer aquí es tomar el valor de retorno de get controller, que es un tipo de
‫puntero de controlador y estamos tratando de almacenarlo en un puntero de controlador de jugador A.
‫Observe que vemos el rojo ondulado aquí.
‫Dice un valor de tipo.
‫Un puntero de controlador no se puede asignar a una entidad de tipo.
‫Un controlador de jugador.
‫Estamos recibiendo un error.
‫Echemos un vistazo aquí a la documentación de un controlador.
‫Echar un vistazo.
‫Aquí hay un controlador.
‫Y dice herencia, jerarquía.
‫Y debajo de un controlador vemos un controlador y un controlador de jugador.
‫Esto significa que un controlador de jugador es una clase secundaria de un controlador.
‫Ahora, en C++, no podemos tener un puntero de tipo.
‫Un controlador de jugador almacena el valor de la dirección de un controlador A.
‫Un controlador es el tipo principal.
‫Un controlador de jugador es del tipo niño.
‫No puede tomar un objeto de tipo principal y almacenarlo en un puntero de tipo secundario.
‫Entonces, ¿cómo solucionamos esto?
‫Así que aquí está nuestro problema.
‫La función obtener controlador devuelve la dirección de un controlador A.
‫Ahora, esto es algo que podríamos almacenar en un puntero de controlador A, pero no podemos almacenarlo en un puntero de controlador
‫de jugador A.
‫Sin embargo, lo curioso es que el objeto devuelto por get controller es, de hecho, un controlador de jugador.
‫Así que tenemos esta dirección en forma de un puntero de controlador A y sabemos que almacena un controlador de jugador, pero
‫si la tenemos en forma de controlador A, no podemos acceder a la función que necesitamos porque
‫existe en un controlador de jugador. .
‫La función se llama get hit result under cursor.
‫Ahora bien, si tenemos un valor de puntero de controlador de tipo A e intentamos obtener esa función que
‫existe en un controlador de reproductor, no lo haremos.
‫Obtendremos un error de compilación.
‫Entonces, dado que sabemos que el objeto en sí es un controlador de jugador, solo se almacena en un puntero de controlador A.
‫¿Cómo solucionamos este problema?
‫La respuesta es que tenemos que lanzar.
‫Sabemos que un controlador es la clase principal y un controlador de jugador es la clase secundaria.
‫Y sabemos que no podemos tener un controlador A almacenado en un puntero de controlador de jugador A.
‫Sabemos que podemos ir al revés y tener una tienda de punteros de controlador A, un objeto de un controlador
‫de jugador.
‫De hecho, eso es lo que estamos viendo cuando llamamos a get controller, devuelve un puntero de controlador A que apunta
‫a un controlador de jugador A.
‫Entonces, si tenemos un valor de puntero de controlador de tipo A, podemos usar una función especial llamada conversión para convertir
‫el tipo de puntero en un puntero de controlador de jugador A.
‫Entonces, la conversión cambia el tipo de un puntero a otro tipo de puntero siempre que el objeto en sí sea del tipo al
‫que estamos tratando de convertir.
‫Ahora, si intentamos convertir a un tipo no válido, por ejemplo, tenemos un puntero de controlador A que apunta a un
‫objeto de controlador de jugador.
‫Si intentamos lanzar para decir, un personaje, la función de lanzamiento devuelve nulo y decimos que fallamos en el
‫lanzamiento.
‫Así que la función de conversión se ve así.
‫Es una plantilla como crear un subobjeto predeterminado.
‫Esta función de plantilla se adaptará al tipo elegido y en esta función, el tipo que pasamos es el tipo
‫que estamos emitiendo también.
‫Entonces pasamos ese tipo.
‫Nos gustaría lanzar dos dentro de los paréntesis angulares y pasamos el puntero que nos gustaría lanzar
‫entre paréntesis.
‫Aquí hay un ejemplo.
‫Digamos que nos gustaría lanzar a un controlador de jugador y un puntero del tipo de controlador tipo A.
‫Pasamos el puntero entre paréntesis y el tipo que estamos proyectando entre los corchetes angulares.
‫Y lo que se devuelve es un valor de puntero de controlador de jugador de tipo A.
‫Así que aquí está la llamada a la función donde estamos pasando el tipo entre paréntesis angulares y
‫el valor del puntero del controlador A que recibimos de get controller puede ir entre paréntesis.
‫Por lo tanto, debemos emitir este valor que nos devuelve el controlador de obtención.
‫Ese va a ser tu desafío.
‫Entonces, en Begin Play, use la función de obtener controlador y pase ese valor a la función de conversión y envíe a
‫un controlador de jugador.
‫Y luego puede almacenar el resultado en nuestro puntero de referencia del controlador de jugador, que es un puntero de controlador de jugador de
‫tipo A.
‫Pausa el video y realiza el elenco.
‫Bueno.
‫Así que casi tenemos todo el trabajo hecho aquí, solo tenemos que lanzar.
‫Entonces, lo que vamos a hacer es llamar a la función de conversión, que tiene corchetes angulares y paréntesis.
‫Y lo que va entre paréntesis es el valor que nos gustaría emitir.
‫Ahora get controller devuelve un puntero del controlador Tipo A.
‫Voy a mover eso aquí mismo entre paréntesis.
‫Y el tipo al que estamos lanzando es un controlador de jugador.
‫Así que de nuevo estamos tomando el valor devuelto por get controller.
‫Esto devuelve un puntero de controlador o una dirección.
‫Luego estamos usando cast para enviarlo a un controlador de jugador A.
‫Sabemos que el objeto devuelto por el controlador de puerta es un objeto de controlador de jugador A almacenado en un puntero
‫de controlador A.
‫Entonces, después de lanzar esto, lo que se devuelve es un puntero del controlador de jugador tipo A.
‫Así que estamos almacenando eso en el controlador del jugador ref.
‫Ahora que tenemos acceso al controlador en la forma de un puntero de controlador de jugador A, podemos acceder a
‫la función que necesitamos para obtener el resultado de rastreo bajo el cursor.
‫Entonces, en resumen, usamos get controller para obtener acceso al controlador.
‫También usamos la función de conversión para enviar desde el puntero del controlador tipo A al puntero del controlador del jugador tipo
‫A.
‫Ahora podemos acceder a la función que necesitamos, que es obtener resultados de éxito bajo el cursor que existe en la clase de
‫controlador de jugador A.
‫Entonces, comenzaremos a usar esta función en el próximo video.
‫Te veré pronto.