Una guía para la Gestión de Recursos de estrategia en tiempo real de juegos – GameDev Academia

Puede acceder al curso completo aquí: Proyecto de estrategia en tiempo real – la recolección de recursos

Tabla de contenidos

Creación de un objeto de recursos

Para empezar, vamos a crear un nuevo GameObject vacío llamado Resource_Tree . A continuación, arrastre el modelo de árbol en la escena como un hijo del objeto vacío.


  • Ponga la posición 0, 0, 0
  • Establecer la escala de 0,12, 0,12, 0,12

    objeto de árbol de la Unidad y su transformada componente

    A continuación, seleccione el Resource_Tree objeto.


    • define la etiqueta de recursos
    • Ajuste la capa a sitio web

      Inspector Unidad con Tag y Capa rodeó

      Recurso Componentes

      Ahora vamos a trabajar en los guiones. Crear dos nuevas secuencias de comandos de C # y adjuntarlos a la Resource_Tree objeto.


      • ResourceSource
      • ResourceSourceUI

        Inspector de la Unidad con los scripts de gestión de recursos agregados

        A continuación vamos a trabajar en el colisionador que detectará clics del ratón. Añadir un nuevo CapsuleCollider componente.


        • Establecer el Centro de 0, 2, 0
        • establecer el radio a 1
        • Establecer la altura a 4

          objeto de árbol de la Unidad, con el componente colisionador añadido

          Para la navegación AI, vamos a añadir un componente NavMeshObstacle.


          • establecer la forma en Capsule
          • Establecer el radio de 1.3
          • Establecer la altura a 4
          • Habilitar Carve

            componente de obstáculos Unidad Nav Mesh

            Ahora bien, si nos vamos a la Navegación ventana, verá que el árbol se está forjando en el NAV de malla.

            escena Unidad con Navmesh añadió

            ResourceSource escritura

            Vamos ahora abrir el ResourceSource script con Visual Studio y empezar a crear scripts.

            En primer lugar, vamos a añadir una nueva biblioteca en la línea 4.
            utilizando UnityEngine.Events; 1usingUnityEngine.Events;

            A continuación, justo por encima de la clase, vamos a crear un enumerador para almacenar nuestros tipos de recursos. En este momento, sólo tenemos comida, pero en el futuro, es posible que desee agregar más.
            ResourceSource public enum {} Alimentación Alimentación 1234publicenumResourceSource {}

            De vuelta a la clase, vamos a crear nuestras variables.
            Tipo de público TipoRecurso; cantidad int pública; // eventspublic UnityEvent onQuantityChange; tipo 12345publicResourceType; publicintquantity; // eventspublicUnityEvent onQuantityChange;

            La GatherResource función será llamada cuando una unidad se encuentra en el recurso, recogiéndola . Ellos enviarán sobre el jugador para recoger el recurso, y el importe a cobrar.
            GatherResource public void (int cantidad, jugador gatheringPlayer) {cantidad – = cantidad; int amountToGive = cantidad; si (cantidad <0) amountToGive = + cantidad cantidad; si (cantidad <= 0) Destruir (GameObject) if (! onQuantityChange = null) onQuantityChange.Invoke ();} 123456789101112131415publicvoidGatherResource (intamount, jugador gatheringPlayer) {cantidad- = cantidad; intamountToGive = cantidad; si (cantidad <0) = amountToGive cantidad + cantidad; si (cantidad <= 0) Destruir (GameObject) si (onQuantityChange! = null) onQuantityChange.Invoke ();.}

            de nuevo en el editor, vamos a configurar las propiedades


            • establezca el tipo de alimentos
            • ajustar la cantidad a 100

              componente de secuencia de la Unidad de Recursos Curso

              En la siguiente lección, vamos a trabajar sobre la configuración de la interfaz de usuario de recursos para mostrar la cantidad restante.

              Recursos interfaz de usuario

              Como hijo de la Resource_Tree objeto, crear un nuevo objeto de la lona. Esto mantendrá los elementos de la interfaz. Cambiar el nombre a PopopCanvas .


              • establecer la posición a 0, 4.6, -0.7
              • Establezca una anchura de 240
              • ajustar la altura a 120
              • establecer la escala de 0.01, 0.01, 0.01
              • Establecer el modo de procesado a Mundial del Espacio
              • Adjuntar un nuevo componente Imagen

                Inspector Unidad con diversos componentes de interfaz de usuario en círculos

                Configurar el color de la componente de imagen a un gris oscuro.

                La unidad de interfaz de usuario de la imagen con el color gris oscuro

                Como hijo de la tela, crear un nuevo objeto de imagen.


                • Ponga la posición -60, 0, 0
                • Establecer el ancho a 80
                • Establecer la altura a 80
                • Establecer la imagen de la fuente de UIIcon_Tree

                  imagen de la unidad de interfaz de usuario con el sprite de árbol blanco añadido

                  Como hijo de la tela, crear un nuevo texto – TextMeshPro objeto. Cambiar el nombre a Cantidad .


                  • Ponga la posición 63, 0, 0
                  • Establezca una anchura de 113
                  • ajustar la altura a 120
                  • Establecer el estilo de fuente a Negrita
                  • Establecer el tamaño de fuente a 50 (diferente a la imagen)
                  • establecer la alineación a la izquierda de mediana

                    imagen Unidad de interfaz de usuario con texto malla texto pro añadido

                    LookAtCamera escritura

                    Para que el lienzo para estar mirando a la cámara, vamos a crear un nuevo guión C # llamado LookAtCamera . Coloque esta a la lona y se abre en Visual Studio.
                    [ExecuteInEditMode] LookAtCamera clase pública: MonoBehaviour {leva de la cámara privada; void Awake () {cam = Camera.main; } Void Update () {transform.eulerAngles = cam.transform.eulerAngles; }} 123456789101112131415 [ExecuteInEditMode] publicclassLookAtCamera: MonoBehaviour {leva privateCamera; voidAwake () {cam = Camera.main;} voidUpdate () {transform.eulerAngles = cam.transform.eulerAngles;}}

                    La ExecuteInEditMode medios de atributos que este script se ejecutará en el editor, incluso si no estamos jugando el juego. Así que cuando se guarda el guión y volver al editor, verá que el lienzo está ahora mirando a la cámara.

                    ResourceSourceUI escritura

                    Ahora vamos a trabajar en el script de ResourceSourceUI. Abrir hasta que en Visual Studio. Comenzaremos añadiendo en el texto de malla Pro biblioteca.
                    utilizando TMPro;.

                    En la clase, vamos a crear nuestras variables
                    GameObject popupPanel pública; TextMeshProUGUI pública resourceQuantityText; ResourceSource de recursos públicos; 123publicGameObject popupPanel; publicTextMeshProUGUI resourceQuantityText; publicResourceSource recursos;

                    La OnMouseEnter función está incorporada en MonoBehaviour de la Unidad. Que se llama cuando nuestra ratón entra en el colisionador del objeto.
                    OnMouseEnter vacío () {popupPanel.SetActive (true);} 1234voidOnMouseEnter () {popupPanel.SetActive (true);}

                    A continuación, en el , función OnMouseExit, vamos a desactivar el panel.
                    OnMouseExit vacío () {popupPanel.SetActive (falso);} 1234voidOnMouseExit () {popupPanel.SetActive (falso);}

                    La OnResourceQuantityChange función va a ser un oyente a la onQuantityChange evento en el guión ResourceSource.
                    pública OnResourceQuantityChange void () {resourceQuantityText.text = resource.quantity.ToString ();} 1234publicvoidOnResourceQuantityChange () {resourceQuantityText.text = resource.quantity.ToString ();}

                    De nuevo en el editor, vamos a llenar en las propiedades.


                    • Añadir una nueva escucha al evento OnQuantityChange y el enlace que hasta la función que acaba de hacer
                    • Establecer propiedades de los componentes de la interfaz de usuario de recursos de origen a sus respectivos objetos

                      Inspector de la Unidad con las asignaciones de componentes prefabricados para secuencias de comandos

                      Si presiona el juego, se puede ver que el lienzo se activa y desactiva cuando el cursor sobre el recurso.

                      Transcripción

                      Hola a todos, y bienvenidos de vuelta. En esta lección vamos a trabajar sobre cómo comenzar a crear nuestro recursos, que va a ser un árbol que las unidades se pueden reunir y que les da la comida, y con este alimento, que puede entonces freza más unidades.

                      Así que para empezar, voy a crear un objeto nuevo juego de vacío. Voy a llamar a éste de aquí nuestra Resource_Tree. Y voy a configurarlo para que, posición cero cero cero, de modo que podemos conseguirlo en el centro de la pantalla por ahora. Ahora, con este árbol de recursos, si nos vamos a la vista de la escena y pulse F para centrarse en ella, no hay nada en este momento. Por lo tanto, vamos a ir realmente a nuestros modelos carpeta y arrastrar el árbol como un hijo del objeto vacío. Vamos a traer el árbol al centro.

                      Como se puede ver, es muy grande. Probablemente no lo queremos tan grande. Por lo tanto, voy a traer la escala hasta aquí para tal 0.12 como que se parece bastante a escala. Y si nos vamos a la vista del juego aquí, podemos ver que el árbol está a la vista, y se ve tamaño bastante decente.

                      Así que ahora lo que podemos hacer es volver a nuestro objeto Resource_Tree aquí y vamos a empezar por cambiar la etiqueta a los recursos y la capa de recursos también. Si esto aparece aquí sólo podemos sin hacer clic, solamente este objeto. Y ahora podemos empezar con los componentes. Ahora, con nuestros recursos, que vamos a tener un guión, que gestiona la cantidad de alimentos que hay en ella, el tipo de recurso, y siempre que una unidad quiere obtener ese recurso, el tope de este script, por lo que se puede comprobar bien , ¿tengo suficiente de esto para regalar? Si es así, le dan. Si no es así, dar lo que me queda y luego destruir el recurso.

                      Así que en nuestros carpeta Scripts, voy a crear un nuevo guión C # aquí se llama ResourceSource. Vaya a nuestra Resource_Tree aquí y voy a arrastrarlo ese guión sucesivamente. También vamos a añadir en otro script. Y esto va a ser nuestra interfaz de usuario de los recursos, ya que con este árbol, vamos a tener de manera que si Pase el ratón sobre el árbol, a continuación, una pequeña ventana va a aparecer que nos muestra básicamente la cantidad de comida que queda en este recurso. < / p>

                      Por lo tanto, vamos a crear un nuevo árbol. Esto va a ser llamado nuestra ResourceSourceUI. A continuación, podemos seleccionar nuestro Resource_Tree y adjuntar eso también. Por lo tanto, tenemos estas dos secuencias de comandos en este momento. Y tenemos que añadir dos componentes más. El primero es un colisionador de cápsula, y esto va a estar aquí para detectar los clics del ratón porque vamos a tener enemigo seleccionado o vamos a tener las unidades seleccionadas. Y luego vamos a ser botón derecho del ratón en este árbol, por lo que necesitamos un colisionador de que a detectar. Para este colisionador cápsula, voy a establecer el radio aquí para aproximadamente una, una altura de cuatro, y vamos a hacer realidad este Centro Y hasta aproximadamente dos por lo que es, así que la cápsula se encuentra por allí.

                      Junto con este colisionador cápsula, también queremos añadir en un obstáculo navmesh. En el curso anterior, hicimos el trabajo en la creación de un navmesh, que, si vamos al panel de navegación aquí, se puede encontrar que al ir Ventana, AI, de navegación. Tiene básicamente un plano azul para las superficies que las unidades pueden caminar.

                      Ahora, con este árbol aquí, podría seleccionar este árbol, y luego ir a donde dice objeto, y luego vamos a seleccionar el modelo, y luego ir estática de navegación, no transitable. Pero el problema con esto es que cuando estos árboles luego con el tiempo se destruyen una vez que el recurso ha terminado, entonces todavía habrá una brecha aquí en el navmesh donde una vez fue ese árbol. Debido a que estos navmeshes, por defecto cuando se hornea, no son dinámicos, como su nombre implica que están al horno, así que son horneados en la malla real.

                      Así que una manera en que puede evitar esto al hacer este objeto una dinámica, es mediante la adición de un componente llamado un obstáculo navmesh. Así, obstáculo navmesh aquí, queremos que sea una forma de cápsula, vamos a establecer el centro aquí en cero, cero, radio, podemos establecer que a 1,3, y podemos tener una altura de 4. Ahora bien, si nos vamos a navegación, verá suceso del que nada. Y la razón es porque tenemos que establecer este obstáculo navmesh a tallar, que luego tallar en el navmesh existente.

                      Así que si volvemos al panel de navegación ahora, verá que este navmesh tiene ahora una gran brecha en ella, donde este árbol es. Y si en realidad se mueven alrededor de este árbol se verá que esta diferencia también sigue a lo largo. Así que si este árbol era entonces de repente ser destruido, entonces esto sólo sería llenado, y luego las unidades serían capaces de caminar a través de ella.

                      Ahora que tenemos nuestros objetos de árbol configurado y listo para ir, Lo que podemos hacer ahora es en realidad comenzar a aplicar el recurso aquí. Vamos a empezar por mirar dentro de la secuencia de comandos fuente de recursos aquí, así que vamos a abrir en el interior de Visual Studio, y en el interior de este script lo que vamos a centrarnos en su puesta en marcha es por lo que cada vez que una unidad quiere obtener un recurso , que va a comprobar si se puede, si es así, lo dará. De lo contrario se destruirá.

                      Así que voy a quitar las funciones de inicio y de actualización, aquí, y voy a añadir en dos variables, la primera es que va a ser el tipo de recurso. Ahora podríamos tener esto como una cadena o un número entero para referirse a una cierta identificación, pero lo que voy a hacer es usar un empadronador, que es básicamente una lista de cosas diferentes que podemos asignar como una variable. Así que te voy a mostrar lo que quiero decir.

                      En primer lugar, para ello vamos a ir enumeración pública para empadronador, y voy a llamar a éste nuestro TipoRecurso. Ahora en dos soportes de aquí podemos entonces entrar en todos los diferentes valores posibles para esta empadronador, así que realmente ahora sólo vamos a tener uno, así que sólo voy a entrar en los alimentos, pero si tuviera múltiples, usted podría ir comida, coma, y ​​entonces podría ser algo como madera, coma, piedra, y etcétera. Pero sólo tenemos comida, así que sólo voy a salir de ese allí.

                      Y de vuelta dentro de la clase, voy a crear esa como una variable, así que iré TipoRecurso pública, y llamar a éste tipo, por lo que ahora en el inspector o en escritura, podemos tipo básicamente listo para ser comida o piedra, o madera, o lo que tendrían dentro de este empadronador, aquí. Dado que sólo tenemos una, que va por defecto a la alimentación, por lo que en realidad no tienen que modificar de ninguna manera.

                      Así que con el tipo ahora lo que podemos hacer es añadir también en una cantidad para la cantidad de recursos que hay, así que podemos ir cantidad int pública, y después de esto, también quieren tener un evento. Y este evento va a ser llamado cuando la cantidad se cambia, y esto va a ser útil para alertar al sistema de interfaz de usuario para el recurso para actualizar su interfaz de usuario para mostrar la nueva cantidad.

                      Ahora, para hacer eso, sólo voy a añadir en una biblioteca utilizando UnityEngine.Events aquí para que podamos usar eventos, y luego sólo voy a ir a eventos, sólo para etiquetar esto adelante, y voy a llamar a éste nuestro público UnityEvent onQuantityChange. Ahora podemos entrar en nuestra función principal, que va a ser reunir los recursos, y esto aquí es sólo va a ser un GatherResource public void, y va a enviar más de dos cosas. En primer lugar, una cantidad por lo mucho que quiere reunir, y el juego para el gatheringPlayer.

                      Ahora no vamos a estar enviando sobre la unidad que está la recopilación de esta, ya que en realidad no importa, todo lo que necesitamos saber es qué jugador vamos a estar dando el recurso a? Debido a que cada unidad tiene un reproductor de propietario, el jugador que posee esa unidad, de manera que la unidad se va a enviar a través de su reproductor de propietario aquí, y luego vamos a dar a este jugador aquí el recurso, más o menos.

                      Así que lo que queremos hacer, en primer lugar, es la cantidad de resta de la cantidad, así que podemos ir cantidad – = cantidad y luego tiene que averiguar una cantidad para dar, porque no podemos simplemente darles la cantidad aquí que quieren, porque lo que si se trata, por ejemplo, cinco, y sólo tenemos dos quedan? Entonces sólo podemos darles posiblemente dos, por lo que es algo que tenemos que tener en cuenta. Así que sólo voy a ir aquí, int amountToGive, y por defecto, voy a hacer esta cantidad.

                      Ahora para comprobar si tenemos que modificar esto un poco, podemos ir si la cantidad es menor que cero, por lo que si la cantidad en este momento es menor que cero, entonces eso quiere decir que estamos en el negativo, lo que nosotros no ‘t quiere, por lo que queremos equilibrio que salir y dar al jugador aquí menos de lo que quieren. Así, por esta podemos ir amountToGive = importe + cantidad. Así, por ejemplo, si estamos en, actualmente, una cantidad de cinco y queremos obtener el 10, no podemos hacer eso.

                      Así que aquí, estamos cantidad ajuste para ser -10, ya que estamos haciendo básicamente cinco llevar diez, la cantidad es ahora -5, amountToGive, sólo podemos darles cinco ya que eso es todo lo que realmente habíamos dejado, por lo estamos estableciendo amountToGive a ser igual a la cantidad más cantidad, por lo que 10 más -5 va a ser cinco. Así que estamos les va a dar cinco, a pesar de que pidieron 10 pero que sabemos, sólo tenemos cinco. Aparte de esto, entonces, sólo queremos ir si nuestra cantidad es menor o igual a cero, queremos destruir el recurso, por lo que sólo voy a ir a destruir GameObject.

                      Y ahora todo lo que tenemos que hacer en esta función aquí es llamar al evento onQuantityChange ya que la cantidad ha cambiado aquí, queremos llamar al evento. Así que en primer lugar, tenemos que comprobar si hay alguna oyentes en el evento, ya que si no hay, que va a vomitar errores. Así que si onQuantityChange no es igual a cero, entonces onQuantityChange.Invoke. Y ahí vamos, que es prácticamente todo lo que tenemos que hacer para este script aquí, así que vamos a ir de nuevo en el editor de ahora.

                      Y lo que voy a hacer es establecer el tipo aquí en la fuente de recursos de comida, por supuesto, porque eso es el único que nos queda, y la cantidad, podemos simplemente establecer que a 100, o lo que realmente quieres . Puede probar esto más adelante una vez que hemos creado la capacidad de nuestras unidades para recoger el recurso, en el que podemos establecer sus tasas de recoger, y cosas por el estilo.

                      Así que en la próxima lección vamos a estar trabajando en la creación de la interfaz de usuario de la fuente de recursos aquí, que va a hacer que sea así que cuando nos vuelo estacionario sobre el recurso es que nos va a mostrar la cantidad restante. Así que gracias por ver, y yo veré a todos en la próxima lección.

                      Bienvenidos a todos de nuevo. En esta lección nos va a ser de continuar con nuestro árbol de recursos por aquí. En la lección anterior hemos creado el objeto y el guión fuente de recursos. Lo cual nos permite realmente conseguir algo de ese recurso, y cuando llega a una cantidad de cero se destruye. Así que en esta lección vamos a estar trabajando en el pequeño panel de interfaz de usuario que aparece cada vez que se pasa sobre el recurso. Se le muestra básicamente la cantidad restante.

                      Así que para hacer eso de abrir nuestro árbol de recursos aqui, y como un niño del árbol de recursos que voy a crear un nuevo lienzo, que va a ser la celebración de nuestra interfaz de usuario. Voy a cambiar el nombre de este aquí para nuestros PopupCanvas. Y con el fin de hacer de este un lienzo que podemos reducir el tamaño, cambiar el tamaño y la posición, tenemos que cambiarlo de un modo aleatorio de espacio en la pantalla al espacio de entorno. Y esto lo hace por lo que no está unido a nuestra pantalla de la cámara, sino que es un objeto en el mundo que nos podemos mover en el espacio 3D.

                      Así que ahora que hemos hecho de que, a continuación, podemos modificar la posición X, Y. Voy conjunto X e Y a cero a alrededor de un 4,6, y el ancho tendremos que alrededor de 240 y una altura de 120. Y ahora te voy a mirarlo ver, ver que es un lienzo muy grande, por lo que una manera de solucionar este problema es entonces la reducción de abajo de la escala. Voy a llevar el mínimo de escala de 0.01 en los ejes X, Y y Z.. Y como se puede ver, aquí está, aquí, tenemos el lienzo, que es alrededor del tamaño que queramos. Ahora también vamos a ajustar la posición de la zeta de ser negativo 0.7, simplemente por lo que está en frente del árbol, y que podemos ver a continuación.

                      Así que lo que quiero hacer ahora es, vamos a añadir un componente a este lienzo. Y voy a añadir en un componente de la imagen, para que podamos tener un poco de historia aquí. Y el color que voy a hacer que esto va a ser de un color gris oscuro, algo similar a esto de aquí. Y con esta imagen ahora, podemos también, en este objeto de lona, ​​podemos quitar el componente raycaster gráfico. Esto sólo significa que no serán capaces de raycast nada, así que no vamos a ser capaces de hacer clic en los botones, pero eso no es realmente necesario, por lo que sólo podemos quitar eso.

                      Por lo que tenemos aquí el lienzo emergente de configuración, ahora vamos a añadir en los dos elementos que van a hacer las paces. Eso va a ser el icono del árbol de aquí a la izquierda, y en el lado derecho, el texto cantidad. Así que en el lienzo de la imagen que voy a la interfaz de usuario haga clic en Ir a la derecha. Y esto aquí es que va a ser nuestro icono. Ahora todo lo que tenemos que hacer aquí es, voy a establecer la posición en la que X sea negativo alrededor de 60, y luego también podemos reducir su tamaño un poco, así que voy a traer el ancho a 80, y el altura hasta 80 también. Y entonces podemos establecer la imagen de origen aquí, al ser el árbol icono de la interfaz de usuario. No nos vamos, tenemos el icono del árbol.

                      Y después de eso podemos trabajar en el texto real cantidad. Así que para hacer eso, voy a click derecho en nuestro lienzo emergente, ir a la interfaz de usuario, texto, TextMeshPro, y esto va a pedir que importar algunos productos de TMP. Texto de malla Pro es básicamente un nuevo tipo de sistema de interfaz de usuario para la unidad. Es un reemplazo para su único defecto, lo que realmente no es el mejor. Texto de malla marcas Pro para que el texto es en realidad en malla, simplemente una imagen de píxeles en lugar de. Por lo que el texto es un rizador mucho y hay también mucho más básicamente opciones que usted puede hacer para aplicar al texto.

                      Así que nos dio nuestro texto aquí, estoy aquí para cambiar el nombre de esta nuestra cantidad. También vamos a definir el ancho aquí para ser 114, altura de 120, y voy a sext la posición X a ser 63, por lo que es en el lado derecho aquí. Sólo podemos poner un texto de ejemplo, por ahora, sólo voy a poner maquillaje 100. Vamos hacerle centrado, por lo que vamos a ir a la alineación aquí para estar en el medio. Y también vamos a ponerlo en negrita, así que es un poco más grande. Es también el texto bastante pequeña, así que podemos aumentar el tamaño de alrededor Digamos 50.

                      Si nos fijamos en la vista de juego, podemos ver el panel de la derecha allí, pero no está mirando hacia la cámara. Así que pudimos girar hacia arriba para hacer frente a la cámara, pero luego lo que pasa si queremos ajustar tal vez nuestra posición de la cámara con el tiempo? Bueno, el problema con esto es que, a continuación, se nos va a requerir para volver a girar el lienzo de nuevo. Así que algo que podemos hacer es crear un script que automáticamente puede girar el lienzo para mirar a la cámara.

                      Y lo que voy a hacer es crear una marca nueva secuencia de comandos aquí. Y esto va a ser llamado mirada a la cámara. De acuerdo, entonces podemos abrir esta dentro de Visual Studio, y lo que este script hace básicamente es sólo gira el lienzo, o cualquier objeto en realidad. Se puede conectar a cualquier objeto, y se le mira a la cámara. Por lo tanto, podemos eliminar la función de arranque, y voy a reemplazar esto con la función despierto, pero primero vamos a crear nuestra variable, que va a ser una leva cámara privada, por lo que podemos acceder a la cámara.

                      Y luego en la función despierta vacío, vamos a conjunto de levas para ser igual a la cámara de punto principal. Y luego, en la función de actualización, que es llamada cada cuadro, podemos girar el objeto para hacer frente a la cámara. Y para hacer eso, sólo podemos coincidir con la rotación de la cámara, por lo que es igual a transformar punto eulerAngles leva de puntos transformar punto eulerAngles. Y ahora lo que podemos hacer es volver salto dentro del editor y como se puede ver nada todavía sucede, pero cuando presiona el juego, vamos a ver que el lienzo no es lookin’ a la cámara porque no hemos fijado todavía .

                      Así que en nuestro lienzo emergente, vamos a adjuntar al mirar el script de cámara, presiona el juego, y hay que ir. Se está examen a la cámara, podemos moverse. Sin embargo, es posible que desee tener esta mirada de la lona a la cámara mientras que nos encontramos, no jugar el juego. Y una manera de hacerlo es, si volvemos a nuestro script aquí. Lo que podemos hacer es añadir en una ejecución en modo de edición de atributos de esta clase. Así que en la parte superior de la clase, sólo voy a ir entre corchetes, ExecuteInEditMode, y lo que esto significa es este script aquí va a estar corriendo en el interior del modo de edición, cuando no estamos jugando el juego. < / p>

                      Así que si salvamos esto y volver al editor, lo que se verá, el panel actual está ahora mirando a la cámara. Y esto se debe a que se está ejecutando la función de actualización, incluso cuando no estamos jugando el juego. De modo que pueda ajustarse automáticamente a mirar a la cámara en todo momento. Lo cual está muy bien.

                      Así que, aparte de eso, lo que podemos hacer ahora, es empezar a trabajar en el guión de interfaz de usuario real que tiene el lienzo emergente. Y que va a ser la secuencia de comandos de interfaz de usuario fuente de recursos, que nos hemos unido a nuestro recurso subrayado objeto de árbol. Vamos a abrir esta dentro de Visual Studio, y aquí podemos empezar a comenzar realmente a secuencias de comandos.

                      Entonces, ¿qué vamos a tener aquí, está a sólo un par de cosas, primero de todo el complemento de dejar entrar el uso de la biblioteca TMPro, porque necesitamos acceder a las clases TextMeshPro. Y después de nuestras variables podemos tener nuestra GameObject pública popupPanel, y esto es lo que vamos a activar o desactivar si el ratón está sobre o no. Y entonces tenemos un textmeshproUGUI pública para el texto de la cantidad de recursos. Entonces tenemos un resourceSource pública para el recurso real que esto está unido a.

                      Y ahora lo que podemos hacer es habilitar o deshabilitar el panel cuando se movía sobre o se han mantenido fuera. Y para hacer eso solo se puede utilizar una función incorporada en monobehaviour, que es nula OnMouseEnter, así que cuando el ratón entra en el colisionador de este objeto, queremos ir popupPanel, punto, setActive, es cierto. Y cuando las salidas de ratón que hemos OnMouseExit, a continuación, lo que podemos hacer es básicamente desactivar el panel, por lo popupPanel punto setActive, falsa.

                      Ahora estamos fijando el panel sea verdadera o falsa, pero lo que sucede cuando queremos actualizar el texto cantidad? Bueno, si usted recuerda en nuestro script resourceSource aquí, tenemos un evento llamado onQuantityChange, que es llamada cada vez que una unidad ha reunido el recurso. Así que lo que queremos hacer es crear una función que se llamará cuando ese evento se llama, y ​​que va a ser un público, nula OnResourceQuantityChange, y todo esto es que va a hacer, se establece el texto a ser nuestro derecho cantidad de recursos aquí, así que sólo podemos ir rsourceQauntityText, punto de texto, es igual a nuestro recurso, punto cantidad.

                      Ahora se ve que se producirá un error, y esto se debe a que estamos tratando de asignar una cadena, que es el texto que aquí, al ser un número entero, que es la cantidad. Por lo que una forma en que podemos convertir este entero en una cadena es sólo por ir punto, ToString, al final, como tal.

                      Ahora vamos a salto dentro del Editor de nuevo, y Vamos a conectar este guión a la altura de diversos objetos y el evento. Así que podemos arrastrar en la ventana emergente lienzo aquí por la PopupPanel. El texto cantidad de recursos, que es nuestra cantidad aquí. Recurso que es el ResourceSource y luego vamos a agregar un nuevo evento aquí en el evento onQuantityChange, arrastre en la ResourceSource interfaz de usuario, y establecer la función de ser ResourceSource interfaz de usuario, el DOT, en cambio la cantidad de recursos.

                      Ahora bien, si usted presiona el juego, verá, por supuesto, no hay nada que realmente sucede, y eso se debe a que no tenemos las unidades realmente capaz de mina de los recursos todavía. Entonces, ¿qué vamos a estar trabajando en la siguiente lección que realmente está teniendo estas unidades empiezan a entender que hay un recurso aquí y permitir que se muevan hacia él, y comienzan la minería ella. Así que gracias por ver y voy a verlos a todos en la próxima lección.

                      interesado en continuar? Echa un vistazo a la estrategia del proyecto completo en tiempo real -. Recursos Encuentro por supuesto, que es parte de nuestra Academia de desarrollo de juegos de estrategia

                      Mensajes relacionados

Deja una respuesta

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