Transcripciones
1. Introduccion: Bienvenido a mi curso
sobre lo esencial del desarrollo
de juegos y Gado. Este curso es una continuación de introducción al
desarrollo de juegos de tres D y Gado pero se
puede seguir y aplicar
a cualquier proyecto que contenga un personaje que el jugador pueda controlar para moverse por
múltiples niveles. Te invitamos a unirte a
nuestro servidor de discordia para trabajar en este curso
junto a tus compañeros En este curso,
cubriremos elementos esenciales que son comunes a casi
cualquier juego de cualquier género. Construyendo una escena de título, menús, transición fluida
entre escenas, movimiento de un personaje entre diferentes niveles de tu
juego, música de fondo, ajustes y
persistencia de datos entre escenas, niveles y sesiones de juego Cuando termines,
tendrás una buena estructura
básica de
un juego que
podrás desarrollar aún más en algo de tu propio
diseño de cualquier género. También aprenderás habilidades útiles para trabajar con el motor de juego
Gada, organizando y diseñando tus proyectos para que
sean más escalables. Estarás
aprendiendo a codificar con script
GD con todo lo
explicado en detalle Aplicaremos principios de diseño
orientado a objetos en nuestros scripts, herencia, encapsulación y abstracción,
para mantenerlos organizados, personalizables y reutilizables
para un proyecto de cualquier tamaño Todos los archivos del proyecto
también estarán disponibles en GitHub, si necesitas revisar
el proyecto tal como estaba después de completar
cada lección. Estos videos fueron grabados
usando Gadot versión 4.2 0.2. El proyecto comienza
con activos de
Ka Kits Character y Dungeon remasterizados Packs
hechos por En este curso,
también estaré agregando activos de Basic Guy Bundle
hecho por Penzilla, y música en el pack
Barns Music hecho por Eric el Funny Todos están disponibles
para descargar gratis en H dot IO.
2. Pausa: Hola, amigos. Antes de que
empecemos, deberías tener una
escena de juego en tu proyecto, que contenga un personaje
que el jugador pueda controlar y un nivel en el que
puedan caminar. Debes tener al menos dos o tres escenas de diferentes niveles listas para conectar entre sí cuando el jugador
pasa por encima de un umbral. A lo largo de este curso,
agregaremos elementos que
son esenciales para cualquier tipo de juego
que se te ocurra, incluyendo menús, transiciones de
escena y nivel, desvanecimiento tanto visuales como audio,
ajustes, créditos
y persistencia de datos Puedes usar tu propio proyecto para seguir junto con este
curso o descargar un proyecto de inicio de mi
Github titulado
Curso Godot Essentials rama principal Tu proyecto puede ser
dos D o tres D y casi cualquier
género de juego que implique mover a un personaje
entre diferentes escenas. Empecemos por permitir que el
jugador haga una pausa en el juego. Al abrir la configuración del proyecto y cambiar a la pestaña Mapa de entrada, podemos agregar una nueva acción para pausar y hacer clic en
el botón Agregar. Desplazándonos hacia abajo, encontrando
nuestra nueva acción de pausa, podemos agregar eventos
que activarán esta acción de pausa haciendo
clic en el botón Más Usaré la tecla Escape y el botón de inicio
de mi mando. Hemos estado usando el nodo
jugador para manejar entrada de
nuestro juego a través
del guión de los jugadores adjuntos y repasando la información
apropiada para
mover al personaje o el brazo de
resorte y la cámara Como hicimos con los botones de
correr y saltar, podemos verificar si se presionó el
botón de pausa. Pero no queremos pausar
al personaje ni a la cámara. Queremos hacer una pausa
en toda la escena. Podemos tomar una referencia
al nodo
raíz de escenas exportando
otra variable. Vamos a llamarlo subrayado GM, abreviatura de manager de juego Pero el valor de esta variable nunca
debería
tener que cambiarse realmente. Siempre debe ser el
nodo raíz de la escena del juego. En lugar de en la exportación, podríamos usar at on ready para establecer el valor de nuestra variable
GM para obtener padre, ya que el nodo jugador es
un hijo del nodo de juego. Pero es posible que no queramos confiar en
esta estructura exacta para
que nuestro guión funcione correctamente. Podemos, por ejemplo,
querer que el nodo jugador
sea hijo del
nodo de personaje por otras razones. Entonces para hacer que esta referencia siempre apunte directamente al nodo raíz de
Scenes, podemos usar la anotación del
signo de dólar Comenzando la ruta del nodo
con barra diagonal diagonal,
comenzaremos en la raíz de árboles de
escena Pero es importante señalar que este aún no es el nodo de la escena del
juego. También necesitamos agregar el
nombre del nodo raíz a esta ganancia de barra de raíz de ruta de nodo Si ejecutamos nuestra escena actual, luego cambiamos a la
vista remota en el panel de escena, podemos ver que el nodo raíz de
árboles de escena se denomina raíz, y actualmente el nodo
hijo de raíces único es el nodo de juego. Ahora que nuestro nodo reproductor tiene una referencia directa
al nodo raíz de escenas, llamemos a una función
en él que
aún no
hemos escrito, Toggle pause. Adjuntar un nuevo script
a nuestro nodo de juego. Este guión se encargará de gestionar la
escena en su conjunto. Lo llamaremos manager de juegos. Al igual que un gerente
en un lugar de trabajo, este trabajo de guiones será abrir la escena
cuando comience por primera vez. Asegúrate de que todos los
empleados o nodos hijos tengan todo lo que necesitan para hacer sus trabajos individuales, luego cierra la escena
cuando esté terminada. Dado que nuestro juego simple solo
tiene un modo de juego, solo
necesitamos un manager de juego. Pero un juego más complejo con múltiples escenas de juego podría
tener un gerente de exploración, gerente de
batalla, un gerente de rompecabezas etc., para diferentes escenas de
juego. En nuestro nuevo script de administrador de juegos, podemos agregar la función toggle
pause que llamamos desde el script
del jugador. Pausar el juego es
en realidad bastante simple. Comenzaremos por
obtener una referencia a todo
el árbol de escenas con una función
incorporada, get tree. El tipo de retorno de este
método es un árbol de escenas, que contiene una variable llamada
paused a la que podemos acceder con p. El tipo de la variable
pausada es un booleano, que tiene un valor predeterminado Establecer el valor en
true pausas para ganar. Podemos cambiar el valor de
ida y vuelta entre verdadero
y falso cada vez se
llama a
esta función de pausa de alternar usando el operador lógico
naught, representado con un signo de
exclamación Estableciendo el valor de
pausado a nada falso la primera vez y luego no verdadero el segundo y Si lo probamos,
podemos pausar el juego, pero aún no podemos deshacer la pausa. Esto se debe a que el nodo jugador, que está tratando de recibir la
entrada para restablecer la pausa del juego, también
está en pausa y no puede
recibir ni procesar Algunos nodos específicos que quizás no
queramos hacer una pausa mientras
el juego está en pausa Seleccionando el
nodo reproductor en el árbol de escenas, busque en el inspector debajo nodo y expanda la sección de
proceso. La propiedad mode está
actualmente establecida para heredar, lo que significa que heredará el mismo modo de proceso que
su padre, el nodo de juego Dado que el nodo de juego está en pausa, el nodo jugador también hará una pausa Podemos cambiar este
valor a siempre, por lo que el nodo jugador siempre
procesará incluso cuando
el juego esté en pausa Tenga en cuenta que también podemos hacer que
los nodos pai tengan algunos nodos que solo procesen mientras el juego está pausa o deshabilitar el procesamiento de ciertos nodos por completo Ahora cuando ejecutamos la escena, podemos pausar e
inpausar el juego ya que el nodo jugador siempre se está
ejecutando independientemente Pero esto crea un nuevo problema. Si hacemos una pausa en el juego y
presionamos el botón de salto, luego unpause, el
personaje salta Si no queremos este comportamiento, tenemos que volver al guión
del jugador. Primero movamos la comprobación del botón de pausa a la
parte superior de la función de entrada. Entonces, si el árbol está en pausa, ignore cualquier entrada adicional
regresando y haga lo mismo en la función de proceso para ignorar también los controles de movimiento y
cámara Ahora, cuando el juego está en pausa, la única entrada que el jugador puede dar es hacer una pausa en el Todo lo demás será ignorado. Por último, me gustaría
mostrar un menú en la pantalla con algunos botones
mientras el juego está en pausa Pero antes de hacer algo
que involucre la interfaz de usuario, debemos configurar el tamaño de la ventana del
juego. Abra la configuración del proyecto y
cambie a la pestaña general. Seleccionando ventana, podemos establecer la propiedad size para establecer el tamaño de la
ventana de nuestro juego. El tamaño óptimo de la ventana
dependerá de su plataforma objetivo. Voy a usar 12 80 por 720 pixeles. Hasta el momento, todo en
nuestro árbol de escenas está siendo observado por la cámara para
producir una imagen de dos D, que es lo que vemos en nuestra
ventana cuando jugamos el juego. Esta imagen de dos D
que está siendo renderizada por nuestra cámara es la capa cero
de la pantalla de dos D. Podemos agregar
capas adicionales a la visualización de nuestros juegos después de que la cámara haya terminado su renderizado usando
un nuevo tipo de nodo, un nodo de capa Canvas. La capa predeterminada de un nodo de capa
Canvas es una, por lo que se dibujará
sobre la capa cero. Si queremos, podemos
agregar cualquier número de capas para dibujar delante o detrás
de nuestro juego. Cambiemos el nombre del nodo de
capa Canvas a UY, abreviatura de interfaz de usuario Pulsando con el botón derecho en el nodo UI y seleccionando Agregar nodo hijo. Agreguemos un
nodo de etiqueta al Canvass. Esto cambia nuestra vista a dos
D. Hasta ahora solo hemos estado trabajando con nodos predeterminados como el nodo reproductor y tres
nodos D para todo lo demás. Nuestro Canvas utilizará
una familia diferente de nodos llamados Nodos de control, los cuales tienen iconos verdes. Cambiaré el nombre de este nodo a title y estableceré su propiedad
para que diga pausa. A continuación, vamos a repetir el
proceso para agregar un botón. Y nombra el botón continuar. Después edita el
texto de los botones para decir lo mismo. Zoom y encuadre, para que pueda ver el rectángulo azul
a la derecha del eje y verde y
debajo del eje x rojo. Esta es la ventana gráfica
de la ventana del juego. Nuestros nodos se agregaron
en el origen de la escena, por lo que se renderizarán en la esquina superior izquierda de la
pantalla si jugamos el juego, pero se superponen. Organicemos estos nodos
usando otro nodo de control, un contenedor de caja vertical. Un contenedor de caja vertical en realidad
no dibuja nada, pero organizaremos sus
hijos para que se alineen verticalmente, haciendo que la organización sea más rápida que si tuviéramos que
colocar manualmente cada nodo. Seleccionando tanto el título
como los nodos continuos, podemos hacer clic y arrastrar
para volver a
los padres al nodo de cuadro vertical y ver que se reorganizan
automáticamente Duplicemos también el botón de
continuación para crear otro botón y
nombrar a esta salida. Después edita la
propiedad text para que coincida. La caja vertical
se ajustó automáticamente para
acomodar el botón adicional. Cambiemos el nombre de la
caja vertical para pausar el menú. Con el
nodo de menú de pausa seleccionado, expanda la sección de diseño. El valor preestablecido de anclajes está configurado
actualmente en la parte superior izquierda. Podemos anclar fácilmente
el menú de pausa a cualquier borde de esquina o al
centro de la pantalla. Los anclajes están representados en la vista previa por estos
cuatro pines verdes, que individualmente podemos hacer clic y arrastrar
alrededor de la pantalla Los anclajes determinan la posición o tamaño de las
notas, en relación con el tamaño de ventana que establecemos en la configuración del proyecto, expresado como porcentaje También podemos usar anclajes personalizados si queremos, por ejemplo,
usar solo el 10% superior de
la pantalla para una barra de menú, o tal vez usar el tercio medio de la pantalla para
mostrar un marcador Anclaré mi menú de pausa al centro de
la pantalla, y también estableceré la alineación
horizontal de los títulos para que se centren para que
coincidan con los botones. Con el menú de pausa creado, establecemos su
propiedad visible en false
por defecto haciendo clic en el icono
junto a ella en el árbol de escenas. Después en el guión del administrador del juego, podemos usar un ready para obtener una
referencia al menú Pausa. Usando el signo $1 para
especificar una ruta de nodo, usando comillas porque
el nombre contiene un espacio, pasando por el nodo UI para
acceder al nodo del menú de pausa. Cuando el juego está
pausado o sin pausa, podemos establecer la propiedad
visible del menú de pausa para
que coincida con el valor
pausado del Ahora tenemos un
menú de pausa con botones, pero ¿cómo sabemos cuándo se presionan
los botones, y qué hacemos cuando se
presionan? Si seleccionamos el
botón de salida en el árbol de escenas, podemos cambiar la
pestaña del inspector a la pestaña de nodo, que mostrará
las señales por defecto. Si se muestran grupos, puede cambiar a señales
haciendo clic aquí. Aquí podemos ver una
variedad de señales que este nodo emitirá bajo
diferentes condiciones. El nodo de botón emitirá una
señal cuando se presione. Todo lo que tenemos que hacer es conectar
esta señal a una función, ya sea haciendo doble clic sobre ella o haciendo clic derecho y
seleccionando conectar. En la ventana, podemos seleccionar
cualquier nodo de nuestro árbol de escenas, que escucharemos para que se emita
la señal. Si seleccionamos el nodo del administrador del
juego, el campo del método receptor
dirá en Exit pulsado, que es el nombre de la
función que se
creará para nosotros cuando
hagamos clic en Conectar. Nuestra vista cambiará
automáticamente al script y mostrará el script del administrador del
juego, que ahora contiene la función pulsada al
salir. Esta función ahora se llamará automáticamente cuando el reproductor presione el
botón de salida . Se muestra un icono de conexión verde junto a la
definición de la función para decirnos que esta función está
siendo llamada por una señal, y el botón de salida en el árbol de escenas tiene
un icono de señal para decirnos que este nodo puede emitir una señal que está
conectada a un receptor. Por ahora, vamos a
imprimir a la salida, un mensaje que dice,
volver a la escena del título. Tanto para que sepamos que funciona como para recordarnos que implementemos
esta característica más adelante. Seleccionando el botón de continuación, también
podemos conectar
su señal presionada al nodo del administrador del juego. Pero esta vez, da clic
en el botón de selección y elige la
función de pausa de alternar que escribimos anteriormente. Por último, necesitamos este nodo para procesar mientras
el juego está en pausa Entonces cambiemos su modo de
proceso a cuando esté pausa. Vamos a probarlo. Podemos pausar el juego, al hacer clic en
el botón de salida se muestra nuestro mensaje y
al presionar el botón de continuar, se
pausa el juego Una vez que
los botones del menú tienen foco, también
podemos usar las teclas de
flecha para navegar entre los botones y la barra
espaciadora para presionarlos. Hagamos que esto funcione también
con nuestro controlador
de juego con solo un
par de pasos más simples. Abriendo la configuración del proyecto, la pestaña Mapa de entrada, haga clic en el show
built in actions toggle para ver las
acciones que se utilizaron. El DP de Controllers ya está
listado en la interfaz de usuario izquierda, derecha arriba y abajo para
navegar por los menús. Pero necesitamos agregar una entrada de
controlador a la UI accept action para
poder presionar los botones. Voy a usar el botón de
acción inferior, que es A en mi Controller. Ahora solo necesitamos el menú para captar el foco cuando se abre. Añadiendo un script
al nodo del menú de pausa, simplemente le
nombraremos menú. Exportaremos una variable
para mantener el elemento del menú, que debe tomar el
foco por defecto cuando se abre
el menú
de control de tipo. Voy a asignar el botón de
continuación para que sea el elemento de enfoque predeterminado en el inspector haciendo clic y
arrastrándolo al campo Creando una función pública,
llamémosla abierta. Podemos establecer la
propiedad visible en true y
también decirle al elemento de
enfoque predeterminado que tome el foco. Y otra función cerrar, establecerá la
propiedad visible de nuevo en caídas. De vuelta en el guión del manager del juego. En lugar de establecer
la propiedad visible de la pausa muchos directamente, podemos llamar ya sea open o closed basado en el valor de paused, usando
una sentencia if Ejecutando la escena, usando
solo un controlador, podemos pausar el juego, navegar por el menú y
presionar los botones. Ahora tenemos un menú de pausa que se presenta al jugador
cuando presiona la pausa. En la siguiente lección,
construiremos una escena de título
para nuestro juego. Te veré en la siguiente lección.
3. Cargo: Hola, amigos. En
la lección anterior, creamos un menú de pausa
para nuestra escena de juego. En esta lección, construiremos una escena de título que se conecte con
la escena del juego. Para eso, necesitaremos
una imagen de fondo y algunos activos básicos de UI. Estaré usando paquete básico de Guy hecho por Penzila en it shot IO Empecemos por
crear una nueva escena. Puede seleccionar escena en la barra de
menú, luego nueva escena. Utilice el acceso directo Control
N o Comando N o
haga clic derecho en la pestaña Sistema de archivos
y seleccione Crear nueva escena. Al hacer clic derecho en una carpeta
específica se creará la escena en esa carpeta y nos
permitirá darle
un nombre de inmediato. No importa si esta
escena es dos D o tres D, ya que solo nos
interesa UY para esta lección Hagamos de este nodo raíz de escenas un nodo de control
seleccionando Interfaz de usuario. Y el nodo raíz
se
renombra automáticamente para que coincida con el
nombre del título de la escena Si creamos la escena
a través del menú, nos pedirá que seleccionemos primero
el tipo de nodo raíz. Después nombra y ordenalo en una carpeta la primera
vez que se guarde. Seleccionando el nodo raíz,
podemos ver que este es un nodo de control con sus
presets de anclaje establecidos en full wreck, cubriendo toda la ventana del juego, pero en realidad no
dibujando Al igual que en la lección anterior, agreguemos un nodo de etiqueta
y algunos botones. L et's nombra el título de la nota de etiqueta y establece la propiedad
de texto en el título de nuestro juego. Entonces igualmente, nombra
nuestros botones y edita sus
propiedades de texto a nuevo juego. Continuar. Ajustes, créditos y salida o cualquier otro botón que te gustaría tener en la pantalla de título de
tu juego. Organicemos también
estos botones usando un contenedor de caja vertical como lo hicimos con el menú Pausa y renombrémoslo a botones de menú. Podemos organizar rápida y
fácilmente estos artículos en nuestra
pantalla usando anclajes. Por ejemplo, me gustaría que
el título estuviera centrado horizontalmente en la pantalla y un tercio hacia abajo desde
la parte superior de la pantalla. Con la
nota de etiqueta de título seleccionada, expandiendo la sección de diseño, cambiaré los
ajustes preestablecidos de anclaje a personalizados Los anclajes se definen
como números 0-1, que representan el porcentaje del ancho o alto de los padres Posicionar el título en
el centro de la pantalla horizontalmente se puede hacer estableciendo el
ancla izquierda en 0.5, y el anclaje derecho se actualizará
automáticamente para que
coincida ya que el anclaje derecho no
puede ser menor que el izquierdo. De igual manera, posicionar el título a
un tercio de la parte superior de la pantalla significaría establecer
el ancla superior en 0.333 Esto no es del todo posicionar de
la manera que quiero todavía porque los anclajes están en la esquina superior
izquierda de la etiqueta El texto justo se reproduce a la derecha y debajo
del punto de anclaje. Ampliando la subsección de
dirección de crecimiento, podemos establecer las
direcciones de crecimiento horizontal y vertical a ambas En espera de la subsección de
desplazamiento de ancla, podemos restablecerlos todos a cero, y ahora los anclajes están
centrados dentro También colocaré el
contenedor de botones de la misma manera. Pero con su
ancla vertical a dos tercios abajo, por lo que aparece por debajo
del título del juego. También puedes posicionar cualquiera de
tus nodos de control manualmente, pero recuerda que el uso de
anclajes hará que tus diseños más flexibles y se ajusten a
diferentes resoluciones de pantalla Agreguemos un manuscrito
al nodo Mini buttons y asignemos un
elemento de enfoque predeterminado en el inspector Al igual que nuestra escena de juego tiene
un script de administrador adjunto a su nodo raíz, también
necesitamos un script de administrador de
títulos adjunto al nodo raíz de
escenas de título. Y aquí podemos
tomar una referencia al script
de botones de menú durante la fase de listo
usando add on ready. Después dígale a los botones del menú que se
abran en la función ready. El menú ya estaba visible, pero diciéndole que se
abra, también le diremos al
elemento de enfoque predeterminado para tomar el foco. Seleccionando cada uno de
los nodos de botón, podemos agregar una llamada de
función presionada a nuestro
script de administrador de títulos para todos ellos. Por ahora, sólo nos ocuparemos del
nuevo botón de juego. El resto solo puede
imprimir cadenas para indicarnos que implementemos
estas características más adelante. El propósito del nuevo
botón de juego será cambiar nuestro juego de la escena del título a la
escena del juego. Podemos lograr esto
obteniendo una referencia
al árbol de escenas, luego accediendo a un método
llamado change scene to file. Este método toma
un argumento de cadena, que es una ruta de archivo a
la escena que queremos cargar. Las sugerencias contienen una lista de todas las escenas
de nuestro proyecto, por lo que podemos seleccionar la escena del
juego desde aquí. Alternativamente, mirando
en la pestaña del sistema de archivos, podemos encontrar la
escena del juego y hacer clic derecho, luego seleccionar Copiar ruta y pegarla como texto. Pero recuerda que las cadenas deben ir
entre comillas. Hasta el momento, hemos estado usando el botón Ejecutar escena
actual
para probar nuestro juego. Pero probablemente ya hayas presionado
accidentalmente el botón de ejecutar proyecto al
menos una vez, lo que provocará la configuración de la escena principal de nuestro proyecto. Esta es la primera
escena que
se cargará cuando
iniciemos el juego, que debería ser esta
escena, la escena del título. Si aún no lo has configurado, puedes hacer clic en el botón
seleccionar actual para establecer la escena del título como
escena principal del juego. El nuevo botón de juego agarra el
foco cuando comienza el juego. Al hacer clic en cada uno de los botones se
imprime nuestras declaraciones, y al hacer clic en el botón de
nuevo juego se cambia inmediatamente
a la escena del juego. También podemos editar la escena
principal del proyecto en cualquier momento desde la configuración del proyecto
en la
pestaña general en la aplicación ejecutar Min scene. Nuestra escena de títulos
ahora es funcional, pero no se ve muy bien. Primero, podemos agregar un
fondo splash usando un nodo de texto. Vamos a llamarlo fondo. En la sección de diseño, establecer los anclajes
preestablecidos en naufragio completo, asegurará que el fondo
cubra toda la ventana Podemos editar la propiedad de textura para mostrar cualquier imagen de
dos D que queramos. Usando las propiedades
en el inspector, podemos alterar cómo
se muestra la imagen para que no mantenga su tamaño nativo
o encaje dentro los puntos de anclaje ya sea
por ancho o alto. También podemos especificar que
la imagen debe mantener su relación de aspecto para evitar la imagen se estire
para que se ajuste a la ventana. Por último, lo clasificaremos en la
parte superior de las escenas de los niños, así se dibuja primero,
detrás de todo lo demás. A continuación, echemos un vistazo a las propiedades de
los
nodos de etiqueta de título. La mayoría de los
ajustes de etiquetas tienen que ver con la justificación
y el envoltorio, lo cual no es realmente
relevante para nuestro título. Los ajustes que queremos cambiar
están bajo las propiedades heredadas del control en
la sección de anulación de tema. Aquí podemos ajustar
el color de la fuente. Agrega una sombra o un contorno que
también se puede ajustar en la subsección de
constantes Podemos cambiar el tamaño de fuente, y también la fuente en sí. He descargado un par de fuentes
gratuitas de dafont.com. Asegúrate de que las fuentes que uses
en tus juegos sean gratuitas. Da font muestra la licencia
de sus fuentes encima
del botón de descarga. Esto funciona bien para
nuestro título de juego, que está destinado a destacar, pero editar
propiedades individuales esta manera para todo en
nuestro proyecto sería tedioso Para editar nuestros botones de menú, deberíamos
crear un tema común para usar a lo largo
del proyecto del juego. Seleccionando el nodo
contenedor de botones. Esta vez, ampliar
la sección temática. El campo temático está vacío. Al hacer clic en él, podemos seleccionar nuevo tema para crear un nuevo
recurso temático para nuestro proyecto. Al hacer clic en el recurso temático
se agregará una nueva pestaña
al panel inferior de nuestra
ventana, un editor de temas. El editor de temas
contiene una vista previa de una variedad de
diferentes nodos de control, un panel, jugable,
diferentes tipos de botones, alterna, desplegable, selector de
color, campos de texto, barras de
desplazamiento, separadores,
pestañas Todo usando el tema por defecto
que es proporcionado por Gadot. Mirando hacia atrás en nuestro
recurso temático en el panel del inspector, podemos editar la fuente y el tamaño de
fuente predeterminados para todo
en nuestro tema. Cambiemos la fuente
y ajustemos el tamaño. Podemos ver los efectos tanto en la vista previa como en nuestros
botones de nuestro menú de títulos. Esto no afecta a
la etiqueta del título del juego ya que el tema no
se ha aplicado a ese nodo. Sólo se ha aplicado al contenedor
de botones de menú. Incluso si el tema se
aplicara al nodo title,
las anulaciones de tema que
acabamos de aplicar se
usarían en su lugar Los botones heredan su tema de su padre
en el árbol de escenas En el editor de temas,
podemos agregar nuevos ajustes para cualquier nodo de control haciendo
clic en el botón Más. Dado que nuestro menú contiene
solo nodos de botón, agreguemos ajustes
para los nodos de botón. Hay muchos
ajustes diferentes para ajustar la fuente y los colores de los iconos durante
los diferentes estados del botón. Predeterminado, desactivado,
enfocado, cercado, cercado presionado y presionado, así
como un color de contorno Antes de que podamos ajustar
cualquiera de estos ajustes, necesitamos agregarlos al tema haciendo clic en el
botón más al lado de ellos. Ajustando cualquiera de estos ajustes, podemos ver sus
efectos en la vista previa, incluidos los estados de desplazamiento, enfoque y pulsación haciendo
clic en los botones Hay
ajustes adicionales y otras pestañas para
ajustar constantes, fuentes y tamaño de fuente La fuente y el
tamaño de fuente ya han sido establecidos por el propio
recurso temático. No necesitamos
ajustarlos aquí. También podemos cambiar el aspecto
del propio botón
usando cuadros de estilo. Cada uno de los estados de botón
se puede asignar a una caja de estilo
diferente. Empecemos con lo normal.
Al hacer clic en el botón más, podemos usar una caja de
estilo plano para simplemente crear un
rectángulo plano de color para el botón, o podemos usar una caja de estilo de
textura para usar una imagen importada de dos D. Al hacer clic en el
recurso de cuadro de estilo se abrirá en el panel inspector
donde podremos poblar el campo de textura con
un archivo de imagen de dos D. Es posible que desee agregar algo de relleno a los
bordes del botón, que el texto del botón no se superponga con los
bordes de la imagen. Ampliando la sección de
margen de contenido, podemos ajustar el
tamaño de los márgenes para que se ajuste mejor al texto
dentro de la imagen. Añadiendo un cuadro de estilo presionado, podemos cambiar la textura que se usa para dibujar el botón. Copiar los mismos ajustes se elimina
para el cuadro de estilo normal, pero aumentando el relleno superior para hacer que el texto se mueva
hacia abajo cuando se presiona. Agregar más cuadros de estilo para estados
enfocados y hover
deshabilitados Es posible que no tengas
diferentes texturas para todos tus diferentes estados de
botón. Pero aún podemos crear nuevas cajas de
estilo para estos estados. Usa la misma
textura y configuración normales, pero agrega
modulación de color para crear una apariencia diferente para
el botón en este estado. Podemos multiplicar los
colores de las texturas por algo así como el
amarillo para que se
vea notablemente diferente mientras se cubre O simplemente podemos usar
otra imagen en un color diferente
para enfatizar el enfoque. Cuando se desactiva, podemos multiplicar los colores Alfa para
agregar algo de transparencia. Podemos probar todas estas cajas de estilo
diferentes fácilmente desde la vista previa
en el editor de temas. Ahora el
menú de permanecer se ve mejor, también
editemos el menú Pausa en la escena del juego para que coincida. En lugar de agregar un nuevo tema
al menú Pausa y
rehacer todas las ediciones, podemos volver
a la escena del título,
encontrar el recurso y
hacer clic en el Seleccione Guardar y guardar el tema en nuestra carpeta de
recursos de proyectos. Ahora, en la escena del juego, podemos asignar este tema
al menú de pausa, y los botones
se
actualizarán automáticamente para que coincidan con
el nuevo tema. Abriendo el guión del manager del juego. Cuando el jugador presiona
el botón de salida, también
podemos cambiar
a la escena del título. Ejecutando nuestro juego,
empezamos en la escena del título. El nuevo botón de juego
cambia a la escena del juego. Pausar el juego y seleccionar salida vuelve a la escena del título Ahora tenemos una
escena de título y podemos cambiar de un lado a otro
entre nuestras dos escenas. En la siguiente lección, suavizaremos transición de
la escena
al desvanecerse a negro Te veré en la siguiente lección.
4. Transición: Hola, amigos. En
la lección anterior, creamos una escena de título y nos
conectamos a la escena del juego. En esta lección,
hacemos que la transición más suave con un desvanecido visual. La mayoría de los juegos comienzan
con una pantalla negra. Agreguemos un nuevo nodo
a nuestra escena del título, un nodo destrozado de color Vamos a llamarlo Fade.
En el Inspector, podemos establecer la
propiedad de color en negro. Luego ponga los preets de anclaje en naufragio
completo para cubrir toda
la ventana Cuando comience el juego,
podemos
desvanecer suavemente este objeto para que
sea completamente transparente, revelando la
escena del título detrás de él. Incluso cuando un objeto en
nuestra escena es transparente, los eventos
del mouse solo se
activarán en lo
primero que golpeen, que significa que mover el
mouse o hacer clic en nuestros botones ha sido
bloqueado por el fade. En las propiedades heredadas del control, en la sección del mouse, podemos cambiar la
configuración de filtro de nuestro fade para ignorar, lo que permitirá que
los eventos del mouse pasen por el fade a
los objetos detrás de él. Ahora los botones funcionan de nuevo
con el ratón. Mientras estamos trabajando en
nuestra escena en el editor, sería mejor
poder ver todo lo demás. Me gustaría que el fade
sea visible por defecto. Antes de adjuntar un script, comencemos a organizar
nuestros scripts en carpetas
más específicas
creando una subcarpeta llamada UI Podemos mover el manuscrito a
la subcarpeta ya que se
utiliza para controlar los elementos de la interfaz de usuario Pero al
mover recursos así, asegúrate de que las escenas que lo
usan estén abiertas primero. De lo contrario, los archivos de escena
podrían perder la pista de ellos. Si eso sucede, simplemente mueva el recurso de regreso a
donde estaba originalmente y asegúrese de que
las escenas que utilizan el recurso estén abiertas
antes de moverlo. Ahora podemos adjuntar un script
al nodo Fad y
usar el navegador para ordenarlo
en la carpeta de scripts de la interfaz A diferencia de nuestro manuscrito, que podría ser relevante para
cualquier nodo de control, ya que solo estaba afectando a
la propiedad visible, que se hereda del control Este script FAD estará alterando la propiedad de color
del nodo naufragado de color, lo que solo será utilizable por los nodos de
color o sus Empecemos en la función
ready. Establecer la propiedad visible de la fa verdadera cuando comienza la
escena por primera vez, haciendo que la ventana sea
completamente negra. Entonces podemos declarar una
función pública llamada a despejar. A diferencia de la mayoría de las funciones
en la mayoría de los scripts, esto es algo que
tendrá que suceder gradualmente con el tiempo,
abarcando varios fotogramas Podemos lograr esto con un
nuevo tipo de variable, una tween. Esta puede ser una variable privada, solo aplicable a
este script localmente, y solo lo nombraré
tween por simplicidad El nombre de esta
clase proviene de las palabras inglesas en el medio, ya que se usa
con mayor frecuencia para encontrar puntos entre un
punto de partida y un punto final. Podemos crear una pregeneración en cualquier momento
llamando a un
método incorporado, create tween llamando a un
método incorporado, create tween Este método devuelve
un objeto tween, que podemos asignar a
nuestra variable para almacenarlo. Una tween es una clase compleja
con una variedad de métodos, pero la que queremos usar
se llama propiedad tween, que requiere
varios argumentos El primer argumento es el nodo al que
va a afectar esta preadolescentes, que es el mismo nodo al que está asociado
este script Podemos obtener una referencia a este nodo usando
la palabra clave self. El siguiente es la
propiedad node que queremos cambiar, una ruta de propiedad como una cadena. Estaremos cambiando la propiedad
de color de este nodo. Si no está seguro del camino de
la propiedad, podemos buscar en el inspector Al pasar el cursor sobre cualquier propiedad nos
mostrará la
ruta de la propiedad para acceder a ella, o podemos hacer clic derecho para copiar la ruta de la propiedad y
pegarla como texto El siguiente argumento es
el valor final en el que queremos que se establezca
esta propiedad una
vez finalizada la preadolescentes Dado que la propiedad es de un color, estaremos configurando esto a un color
personalizado que definiremos. Digámoslo claro. Y la última propiedad es la cantidad de tiempo que durará
la preadolescentes, medida en segundos,
expresada como un flotador Vamos a ponerla en 1
segundo por ahora. El valor del claro será algo que podamos
definir pero que nunca cambie. En lugar de declarar una variable, podemos definir una constante
usando la palabra clave constant Nombrarlo claro de tipo color. Es convencional nombrar
constantes en mayúsculas. Después asigne el valor de
esta constante como un color. Escribiendo el nombre de la clase
seguido de corchetes, accede a un método constructor, lo que nos permite
construir el color especificando todas las propiedades
requeridas. Un color se define
por cuatro flotadores, rojo, verde, azul y
Alpha para transparencia A como números 0-1. Nuestro color claro
simplemente será cero, rojo, cero, verde, cero, azul y cero Alpha, haciéndolo negro, pero también completamente transparente. Llamar a nuestro método de dos
claros hará la
transición de la propiedad
de color de su valor actual, que es negro para borrar durante
la duración de 1 segundo. También podemos escribir
otra función a negro para hacer lo contrario. Sin embargo, no necesitamos
definir una constante para negro ya que la
clase de color ya tiene una. Podemos acceder a ella a través del nombre de la
clase usando un punto, y podemos ver que hay una gran cantidad de colores
predefinidos. El que queremos
ahora mismo es negro. El negro se define como cero, rojo, cero, verde, cero,
azul, pero uno Alfa. Cambiemos al guión del
administrador de títulos por un momento y tomemos una referencia al FAD Noe durante la
fase de preparación usando at ready Cuando comience la escena,
podemos decirle la nota
a Fate para despejar. Entonces antes de cambiar
a la escena del juego, podemos decirle que se desvanezca a negro. Pero el proceso de desvanecimiento
a negro lleva tiempo, y esta función se ejecutará en un fotograma
cambiando inmediatamente a la escena del juego, así que no veremos que suceda Podemos decirle a esta
función que haga una pausa y espere una señal
antes de continuar, usando una nueva palabra clave, un peso. Un peso requiere una
señal a esperar, que podemos regresar de
la función fade a black. De vuelta en el script FAD, podemos especificar un tipo de retorno para nuestras funciones
antes de los dos puntos
agregando un guión una flecha,
seguido de un En este caso, queremos
devolver una señal. La clase Tween contiene
una señal que se emite automáticamente cuando finaliza
la Tween, por lo que podemos devolverla Ahora el encargado del título
esperará a que el nodo FAD se desvanezca a negro
antes de cambiar de escena Butt's también copia este formato
en la función de dos clear. A pesar de que está
devolviendo una señal, el encargado del título
no necesita
aceptar esta devolución ni
hacer nada con ella. En este caso, se
iniciará la preadolescentes y el resto de la función
procederá de inmediato Podemos copiar este nodo FAD
en la escena del juego. Después edita el script del
manager del juego para obtener una referencia al nodo FAD
durante la fase de preparación Se desvanecen para despejar cuando comienza la
escena por primera vez, y esperan desvanecerse a negro antes de cambiar a
la escena del título. Pero esta
función al salir presionada, se está llamando mientras
el juego está en pausa Por lo tanto, el nodo F también
se pausa y no tendrá como resultado
su color Podemos permitir que el nodo FAD procese
siempre para moverse Pero también
sería una buena idea volver a pausar el juego antes de
cambiar de escena Vamos a probarlo. Ahora el juego comienza a partir de una pantalla negra que se
desvanece en nuestra pantalla de título, al
presionar el nuevo
botón del juego se desvanece a negro, cambia a la escena del juego,
que vuelve a aparecer pausa y presionar el botón de
salida, se desvanece a negro, cambia a la escena del título, que también se desvanece nuevamente Sin embargo, hay un parpadeo entre
cambiar de escena. Podemos editar la configuración del proyecto en entorno de renderizado, y cambiar el
color predeterminado a negro. Esta es una transición mucho más
suave que
cambiar de escena inmediatamente, y si nuestro juego
se vuelve lo suficientemente grande como para requerir tiempos de carga más largos, podemos cambiar esto
a una pantalla de carga. Sin embargo, puede haber
algunos problemas iniciar una preadolescentes antes de que termine la
anterior De vuelta en el script FAD, podemos verificar si la tween
existe comparándola con null En el script de Godo, podemos hacer esto implícitamente con solo Si existe, también
comprueba si está funcionando. En ese caso, deberíamos matar a los prejóvenes antes de
crear uno nuevo Esto evitará cualquier posibilidad de que existan múltiples preadolescentes e
interfieran entre sí, ya que la preadolescente más reciente simplemente
se hará cargo Nuestras dos funciones claras y dos
negras son muy similares con solo el
valor de color diferente entre ellas. Será una buena práctica
declarar aquí una función
privada. Vamos a llamarlo dos colores, y aceptar un color
como parámetro. Entonces podemos hacer todo
esto sólo una vez. Pasar el color al método de propiedad
twin, y tener las dos funciones clear
y dos black llamadas esta
función de dos colores en su lugar. Pasando la
señal de retorno a través de
la cadena o los gerentes
pueden esperarla. De esta manera, realizar cualquier cambio este comportamiento requerirá solo cambiar un bloque de código. Es posible que desee tener el
guión para que sea más adaptable. Exportemos una variable
durante la duración de la preadolescentes y le asignemos un valor
por defecto de 1 segundo Luego reemplace el
argumento de 1 segundo con nuestra variable, y ahora el tiempo de la
se puede ajustar fácilmente
en el inspector. Veamos cómo se ve el FAD con la duración de 2 segundos. Podemos hacer esto aún
más flexible al permitir que las dos funciones clear y dos
black acepten un parámetro opcional para
anular la duración especificada. Llamemos al parámetro
duration sin guión bajo, haciéndolo diferente
de la variable que sí tiene un guión bajo Y asignarle un valor predeterminado de la duración
de nuestro guión bajo. Entonces necesitamos pasar este valor a la función de dos colores. Y agrégalo a la
lista de parámetros. Luego use el parámetro en el método de propiedad tween
en lugar de nuestra variable Nuestros scripts de administrador aún
pueden usar estas funciones sin
especificar una duración. En ese caso, el valor
exportado será. Pero también pueden especificar una duración diferente
y usar eso en su lugar. Hagamos que la duración exportada sea
de 1 segundo, pero permitamos que el
administrador del título lo anule y se desvanezca durante una duración
de 2 segundos en su lugar. Ahora tenemos una transición
visual más suave entre nuestras dos escenas. En la siguiente lección,
pasaremos información entre escenas. Te veré en la siguiente lección.
5. Autocarga: Hola, amigos. En
la lección anterior, difuminamos nuestras escenas dentro y fuera
para una transición más suave En esta lección,
agregaremos nodos adicionales
al árbol de escenas que son
accesibles desde cualquier escena. Si ejecutamos nuestro juego y cambiamos
al árbol de escenas remoto. Podemos ver que la escena
árboles raíz tiene sólo un hijo, que es la escena del título. Al cambiar a
la escena del juego, la escena del título se elimina
del árbol y se reemplaza
con la escena del juego. Si queremos pasar
información entre escenas, podemos agregar hijos adicionales al nodo raíz
del árbol de escenas, que permanecerá ahí
mientras el juego esté funcionando. Estas se llaman cargas automáticas, y podemos crearlas
escribiendo guiones. Primero, agreguemos una carpeta
especial dentro la carpeta de scripts para contener
nuestros scripts de carga automática. Después haga clic derecho sobre esta
carpeta para crear un nuevo script. El propósito del script
será guardar la carga, y proporcionar acceso a los datos. Me gustaría nombrar
este archivo de script. Dado que esto no representa nada que deba dibujarse, puede
heredar del nodo Este guión
tendrá dos variables que contienen
conjuntos separados de información, la configuración actual del juego y el
progreso actual del jugador a través del juego. Es posible que desee tener una
tercera variable para almacenar información de
progreso asociada
con una cuenta de usuario, pero no vinculada a un espacio de guardado
específico, como desbloquear
niveles de dificultad o logros Estas variables
serán de acceso público a cualquier otro guión de
nuestro juego en cualquier escena. Al abrir la configuración del proyecto, cambie a la pestaña de carga automática. Haga clic en el icono de
la carpeta junto al campo de ruta para
abrir un navegador y luego navegue hasta
el script del archivo. El campo de nombre de nodo
se
rellenará automáticamente para que coincida con
el nombre del script. Haga clic en el botón Agregar para agregar este script a la
lista de cargas automáticas. Ahora cuando ejecutamos el juego, podemos ver en el árbol de escenas
remotas que el nodo raíz tiene otro nodo
hijo llamado file. Al hacer clic en este nodo,
podemos ver que tiene dos variables llamadas
settings y progress. Al cambiar a la escena del juego, la escena del título se elimina
y se reemplaza por
la escena del juego, pero el nodo de archivo permanece, lo que significa que podemos usarlo para pasar
información entre escenas. Pero no he
especificado un tipo para las variables
porque vamos
a querer crear nuestros propios tipos para contener colecciones
complejas
de información. Vamos a crear otra
subcarpeta en
la carpeta de scripts y ponerle un
nombre a los recursos personalizados. Después haga clic derecho para
crear un nuevo script. Vamos a nombrarlo ajustes. En lugar de heredar
de un tipo de nodo, esta vez, el script
heredará del recurso Entonces podemos crear otro. Llamemos a esto progreso. En los scripts de recursos, podemos agregar cualquier cantidad de
variables de diferentes tipos, pero deben construirse en tipos, no referencias a otras cosas. Por ejemplo, podemos almacenar
una variable booleana, que es verdadera
o falsa para establecer si
los controles de la cámara en el eje x están invertidos y otra
para el eje Y. Los números se pueden almacenar como flotadores, que permiten puntos decimales Podrías usar esto para guardar la configuración de volumen del juego
como un número entre cero, silenciado o un volumen completo Los números también se pueden
almacenar como enteros, un número que no
contiene puntos decimales, sino que puede ser positivo o negativo Podríamos usar esto en
el guión de progreso para almacenar el dinero de los jugadores o. También podemos usar cadenas para
almacenar secuencias de personajes, tal vez dando un nombre al jugador save slot o protagonista. se
puede usar algún otro tipo incorporado como También se
puede usar algún otro tipo incorporado como
vectores o colores? Las colecciones de cualquiera de
estos tipos también
se pueden almacenar en una
matriz o en un diccionario, como una matriz de booleanos para contener si el jugador
ha completado
o no cada nivel Cada uno de estos
tipos de variables tiene un valor predeterminado. Los booleanos son falsos, los enteros
y los números son cero. Las cadenas, las matrices y los
diccionarios están vacíos. Cuando se crea un recurso, automáticamente
llamará a una función
incorporada nombrada en él. Corto f inicializar. Anulando esta
función, podemos especificar los valores predeterminados
que
queramos para nuestras variables Quizás iniciando nuestro
ajuste de volumen como 0.5 para uno, o dándole al protagonista
un nombre por defecto. Para crear nuestro recurso,
necesitamos especificar un nombre de clase, que se realiza en la
parte superior del script. Por lo general, en la
misma línea que la palabra clave extends. Con la palabra clave class name, podemos darle a esta
clase de recurso un nombre que será usado por otros scripts para referirse
a esta clase como un tipo. Podemos nombrar esta configuración de
clase con una S mayúscula, y esta, progresar con una P.
Convencionalmente, las clases se nombran en caso Pascal con la primera letra de
cada palabra en mayúscula De vuelta en el script del archivo, ahora
podemos especificar los tipos de nuestras variables como
ajustes, y progreso. Por ahora, podemos simplemente crear estos recursos dentro de
la función ready. Usando el nombre de su clase
seguido del punto Neu. Esto también activará
la función init, inicializando las variables
dentro del recurso Ejecutando el juego, podemos ver estas variables en el árbol de escenas
remoto. Haga clic en ellos, vea y edite los valores de
sus propiedades. Cambiemos sus
valores alrededor. Cambia a la
escena del juego y confirma que los cambios permanecen
durante la transición de escena. Cualquier script en nuestro juego
puede acceder fácilmente a estos recursos gracias
a la carga automática del archivo. Abramos el guión del brazo de resorte que se encarga de
girar la cámara. Su comportamiento actual es el
uso de ejes x e y invertidos. Pero ahora tenemos variables en nuestro recurso de configuración que
deberían activarlo o desactivarlo. Tenga en cuenta que rotar
la cámara alrededor del eje x es una rotación
vertical, que los jugadores entenderán
como la rotación
y, y que rotar alrededor del eje Y es la rotación horizontal
o la rotación x. Podemos escribir una
sentencia if antes de
cada uno de estos
cálculos para verificar configuración de puntos de
nuestro archivo para ver si la
variable de inversión apropiada es verdadera o falsa. Después multiplica la
fórmula por uno negativo, si es falsa, para cambiar el comportamiento invertido
a no invertido. Esto significa tener casi la misma fórmula copiada dos veces con sólo una diferencia menor de ser multiplicada por uno
negativo o no. Podemos hacer esto de manera más eficiente
usando una re declaración. Volviendo primero al formato
original, luego multiplicando por entre paréntesis,
uno, si la configuración del archivo invierte else, uno negativo Y repitiendo esto con
la rotación horizontal, cambiando y a x.
Las declaraciones
de giro son efectivas en cualquier momento
que desee cambiar valor basado en una condición de intimidación
simple L et's pruébalo. Inclinando
el stick analógico derecho, las cámaras x rotación
ya no se invierte por defecto, sino que la rotación y se invierte Al abrir el árbol de escenas remoto, podemos acceder y
editar los ajustes. Y volviendo a la simulación, los controles de la cámara
son ahora opuestos. Ahora hemos creado
algunos de nuestros scripts que heredan de
diferentes tipos de notas y también de recursos Pero también podemos escribir scripts que heredan de nuestras
propias clases personalizadas Echando un
vistazo rápido al script FAD, combinamos el comportamiento de dos claros y dos negros
en una sola función combinada Podemos combinar comportamientos similares de diferentes scripts
de manera similar, creando una súper clase
y usando herencia para permitir que diferentes scripts accedan
al mismo comportamiento. Vamos a usar nuestros
scripts de manager como ejemplo, ya que ambos ahora usan
la transición FAD Sería una buena idea poner estos en una carpeta separada de
scripts. Llamémoslo gerentes. Mover tanto al administrador
del juego al administrador de títulos a esta carpeta. También podemos crear
un nuevo tercer guión, llamémoslo scene Manager. En la escena Guión Manager, le
daremos al guión un
nombre de clase en caso de campana de pase. Cada vez que le des un nombre de clase a un
script, tendrás que guardarlo antes de que
el motor lo reconozca. Entonces en el juego Manager
y title Manager scripts, podemos tener estos extender el comportamiento de la clase Manager
escena. Ahora, cualquier cosa que pongamos en el guión de
Scene Manager
será utilizada tanto por el
manager del juego como por el encargado del título. Movamos la variable FAD al guión del Gestor de escena Entonces en el juego
y los administradores de títulos, ya que heredan
la variable Fad de la clase de manager de escena, no se
les permite declarar otra variable
del mismo Podemos eliminar la variable, ya que ahora se hereda
de la clase scene manager. Pero la ruta del nodo es diferente entre la escena del juego
y la escena del título. Podemos sortear esto fácilmente
exportando la variable
en lugar de usarla en on ready. Tendremos que asignar
el valor de fade en ambas escenas en
el panel inspector. Si la variable
no aparece, posible
que deba cerrar y volver a abrir Godot para que funcione la
herencia de clases Las funciones también se heredan, pero las subclases pueden redefinir funciones
heredadas
anulando Es por ello que cada clase que
hemos escrito con una función re o process
tiene un icono azul junto a ella, ya que está anulando la definición heredada que ya existe en
la clase node Si nuestra clase de manager de escena tiene una función lista que le dice
al fade que se desvanezca para borrar, este comportamiento
será heredado
tanto por el manager
del juego como por el encargado del título. Podemos eliminar esta función
del manager del juego, pero el encargado del título
también está abriendo el menú. Al permitir que el
administrador de títulos anule la definición de función ready heredada del Administrador de escenas, no
necesitamos
anularla toda. Nuestras subclases pueden acceder a la definición heredada de una función usando
la palabra clave super Dado que el administrador de títulos hereda
de Scene Manager, Scene Manager es la superclase Al llamar a super punto listo, le
estamos diciendo al
Fade que se desvanezca para despejar. Pero luego también le decimos al
menú que abra también. La estructura de
las superclases y herencia
serán más útiles si tenemos más gestores de escena o comportamientos más comunes
de todos nuestros gestores de escena No necesitamos
reescribir el mismo código través de múltiples scripts Ahora tenemos un
nodo cargado automáticamente en nuestro intento de escena que puede almacenar información sobre la configuración
del juego y el progreso. En la siguiente lección,
agregaremos música de fondo a nuestro juego. Te veré en la siguiente lección.
6. Música: Hola, amigos. En
la lección anterior, creamos nodos
autocargados que
se pueden usar para pasar información
entre diferentes escenas. En esta lección agregaremos música de
fondo que puede cambiar con cada escena de nuestro juego. Para esta lección, estaré usando paquete de música de
Barn hecho por Eric the Funny Barn
en itch dot IO. Sea cual sea la música de fondo que elijas usar para tu juego, asegúrate de que esté
diseñada para hacer loop. Dado que los archivos de audio
suelen ser muy grandes, te
recomiendo
importarlos solo a tu proyecto a medida que
decidas implementarlos. Una vez que los haya importado y ordenado en una carpeta de música, seleccione una y cambie el
panel de estafa al panel de importación. Es posible que deba editar
la configuración de importación de sus archivos de audio antes de
que puedan realizar un bucle. Dependiendo del tipo de archivo, la configuración de bucle
puede ser una casilla o un menú desplegable con
múltiples opciones En ese caso, querrás
cambiarlo a un ciclo lineal. Empecemos abriendo la escena del título y
añadiéndole un nuevo nodo. En el nodo reproductor de flujo de audio. Asegúrese de no usar las
dos variantes d o tres D, ya que estas están destinadas a simular sonidos
auditivos en dos
D o tres D espacios. El nodo
reproductor de flujo de audio normal no se verá afectado por la proximidad o
cualquier otra cosa en la escena, y solo reproduzca el audio tal cual. Podemos establecer la propiedad de
flujo de audio en el inspector a una
de nuestras canciones importadas. Echando un vistazo a las propiedades de las
notas del reproductor de flujo de
audio en el inspector, notarás que el volumen
se mide en decibelios, a flote con un valor predeterminado de cero que va desde 80
negativo Es importante tener
en cuenta que este número no escala mentiroso. Aumentar de 1 decibelios a 2 decibelios no es el doble Pero no te preocupes si no
entiendes cómo funcionan los
decibelios porque
no los estaremos usando directamente. Podemos decirle al nodo reproductor de
flujo de audio que se reproduzca automáticamente cuando comience
el juego ejecutar el juego, la música
comienza a todo volumen, y cuando hacemos la transición a la escena del juego, se
detiene repentinamente. Combinando lo que hemos aprendido
en las dos lecciones anteriores, podemos crear un reproductor de audio
persistente para reproducir música de fondo, y también desvanecer la música
y no sin problemas. Dado que la música de fondo
suele ser algo
que los juegos
tendrán en cada escena, tendría sentido
que hubiera un nodo autocargado que pueda permanecer
en el árbol de escenas permanentemente para manejarlo. Así podremos eliminar el nodo
reproductor de audiotrem en nuestro árbol de escenas Y crea un nuevo script
en la carpeta auto lodes. Vamos a llamarlo música. Este nodo
autocargado puede heredar del reproductor
de flujo de audio, dando al nodo de música acceso a todas las propiedades
y métodos de un nodo reproductor de flujo de audio Como no podemos acceder a
las propiedades de un nodo autocargado
en el inspector, tendremos que establecer sus valores de propiedad
predeterminados en la función scripts ready. Me gustaría que el volumen comenzara en su valor más bajo posible, que es negativo 80 decibelios Pero también podemos usar el
volumen lineal si queremos, que es más fácil de entender para la mayoría de la
gente. Usando una función incorporada, lineal a dB,
abreviatura de decibelios, que convertirá una
escala lineal en escala de decibelios, permitiéndonos establecer el volumen
a cero en términos lineales, que significa que Si quieres que la música también reproduzca mientras el juego está en pausa, tendremos que cambiar el modo de
proceso de este nodo Usando las sugerencias,
podemos
configurarlo en nodo, punto, proceso siempre. Gracias. Bien. Pensando primero
en cómo queremos que se use
este nodo, probablemente solo necesitemos
dos funciones públicas. Uno para tocar una pista de música
y otro para desvanecerlo. La pista de reproducción tomará una pista como parámetro de
tipo flujo de audio. Mientras que fade out no
requiere ningún parámetro. En la función Reproducir pista, podemos acceder a cualquier propiedad heredada del nodo reproductor de
flujo de audio, incluido el stream que
se está reproduciendo actualmente, que tiene un
valor predeterminado de null. Podemos establecer el valor de stream a la pista que
queremos reproducir. Entonces dígale al reproductor de
flujo de audio que reproduzca. Pero el volumen es
actualmente inaudible. Vamos a usar una preadolescentes
como hicimos con el desvanecimiento visual para
ajustar gradualmente el volumen a lo largo del tiempo, declarando una nueva variable de tween
en la parte superior del script Primero verificaremos si la
preadolescentes ya existe, y si existe, verificaremos si ya se está ejecutando Y si es así, mátalo. Entonces podemos crear una nueva
preadolescente. Y entre una propiedad Accediendo a este nodo en sí, la propiedad volume,
cambiando gradualmente a file dot setting dot volume a lo largo de
la duración de 1 segundo. Pero recuerda que el volumen
no escala linealmente, ya que se mide
en decibelios En lugar de interpelar la propiedad
volume directamente, podemos interponer un método El método Tween no
requiere una referencia de nodo, por lo que podemos eliminar
el primer argumento La ruta de propiedad es
ahora un método callable. Vamos a escribir una función
llamada set linear volume, que toma un parámetro float
del volumen lineal. Esta función establecerá
la propiedad volume después de convertirla de
lineal a decibelios Podemos usar esto en nuestra
función ready para lograr consistencia. Y también usa esto como nuestro método callable en
la llamada al método tween Tenga en cuenta que cuando se usa
un método como cable, no tiene
corchetes al final. Método también necesita no
sólo un valor final, sino también un valor inicial, ya que esto ya no es una propiedad
del nodo. No tiene forma de saber
cuál es el valor actual. Los valores inicial y final son en realidad un
argumento que
se pasará al
método invocable, el volumen lineal Usando la función
incorporada opuesta, podemos convertir decibelios
a lineales para cambiar el volumen actual de decibelios en
un volumen lineal como valor inicial Podemos especificar que
el volumen lineal de nuestra música se
tweened desde cualquiera que sea el volumen que esté actualmente hasta el
archivo que configurando detener el
volumen a lo largo de 1 segundo También devolvamos la señal de
tween terminada. Entonces la función fade out
querrá hacer exactamente
lo contrario de esto. Tuiteando el volumen lineal
desde lo que sea que esté a cero. Esperando
a que termine la preadolescentes, deteniendo la reproducción del nodo y volviendo a establecer la
pista en nulo Como hicimos con el color Fade, podemos combinarlos en
una sola función privada. Vamos a llamarlo volumen. Tomando como parámetro únicamente el
volumen lineal objetivo. Enroscar el volumen desde
lo que sea que se encuentre actualmente al volumen objetivo durante
la duración de 1 segundo Y ahora tanto el desvanecimiento de entrada desvanecimiento usan la
misma función Abrir la configuración del proyecto, cambiar a la pestaña de carga automática. Podemos agregar el script de música a la lista de nodos cargados
automáticamente. En el script del administrador de escenas, podemos exportar una variable para contener la
pista de música de fondo para cada escena, ya que cada
gestor de escenas heredará la variable y podrá
asignarle su propio valor Nuestro
script de Scene Manager ahora puede
acceder fácilmente al
nodo de carga automática de música usando su nombre de nodo, diciéndole al nodo de música que reproduzca la
pista deseada para esta escena. L et's asignan una pista de música
diferente para cada una de las escenas de título
y juego. Y también asegúrate de desvanecer la música cada vez que
cambiemos de escena. Vamos a probarlo. La música de la
escena del título se desvanece, al
presionar el nuevo
botón del juego se desvanece la música,
y la escena del juego se desvanece
su propia música una pausa y presionar
la salida, se desvanece la música hacer una pausa y presionar
la salida, se desvanece la música y la
música del título vuelve a entrar Esto funciona bien siempre y cuando solo
estemos reproduciendo
una pista de música por escena y seamos diligentes en
desvanecerse siempre antes de
solicitar una nueva Pero, ¿y si quisiéramos
decirle al nodo de música que reproduzca una pista diferente mientras
ya se está reproduciendo o
incluso la misma pista? Sería una buena idea agregar algunas condiciones adicionales a
la función play track. Empecemos por verificar si el nodo de música
ya se está reproduciendo. Entonces también comprueba si
lo que está
jugando el nodo es
lo mismo que lo que queremos jugar. Si ese es el caso,
entonces no necesitamos cambiar la transmisión
ni decirle que juegue. Simplemente podemos devolver la señal de
tween terminada que se devuelve
desvaneciendo el volumen Si ya
se está reproduciendo una pista diferente, deberíamos desvanecer esa pista antes de cambiar a esta. Espere a que termine el gemelo, luego proceda con el
resto de esta función. Tenga en cuenta que esto
ahora estará realizando dos ejecuciones de volumen de moda, cada una dentro de 1 segundo de duración Tomará 2 segundos para
cambiar de pista como resultado. Hagamos esto más flexible
exportando la duración
como hicimos con el FAD y darle un valor
predeterminado de 1 segundo Luego permita que las funciones play track y fade out acepten un
parámetro opcional de duración con un valor predeterminado de la variable
exportada. Pasar el parámetro duration a la función de volumen de fundido. Podemos usarlo en la llamada al
método tween como argumento. Echando un vistazo a los guiones del juego
y del administrador de títulos, O en juego nuevo presionado y salir presionado las funciones se
ven bastante similares ahora. Escribamos un método
heredado para cambiar escenas en nuestro guión de
escena Manager. Nombrado escenas de cambio. Podemos decirle a la
música que se desvanezca. Espera
a que el Fade se desvanezca a negro, unpause el juego
si está en pausa, luego cambia la escena
del árbol a un archivo Pasar la
ruta del archivo como argumento. Para obtener los
resultados que estamos esperando, tendremos
que asegurarnos de que la señal que se espera sea
la de mayor duración La declaración wait también debe ser la última si queremos que todos los preadolescentes
sucedan en paralelo Si por alguna razón, necesitas
reorganizar el orden de estas declaraciones para
que la señal que se espera no sea la que se devuelve, también
puedes almacenarla en una variable y esperarla
en una línea diferente Ahora, el encargado del título
puede hacer todo esto
llamando a su método heredado de cambio de escena, pasando el
camino de las escenas del juego como argumento. De igual manera, el manager del juego
también puede hacer esto cambiando
a la escena del título. Además, no olvides que
las subclases siempre pueden anular estos comportamientos si quieres que una escena específica
se comporte de manera diferente Ahora tenemos
música de fondo que se
desvanece suavemente dentro y fuera con
cada escena de nuestro juego En la siguiente lección, agregaremos un menú de configuración para
cambiar la configuración del juego. Te veré en la siguiente lección.
7. Ajustes: Hola, amigos. En
la lección anterior, agregamos música de fondo
que se desvanece suavemente dentro y fuera. En esta lección, agregaremos un menú
de configuración a nuestro juego. Empecemos en la escena del título. A diferencia de los botones y
menús que hemos creado hasta ahora, que simplemente están flotando
frente
a todo, preferiría que la configuración del juego preferiría que la configuración del juego se encerrara dentro de un panel. Hay dos notas de
control diferentes que podemos agregar a nuestra escena, que
se comportan de manera diferente. Un panel es solo una
ventana básica que podemos redimensionar como queramos y reorganizar a sus hijos de cualquier
manera Un contenedor de panel se
redimensionará automáticamente para
encapsular sus hijos, manera similar a un contenedor de caja horizontal o
vertical Ambos tienen ventajas
y desventajas. Me gusta usar un contenedor de panel para ahorrarme el
tiempo y el esfuerzo de dimensionar y reorganizar los nodos
secundarios mientras estoy construyendo
mi interfaz de usuario Pero podría cambiar
a un panel si quiero más flexibilidad
a la hora de pulir el proyecto
terminado. Dado que nuestra clase de configuración
tiene algunas variables booleanas. Podemos agregar ya sea una casilla o un botón de verificación
para cada variable, permitiendo al jugador establecer su valor en true
o false en consecuencia. Agreguemos uno para cámara invertir x y otro para cámara invertida. Voy a añadir uno de cada uno,
para que pueda ver cómo se ven y decidir
cuál me gusta más tarde. El ajuste de volumen
es una variable flotante, que a menudo se controla
en los menús mediante un control deslizante. Dado que un control deslizante forzará
inherentemente un valor mínimo
y máximo Cada una de estas configuraciones también
necesitará un nodo de etiqueta para decirle al
jugador para qué sirven. Al igual que hemos utilizado contenedores de caja horizontales y verticales para organizar los nodos automáticamente. También podemos usar un contenedor de
cuadrícula para organizar
automáticamente los
nodos en un patrón de cuadrícula. La propiedad de solo nodos de cuadrícula es el número de
columnas en la cuadrícula. Las filas se
agregan y eliminan automáticamente
del contenedor de cuadrícula
para acomodar el número de hijos que tiene. Estableciendo esto en dos,
podemos organizar fácilmente todos los nodos de etiqueta en
la columna izquierda y los
nodos de control interactuables en el lado derecho El contenedor de rejilla comprimirá a todos sus hijos tanto
como pueda. Pero podemos especificar
tamaños mínimos para cualquiera de ellos. Le daré al control deslizante de volumen un valor x mínimo de 100 píxeles, lo que obliga a que la columna derecha del contenedor de la cuadrícula se expanda. Ahora creo que las casillas de
verificación se
verían mejor centradas
dentro de la columna. Al expandir la sección de diseño y la subsección de
dimensionamiento del contenedor, estableceré el
valor horizontal para reducir el centro Ahora la casilla de verificación está centrada horizontalmente dentro de la columna. Y yo haré lo mismo con el botón
de chequeo. Ahora que podemos ver nuestro deslizador, echemos un vistazo a sus
propiedades en el inspector. Podemos establecer sus valores mínimo
y máximo, así
como el valor de paso, que es una distancia entre valores a los que se puede establecer el
control deslizante. Usando nuestros ajustes de
volumen lineal, el valor mínimo
debe ser cero. Un valor máximo de
uno es fino ya que uno en términos lineales
equivaldrá a 0 decibelios Pero también podemos permitir que el
volumen vaya por encima de esto. Ya que sabemos que el valor
máximo de decibelios del
nodo reproductor
de flujo de audio es de 24 decibelios En realidad podemos escribir
funciones integradas en este campo, usando db a lineal, pasando 24, obtenemos 15.849 es
el valor máximo real Pero esto puede provocar una
disminución en la calidad del audio. Establecer el volumen
lineal máximo uno está bien para la mayoría de los casos. Algo tan fluido como el volumen
generalmente se puede ajustar en
un grado muy pequeño. Como mi deslizador es de 100 píxeles, estableceré su valor de paso 0.01 con cada píxel representando
un cambio de 1% en el volumen. También necesitaremos una
etiqueta de título para este menú. Y un botón que lo cierra. Pero estos no pertenecen
como parte de la grilla. Podemos ordenar el contenedor de la
cuadrícula de título y cerrar el botón dentro de un contenedor de caja
vertical. La etiqueta del título y el botón
cerrado se estiran para que se ajusten al mismo
ancho que el contenedor de la cuadrícula. Centraré el título usando
su propiedad de alineación. El botón se puede ajustar para que
empiece a encogerlo para ponerlo en la esquina
inferior izquierda. Encoge el centro para centrarlo o encoger el extremo para colocarlo
en la esquina inferior derecha. Si no quieres
usar estos contenedores o los encuentras demasiado restrictivos, siempre
puedes usar un panel
normal y manual
posicionamos cada uno de los nodos hijos para obtener el arreglo que deseas Podemos reutilizar el recurso temático para nuestro
menú de configuración si queremos, pero es posible que desee usar
diferentes estilos de botón para diferentes partes
de su juego. En ese caso, puede
crear fácilmente un nuevo recurso temático. Simplemente agregaré una
configuración de contenedor de panel a los existentes. Cambia su
cuadro de estilo a una textura. Y darle algunos
márgenes de contenido de 16 píxeles. Las casillas de verificación están heredando
sus estilos de botón, lo que podemos anularlo
agregando una casilla de verificación
al tema y reemplazando
todas sus casillas de estilo Solo usaré cajas de estilo vacías. Después repita el proceso
para el botón de verificación. Bien. Creo que el título debería tener un
tamaño de fuente más grande que las otras etiquetas. Anularé su tamaño de fuente en la sección de anulación de tema. Ahora que he visto tanto
la casilla de verificación como el
botón de verificación y puedo compararlos
en el contexto del menú Creo que prefiero
la casilla de verificación y voy a cambiar la cámara
invertir y para que coincida Con el menú construido, vamos anclarlo al
centro de la pantalla. Ya hemos escrito
un script de menú que maneja mostrar y ocultar un nodo de control y
también puede dar foco cuando se abre
un menú. Adjuntemos esto al nodo
del menú de configuración. Y establezca su
elemento de enfoque predeterminado en el primer elemento del menú, la casilla de verificación Invertir cámara X. Pero para poder conectar las señales de
control a nuestro script, tendrá
que ser
un script
diferente a los utilizados
por otro menú. Podemos darle al
manuscrito un nombre de clase luego crear un nuevo script en la carpeta de scripts de la interfaz de usuario,
heredando del menú Vamos a llamarlo menú de configuración. Arrastrando este script al nodo
del menú de configuración, reemplaza al manuscrito Pero tendremos que repoblar
el elemento de enfoque predeterminado. En nuestro nuevo script,
necesitaremos inicializar cada uno de
nuestros nodos de control
para que coincidan con los valores que ya están dentro
del recurso de configuración Así que tendremos que tomar
referencias a cada uno de nuestros nodos de control
usando At on ready. Luego en la función ready, podemos establecer los valores a
la variable coincidente en
el recurso de configuración del archivo. Con nuestros controles de configuración ordenados en el menú
e inicializados Ahora podemos conectar señales de cada nodo de control al manuscrito
de configuración Llamar a
una función cada vez que el jugador ha
cambiado una configuración. Los nodos de casilla de verificación y botón de verificación conectarán
la señal conmutada, diciéndonos si está
establecida como verdadera o falsa Y el deslizador conectará
la señal de valor cambiado, dándonos el nuevo valor en el
que se acaba de establecer. Podemos establecer los valores
de las variables dentro de nuestra configuración de puntos de archivo
para que coincidan con cualquiera de los valores que se han cambiado usando los nodos de control. Ya que los
controles de la cámara están leyendo directamente desde los ajustes para
determinar cómo funciona. No son
necesarias más acciones para que estos
ajustes funcionen. Pero la configuración de volumen no
va a afectar automáticamente al
nodo de música. Tendremos que ajustar su configuración de
volumen manualmente. Cuando cambia la configuración del volumen, podemos llamar al volumen lineal pasando nuevo valor
como argumento. Ejecutemos esta escena
e intentemos ajustar la configuración del volumen para escuchar la diferencia inmediata
con la reproducción de música. Un juego terminado probablemente
tendrá más nodos de audio, cada uno con su propia configuración de
volumen. Es posible que no queramos
ajustarlos todos individualmente desde
el menú de configuración. Para anticiparnos a esta necesidad, podemos emitir una
señal aquí para decirle a toda
la escena que se
ha cambiado la configuración
del volumen. Entonces cualquier nodo que
esté escuchando para esta
señal puede reaccionar ante ella. En la parte superior del script, podemos declarar señales de la
misma manera que declaramos variables, usando la palabra clave signal. Vamos a cambiar el volumen de nombre. Es convencional nombrar
señales en tiempo pasado, indicando qué es lo que sucedió a lo
que
deberían reaccionar otros guiones. Similar a una función,
podemos agregar corchetes
al final de la declaración de
señal para agregarle parámetros. No sólo podemos emitir que se cambió
el volumen, sino también emitir el nuevo valor de
volumen como flotador. Al conectar esta
señal a una función, la función receptora
debe aceptar un parámetro flotante para que
coincida con la señal. A continuación, conectemos la señal pulsada de los botones
cerrados al
método de clases de menú cerrado para cerrar el menú. La mayoría de los juegos permitirán cambiar la configuración tanto de las escenas de
título como de juego. Vamos a guardar la
rama del menú de ajustes como su propia escena. A continuación, copia el
nodo del menú de configuración y pégalo en
las escenas del juego I. Siempre es una buena
idea asegurarse
de que
el nodo fade esté frente a todo lo demás, así ordenaré el menú de
configuración encima él y estableceré su
propiedad visible de false. Podemos agregar fácilmente un
botón de configuración al menú de pausa. Dado que ambas escenas tienen el menú de configuración, al
igual que el Fade, podemos exportar una variable desde
el guión del administrador de escenas, por lo que tanto el administrador
de títulos como el gestor de ganancias pueden usarla. Y en ambas escenas,
se accede
al menú de ajustes desde otro menú. Ya sea el menú
principal de escenas de título o el menú de pausa de
escenas del juego. Podemos crear una implementación de
Breadcrumbs muy simple dentro de nuestro manuscrito, por lo que cada vez que se
abra un menú desde otro menú, cerrándolo volverá
al menú anterior automáticamente En nuestro manuscrito, podemos
declarar otra variable. Vamos a llamarlo subrayado
Breadcrumb de tipo menú. Luego agregue un
parámetro opcional a la función open también
llamada Breadcrumb Si la miga de pan es otra cosa que no sea null cuando se abre el
menú, entonces deberíamos
guardarla en la variable, y cerrar ese menú
antes de abrir este Entonces cuando se cierra el menú, si la miga de pan no es nula, ese menú debería abrirse
después de cerrar este, entonces se puede volver a ajustar a Tanto el administrador de títulos como los guiones
del administrador de juegos
ahora pueden abrir el menú de configuración, pasando los botones del menú o menú de
pausa como la miga de pan Abrir la escena del menú de configuración. Asegurémonos de que el elemento de enfoque
predeterminado esté configurado y que estos nodos procesarán siempre incluso
cuando el juego esté en pausa Intentemos ejecutar el juego. Cambiar la configuración del juego y cambiar a la escena del juego. Tanto los
controles de volumen como de cámara permanecen cambiados, y podemos cambiarlos
nuevamente desde el menú de pausa. Ahora tenemos un
menú de ajustes que puede cambiar los
controles de volumen y cámara en tiempo real. En la siguiente lección,
agregaremos eventos de transición para mover a nuestro personaje
entre diferentes niveles. Te veré en la siguiente lección.
8. Salida: Hola, amigos. En
la lección anterior, agregamos un menú de configuración. En esta lección, detectaremos
cuándo el jugador entra una puerta y nos prepararemos para hacer la transición a un nivel
diferente Empecemos en
cualquier nivel que esté cargado
actualmente
en la escena del juego Para mí, esa es una habitación tres. Hay dos puertas
que salen de esta habitación. Cuando el jugador entra en
cualquiera de estas puertas, debe hacer la transición a un nivel
diferente de mi juego De manera similar a que
nuestro cuerpo de personaje está colisionando con el cuerpo estático del
piso, podemos detectar colisiones con espacio
vacío para desencadenar
que algo suceda El nodo que hace esto se
llama nodo D de área tres. Y al igual que un cuerpo de física, requiere una
forma de colisión antes de que pueda funcionar. Vamos a agregar una forma de colisión tres nodos D y
convertirlo en una forma de caja. Para que se ajuste al
tamaño de mis baldosas, lo
haré de 4 metros de
largo, ancho y alto. Vamos a cambiar el nombre del nodo
D del área tres a la transición. Luego conviértala en su propia escena
haciendo clic y
arrastrándola a la carpeta de escenas
en la pestaña del sistema de archivos Después abre la nueva
escena de transición para su edición. Me gustaría que las transiciones origen descansaran claramente
en el piso. Moveremos la
forma de colisión hacia arriba a lo largo del eje y, la mitad de su altura de 4
metros, que es de 2 metros. Para reaccionar ante
colisiones con el jugador, el nodo de transición
necesitará un guión Hagamos un nuevo
guión haciendo clic en el icono de desplazamiento. Bien. Asegúrese de que esté guardado
en la carpeta de scripts. El nombre predeterminado y
la herencia están bien. El
nodo D del área tres tiene un montón de señales
diferentes para
reaccionar ante colisiones Dado que nuestro
cuerpo de personaje califica como cuerpo físico y queremos reaccionar ante el personaje que
ingresa a esta área, la señal que queremos
es cuerpo ingresado Al conectar esta señal
al
propio nodo de transición se crea la función on
body enter, que acepta el
cuerpo que ingresó a
esta área como parámetro
de tipo nodo tres D. Podemos ver los tipos de los parámetros
en la lista de señales. Por ahora, vamos a imprimir el cuerpo
para ver nuestro trabajo de colisión. Ejecutando la escena del juego,
entrando en el área de transición, se imprime el
nombre del cuerpo del personaje
tres nota D, pero también los nombres de los nodos de
cuerpo estáticos en nuestra escena. No queremos que
cualquier cuerpo físico entre en esta área para
desencadenar una reacción, solo el personaje del jugador. Podemos comprobar si el cuerpo
es de cierta clase. O revisa el nombre del nodo para ver si este es el personaje
del jugador. Pero esas soluciones
no son muy flexibles. Un
método más fácil y limpio es asegurarse de que solo el
personaje del jugador pueda realmente chocar con esta área
usando el enmascaramiento de colisiones Primero, vamos a abrir la escena del
personaje y seleccionar el
cuerpo del personaje tres nodo D. Mirando debajo de las propiedades heredadas del
objeto de colisión tres D, expanda la sección de colisión. hay dos conjuntos de números Aquí hay dos conjuntos de números que van hasta 32. Estas son capas de colisión, que podemos usar para
controlar qué objetos en nuestro juego pueden colisionar
entre sí y cuáles no? Hasta el momento, todo en nuestro juego existe en la Capa uno predeterminada, y enmascara o choca
con solo la Capa uno Ya que la capa uno es la predeterminada y todo choca
con ella por defecto Hagamos que la capa uno
sea el terreno del juego. La forma en que estas capas
se visualizan en bloques de ocho, me gusta pensar en cada bloque como capas que se
agrupan entre sí. Las primeras ocho capas
de mi juego podrían estar reservadas para las capas del mundo
o del entorno. Nuestro personaje puede existir en
una capa única diferente. Usemos la capa
nueve como ejemplo. De esta manera, todo el
segundo bloque de capas
se puede reservar para
capas de colisión relacionadas con el jugador. Abriendo la configuración del proyecto,
en la pestaña general, bajo los nombres de capa,
podemos cambiar los nombres de cada una de estas 32 capas que existen para tres D física. Voy a nombrar capa uno terreno
y capa nueve jugador. el cursor sobre las capas en el inspector, se
mostrará su nombre En la escena de transición, ya que nada necesita
ser capaz detectar o colisionar con nuestra área, en
realidad no
necesita existir en ninguna capa siéntase libre de reservar una capa de colisión para las transiciones
si le ayuda. La transición
solo necesita tener una máscara de colisión para detectar
colisiones con el jugador Desactivar la capa uno y solo enmascarar la capa
nueve, el jugador. Podemos reforzar aún más
esto cambiando las propiedades
del nodo D del
área tres, diciéndole que monitoree
otros cuerpos físicos, pero que no sea monitoreable
por otros cuerpos físicos Ahora bien, la única manera posible que esta zona
tres D pueda desencadenar una colisión es si detecta un cuerpo físico en la capa nueve. No buscará
ninguna otra capa, y será invisible
para todo lo demás. El área de transición se
puede posicionar para cubrir el espacio vacío
más allá de la puerta, haciendo imposible que el personaje del jugador salga esta habitación sin
chocar con Abriendo todas mis escenas de
diferentes niveles. Puedo ver que esta transición está destinada a conectarse a la Sala uno. Así que vamos a llamarlo dos habitación uno. Duplicar el nodo
cambiará automáticamente el
nombre del duplicado
a dos habitaciones dos, y puedo
reposicionarlo en la otra puerta T Mientras que mis pequeños niveles, cada uno solo tiene dos transiciones. Se puede imaginar cómo un nivel complejo grande podría tener muchos más que son
difíciles de rastrear. Entonces debemos agrupar estos nodos para ordenarlos
dentro del árbol de escenas. Agreguemos un nuevo nodo, solo un nodo normal, y nombrémosle transiciones. Entonces re padre los nodos de
transición a la misma. Esto hará que sean
más fáciles de encontrar y usar no solo en nuestro
árbol de escenas en el editor, sino también a partir de nuestros guiones posteriores. Podemos copiar y pegar
estos nodos en nuestras escenas de nivel y
reposicionarlos para cubrir cada puerta Renombrándolos para que
sepamos a dónde llevan. abrir el script de progreso, podemos cambiar las variables
o agregar otras nuevas para almacenar el nombre del nivel
en el que se encuentra actualmente
el reproductor como una cadena. Lo inicializaré
para que sea la habitación uno. Para que este método
funcione,
el valor de esta
variable debe ser la ortografía exacta
del nombre de escena del nivel
en la pestaña del sistema de archivos. En el guión de transición. Entonces podemos establecer esta variable a medida que el jugador hace una transición
entre niveles. Exportemos una variable
para contener el nombre
del nivel al que
conduce esta transición como cadena. Entonces cuando el
cuerpo del personaje entra en esta área, podemos establecer el valor del nivel de
punto de progreso de punto de archivo. Para ser el
nombre del nivel. A continuación, vamos a
querer decirle al manager del juego
que cambie a este nivel. Como hicimos en el guión del
jugador, siempre
podemos acceder al nodo raíz de
escenas iniciando nuestra ruta de nodo con la raíz de barra de signo de
dólar, luego obtener el
administrador del juego con el juego Vamos a decirle al administrador del
juego que llame a una función que
aún no hemos escrito llamada Load level. Dado que el nombre del nivel
ya está almacenado en el recurso de
progreso, no
hay necesidad de
pasarlo como argumento. Dado que la única vez que
intentamos acceder
al administrador del juego es en esta
única instancia, no
hay necesidad de almacenarlo en una variable o usar add on ready. Sobre todo porque lógicamente, solo puede ocurrir un evento
de transición por nivel
cargado en el juego Entonces, cada transición declarando
la variable y accediendo
al administrador del juego cuando solo uno realmente la necesita
sería más derrochadora En el guión del manager del juego, primero
tomemos una referencia
al nivel que ya
existe en la escena. Podemos hacer clic y
arrastrar el nodo al script para
producir automáticamente su ruta de nodo, o incluso mantener presionada la tecla de control
o comando mientras
soltamos el botón del mouse para almacenarlo
automáticamente en una variable. Voy a cambiar el nombre de la variable
al nivel actual. Después declaramos la función de nivel de
carga que llamamos desde el script de
transición. Primero, necesitaremos saber si ya
hay un nivel cargado comprobando si esta variable contiene un valor
o si es nula. Si sí contiene un valor, entonces primero debemos
esperar f a negro. Luego podemos descargar el nivel
actual de
nuestra escena de juego usando la función
incorporada Q. Vamos a sobrecargar la siguiente
escena en la siguiente lección Por ahora, solo esperemos a
Fate para despejar y probarlo. Si el jugador
entra por la puerta, la escena se desvanece a negro El nivel actual se elimina
del árbol de escenas, y luego nos desvanecemos de nuevo
para ver a nuestro personaje y caída libre ya que ya no
hay ningún nivel. Nuestro panel Debug nos está
dando dos advertencias. Hemos declarado una variable que nunca
se usó en el script, y hay un parámetro no utilizado en nuestra función de colisión. Podemos prefijar
parámetros no utilizados con un guión bajo para marcarlos para el motor para que
puedan ser ignorados Al cambiar al script de
transición, el parámetro body ya no
se usa. Podemos agregar el prefijo
al nombre de la variable para
satisfacer esta advertencia. En la escena Guión del gerente. Hemos declarado la variable de configuración manu en este script, pero no se está utilizando
dentro de este script Lo hemos hecho
a propósito porque la configuración de
muchas variables es heredada y utilizada por todos los herederos
de esta clase No tenemos ninguna intención
de
usar el script del administrador de escenas directamente, sino que lo estamos usando para contener todas las propiedades y
comportamientos similares de un grupo
de scripts relacionados. En otros idiomas,
esto se
conocería como una clase abstracta. Este patrón de usar la
herencia de esta manera se conoce en la
programación orientada a objetos como abstracción. Podemos optar por
ignorar cualquier advertencia agregando otra línea antes la línea que está activando la advertencia usando
en warning ignore A continuación, especifique la advertencia que
queremos ignorar. En este caso, hemos declarado una variable privada no utilizada. Con ambas
advertencias de depuración abordadas, ejecutar el juego
ya no presentará ninguna advertencia. Ahora tenemos el
nivel actual descargando cuando el jugador
entra por una puerta En la siguiente lección,
cargaremos el siguiente nivel y colocaremos al jugador
en la
puerta correspondiente del otro lado Te veré en la siguiente lección.
9. Enter: Hola, amigos. En
la lección anterior, tuvimos al jugador saliendo
del nivel por una puerta En esta lección, cargaremos el siguiente nivel y colocaremos
al jugador dentro de él. Antes de cargar el siguiente nivel, primero
hemos
comprobado si hay un nivel actual y si es
así, lo estamos descargando. Entonces podemos asignar
un nuevo valor a la variable de nivel actual
ya que ahora está vacía. Usando una carga de función incorporada, podemos cargar cualquier recurso
desde nuestra pestaña de sistema de archivos, incluyendo escenas especificando
una ruta de archivo como una cadena. Para mantener nuestras escenas
mejor organizadas, vamos a crear una subcarpeta dentro la carpeta de escenas llamada levels. Después pon cada uno de los
niveles de juegos dentro de esta carpeta. Seleccionando cualquiera de
las escenas de nivel, podemos hacer clic y dragón en los soportes de funciones de carga para llenarlo con
la ruta del archivo Como todos nuestros niveles de juegos están ubicados en la carpeta
levels, y todos terminan con
la extensión dot TSCN, podemos separar estas
partes de la cadena
usando el operador Append, el Luego reemplace el nombre
de la escena de nivel por los almacenados dentro
del recurso de progreso. La función load
devuelve un recurso. Pero la
variable de nivel actual es un nodo tres d. primero necesitamos llamar
a una función en
el recurso para
convertirlo en un nodo, punto instanciado Después agrégalo al árbol de escenas con la función add child. Dado que este es el script del administrador de
juegos adjunto al nodo raíz de
escenas de juego, el nodo de nivel se agregará
como un hijo del nodo de juego. Pero, ¿y cuándo empieza
el juego por primera vez? O si el reproductor
carga un archivo seguro? Podemos iniciar nuestra escena de juego
sin un nodo de nivel en ella. Eliminando el nodo
de nivel de la escena del juego, podemos eliminar el add on ready de la variable de
nivel actual. Anulemos la
función ready heredada del administrador de escenas y el nivel de
carga de llamadas de inmediato. Antes de ejecutar la
definición de superclase de Scene Manager Esto nos permitirá cargar
cualquier nivel en nuestro juego, simplemente estableciendo
su nombre de archivo dentro
del recurso de progreso
y llamando al nivel de carga. Cambiará limpiamente
entre niveles al desvanecerse
primero a negro y
descargar la escena actual, luego cargar el siguiente
nivel y volver a desvanecerse Si es la
primera vez que
se carga un nivel y no
hay nivel actual, se saltará ese paso e
inmediatamente cargará el nivel. Pero tendremos que posicionar al jugador dentro
del nuevo nivel y además asegurarnos de que la posición esté empatada a la trayectoria desde la que
ingresaron al nivel. Empecemos en la escena de
transición, agregando un nuevo nodo que
no hace
más que simplemente marcar una
posición en tres espacios D, un marcador tres nodos D. La única diferencia entre
un marcador tres nodo D y un nodo tres D es
que el marcador
dibujará un Gizmo y el editor
mostrando dónde está Cambiemos el nombre de esta entrada de nodo y la movemos hacia adelante
a lo largo del eje Z, manera que esté fuera del nodo de
área y lo suficientemente
lejos como para que el personaje
del jugador no colisione con el área En el script de transición, podemos arrastrar esto
y mantener el control o comando para agregarlo como una
variable sin estar listo. Esta será la posición
donde el jugador será engendrado al nivel
al entrar por
esta transición En nuestras escenas de nivel, podemos rotar cualquiera de nuestras
transiciones para apuntar el eje Z y el marcador de
entrada a un punto apropiado
dentro del nivel. Si por alguna razón
necesitas mover un marcador de entrada individual sin afectar
otras transiciones, siempre
puedes hacer clic derecho en un nodo de transición y
activar los hijos editables Esto te permitirá mover un marcador de entrada
específico para tener en cuenta obstáculos o variaciones en la
altura del piso, por ejemplo. Antes de que podamos averiguar
cómo posicionar al jugador, necesitaremos las escenas de
nivel para
realizar un seguimiento de sus transiciones
con el guión. Agreguemos un nuevo script
al
nodo raíz de levels llamado level en
la carpeta scripts. Si arrastramos en el nodo de
transición, podemos almacenarlo en una
variable con add on ready. Pero no queremos este nodo. Queremos a todos sus hijos. Usando una
función incorporada get children, almacenaremos una lista
de todos los nodos secundarios a este nodo de transición
en una matriz de nodos. El orden de los nodos
en la matriz
será el mismo que el orden
en el árbol de escenas. Podemos acceder al
contenido de una matriz
especificando un número de índice a
partir de cero. Escribamos una función
en nuestro script de nivel que dé el número de
índice de transiciones y devuelva coordenadas donde se debe colocar el
personaje del jugador. Vamos a llamarlo get entrance, aceptando el índice de transición
como un parámetro entero. Y devolviendo un vector tres, la posición en tres D espacio para que el personaje sea colocado. Podemos acceder a la matriz de
transiciones, poniendo el número
de índice entre corchetes. Si el número de índice es cero, entonces eso
nos dará el nodo superior, seguido de uno, dos, etcétera A continuación, obtendremos el marcador
de
entrada de la transición y obtendremos la propiedad
de posición global del
marcador de entrada tres nodo D. Dado que la posición de las notas
es relativa a su padre. Queremos conocer la posición
global tal y como existe dentro de toda la
escena, para que podamos devolverlo. Tendremos que adjuntar
el script de nivel a la nota raíz de
cada nivel en nuestro juego. También existe la
posibilidad, sin embargo, poco probable de que al cargar el nivel antes de
reposicionar al personaje, el personaje simplemente pasa a estar
ya dentro de
un área de transición En la escena de transición, debemos desactivar la propiedad
de monitoreo por defecto. Después en el script de nivel, cuando se carga un nivel y el personaje se
posiciona correctamente, podemos llamar a una función para
activar todas las transiciones. Una característica muy útil de las
matrices es nuestra capacidad iterar
a través de cada uno de
sus elementos usando un bucle Comenzando con la palabra clave cuatro, podemos especificar un alias, lo usaremos dentro del bucle para hacer referencia al elemento actual. Seguido de la palabra clave in, luego el nombre de la
matriz y dos puntos. Cualquier cosa que pongamos
dentro del bloque loop se ejecutará en cada
elemento de la matriz, y podemos referirnos al
elemento actual usando el alias. Para cada transición
en transiciones, podemos establecer su propiedad de
monitoreo en
true para activar todas las
transiciones en este nivel. En el guión del administrador del juego, podemos agarrar una referencia
al personaje del jugador. Entonces cuando se carga un nivel, podemos posicionar al jugador
en la entrada de niveles. Usemos cero como
argumento por ahora. Ahora que el personaje se
ha posicionado, podemos activar todas las
transiciones en el nivel, ya que sabemos que el personaje no
está tocando ninguna de ellas. Por último, necesitamos
establecer los valores de cada transición en cada
nivel en el inspector, para que cada transición sepa a
qué nivel se conecta. Ejecutando la escena del juego, el
juego ahora comienza en la sala uno, y el jugador se posiciona
frente a la puerta El hijo superior del nodo de
transiciones. Enering el cualquier puerta, el nivel se descarga, y las escenas del juego, que
está al Pero no importa por qué
puerta pasemos, el jugador siempre se posiciona frente a la misma puerta Vamos a agregar otra variable
al recurso de progreso llamado
transition ID de tipo int. Después agregue también esta variable al script
de transición exportado. Cuando el personaje jugador
entra en esta transición, podemos establecer el valor dentro del recurso de progreso para que
coincida con la variable exportada. Y en el guión del manager del juego, usa esto como
argumento para seleccionar la transición donde se colocará al
jugador. Comenzando en la Sala uno, echemos
un vistazo a la
transición a la sala dos, que ahora tiene una variable de ID de
transición con un valor de cero. Este será el índice del nodo
de transición que regresa a la escena
desde la habitación dos. Podemos ver que
la transición a Sala uno es el nodo hijo superior, que es el índice cero. Entonces eso es correcto. Echando un vistazo a la transición de la
habitación dos a la habitación tres. Cambiemos a la escena de la
Sala tres, y podemos ver que
la transición de la Sala tres a la Sala
dos es el Índice uno. Por lo que tendremos que cambiar
el ID de transición de la sala
dos a la Sala tres a una. Y las transiciones que salen de la habitación tres también tendrán que cambiarse
a una. Al ejecutar la escena del juego,
ahora podemos correr entre
todos nuestros niveles,
tanto en el sentido de las agujas del reloj como en el sentido contrario a
las agujas del reloj, y el jugador se posiciona
correctamente cada vez Si tus niveles tienen
muchas transiciones, te
recomiendo establecer
una convención para tu juego sobre cómo
organizas tus transiciones, como en el sentido de las agujas del reloj desde
Norte, por ejemplo. También es posible que desee cambiar el número de índice a una cadena y organizar sus transiciones en un diccionario en lugar
de una matriz. También me gustaría
asegurarme de que tanto el personaje
como la cámara estén apuntando lejos de la transición la
que el jugador
ingresa a un nivel. En el script de nivel, al
igual que
devolvimos la
posición global de entrada desde una función, también
devolvamos
la
rotación de transiciones desde otra función. Ahora, el
script del administrador del juego puede acceder a
esta función para determinar a
qué dirección
deberían estar enfrentando. Podemos pasar esta información
al guión del jugador y utilizarla para rotar
tanto al personaje resorte que
sostiene la cámara, llamando a una ficción, pasando la
rotación devuelta como argumento. Dirección del pase, aceptando
la rotación y como a flote. Puede ajustar fácilmente la rotación de
los brazos de resorte para que coincida. Pero el brazo de resorte
debe girarse 180 grados para estar
detrás del personaje. Dado que la rotación se
mide en radianes, eso significa que podemos
sumar o restar Pi de este valor para apuntar la cámara en la dirección
correcta Luego podemos pasar
este valor de rotación por la cadena a
la clase de caracteres. Y agrega otra
función para rotar el equipo de personajes para
enfrentar inmediatamente la dirección deseada. Vamos a probarlo. Incluso si colocamos al
personaje y la cámara en ángulos
raros antes de
entrar por la puerta, ambos
estarán mirando lejos de la puerta del otro
lado Esto ayudará al jugador entender de qué
manera vino. Ahora tenemos al jugador capaz de hacer una transición entre niveles
y nuestra escena de juego. En la siguiente lección,
guardaremos y cargaremos el progreso de
los jugadores. Te veré en la siguiente lección.
10. Guardar: Hola, amigos. En
la lección anterior, completamos nuestro proceso de
transición de nivel. En esta lección, guardaremos y cargaremos el progreso de los jugadores
a través del juego. Nuestro script de archivo tiene múltiples
variables que contienen recursos
personalizados que utilizamos para realizar un seguimiento de la configuración del juego, así
como el progreso de los jugadores. Comencemos con el recurso
de configuración. En la función ready, estamos creando un nuevo recurso de
configuración, pero solo debemos
hacer eso si
no existe ya uno que podamos cargar en su lugar. La condición I primero verificará si el recurso ceti existe, y si lo hace, cargarlo, contrario, crear uno nuevo
y guardarlo de inmediato. Esta línea en realidad será el bloque else de
una sentencia IF. Godo nos permite guardar y cargar cualquier recurso usando clases
Singleton El cargador de recursos
puede cargar nuestro recurso, llamando al método load, pasando un
argumento de cadena, una ruta de archivo. En lugar de acceder a un
recurso dentro de nuestro proyecto, esta vez, queremos cargar algo del sistema del
usuario. La ruta del archivo comienza
con la barra diagonal de colon del usuario. El motor Godo utilizará
el atajo para encontrar una
ubicación adecuada en cualquier sistema para guardar y cargar archivos
únicos para cada usuario Vamos a nombrar la
configuración del archivo y darle una extensión de RS para el recurso. Esta función de carga
devuelve un recurso, que podemos asignar a
nuestra variable de configuración. Antes de cargar la configuración, podemos realizar una función
similar para verificar
primero si el archivo existe. Dado que la ruta del archivo ahora
se escribe dos veces, también la
estaremos
usando más también, y este es un valor que nunca
debería cambiar. Sería más eficiente para
declararlo como una constante. Si el
archivo de configuración no existe, entonces podemos crearlo. E inmediatamente guárdela usando
la clase de ahorro de recursos, llamando al método save. El método save requiere
un recurso para guardar, que es nuestro recurso de configuración, y la ruta del archivo para guardarlo, que es la ruta de configuración. Ahora al ejecutar el juego, si los ajustes
existen para el usuario, entonces se cargarán, y si no, se crearán. Pero también necesitamos hacer algunos cambios en el menú de configuración. Todos nuestros ajustes deben
establecerse en los valores
que se cargaron, que están en
la función ready. Hemos establecido la posición inicial del
control deslizante de la configuración del volumen utilizando los números almacenados en
el recurso de configuración. Pero también necesitamos
establecer el volumen del nodo
de música
y emitir la señal aquí como lo hicimos a continuación en respuesta al cambio del
valor del deslizador. Cuando el reproductor abre
el menú de ajustes, ajusta algunos ajustes,
entonces sería una buena idea guardar esos ajustes cuando
el menú esté cerrado. Podemos anular nuestro método de cierre de
clases de menú, así que cuando el
menú de configuración esté cerrado, le
diremos al archivo auto
load para guardar los ajustes. De vuelta en el archivo de carga automática, podemos agregar la función
que guarda los ajustes. El recurso
de progreso por otro lado, no
será manejado en
la función ready. Podemos separar cada uno
de estos métodos en funciones públicas para acceder al
recurso de progreso de diversas maneras. Comprobando si existe, iniciando un nuevo
juego y cargando. Usando el mismo formato
que nuestra configuración, podemos declarar una constante de ruta de
guardado. El archivo seguro existe función, devolverá un booleano, devolviendo el mismo
valor devuelto por el cargador de recursos existe. Pasando el
camino de guardado como argumento. Crear un nuevo recurso de progreso
cuando se llama a un nuevo juego. Guardar el recurso
cuando se
llama al juego guardado y cargar el recurso cuando se llama al juego de carga. En la escena del título, ahora
podemos crear fácilmente un nuevo recurso de progreso
cuando se presiona un nuevo juego. Y cargue el
archivo seguro existente si se presiona continuar. Sería un buen diseño de interfaz de usuario
tener el
botón continuar deshabilitado b y solo habilitarlo si
hay un archivo seguro para cargar. Tomemos una referencia
al botón de continuación
usando add on ready. En la función ready,
si existe un archivo seguro, podemos habilitar el botón de
continuación configurando su propiedad
disabled false Luego también dígale
que agarre el foco. De esa manera, la opción predeterminada
será nuevo juego la primera vez que se juegue el juego y continuará cada vez después de eso. Todo lo que tenemos que hacer es decidir
cuándo guardar el juego. Dado que este script de archivo
es un nodo de carga automática, puedes llamar fácilmente a la
función guardar para hacerlo desde el menú de pausa o guardar el objeto
punto en tu juego. Simplemente haré que mi juego
se guarde automáticamente cada vez que el
administrador del juego descargue un nivel De vuelta en el guión del
administrador de títulos, también
completemos
la función de salida. Al igual que nos desvanecemos cuando comienza
el juego, podemos esperar desvanecerse a
negro antes de salir Dejar el juego es una función incorporada del árbol de escenas, al que podemos acceder
con get tree, y simplemente llamar a la función Q En nuestros scripts de recursos personalizados, necesitaremos agregar una
exportación al frente de cualquier declaración de variable
que queramos escribir en el archivo Safe. Cualquier variable que no queramos
guardar puede simplemente omitir
la etiqueta de exportación Si, por ejemplo, está utilizando el método de punto seguro
común a los JRPG, la variable guardada en
el archivo seguro sería un número de ID
asociado al punto seguro, por lo que sería exportado Pero las variables que contienen
el nivel actual y ID de
transición no
necesitarían guardarse
en el archivo seguro, ya que no son
necesarias para cargar el juego, sino que aún son necesarias para hacer la
transición entre niveles. Por lo que no necesitarían
ser exportados en ese caso. En mi juego, voy a necesitar
exportar estas variables, ya que automáticamente estoy guardando mi juego con
cada transición de nivel. Una nota final en el script de carga automática de
archivos. Usando la extensión dot RES, escribiremos un
archivo seguro como un archivo binario, dificultando
el acceso del usuario. Añadiendo una T, haciendo la extensión
TREs para recurso de texto, escribiremos el archivo seguro
como un archivo de texto común, que se puede ver y editar en cualquier software de edición de texto. Ambos son formatos aceptables. Voy a guardar la configuración como
texto y el progreso como un archivo binario. Vamos a probarlo. Ejecutando el juego, el botón
continuar está deshabilitado, pero podemos iniciar una nueva partida. En la escena del juego, me
encontraré con un nivel diferente, lo que debería salvar mi juego. Al hacer una pausa en el juego, voy a cambiar
algunos de los ajustes del juego. Después salga del juego, volviendo a la escena del título. Ahora el
botón de continuar está activo, ya que el archivo seguro
existe para cargarse. Pero primero salgamos del juego, que se desvanece a negro y
cierra la ventana del juego Ahora, estoy dirigiendo el juego otra vez. Esta vez, el
botón de continuar está habilitado, ya que nuestro archivo seguro persistió
entre sesiones de reproducción Continuando con nuestro juego existente, comenzamos en el otro nivel, y los ajustes del juego también son
los mismos que los dejamos. R: Ahora, echemos un vistazo a los archivos que se
crearon en mi disco duro. El archivo de configuración
se puede abrir en el bloc de notas. Podemos ver
claramente
las variables exportadas y sus valores e incluso
editarlas y guardar el archivo. A continuación, abramos el archivo guardado que contiene el progreso de los jugadores. La mayor parte de esta información es. Incluso si tuviéramos que editar
algo y guardar el archivo, al
intentar cargar el archivo
saf se cerrará
el juego ya que
ya no está formateado correctamente Ejecutemos el juego una
vez más y veamos que
nuestro archivo de configuración, que
editamos manualmente un bloc de notas, está cargado, y los
valores son correctos Por lo que ahorrar recursos en formato
binario es más seguro y los recursos de texto
se editan muy fácilmente. En mi opinión, a menudo es más beneficioso para
los desarrolladores de ND poder
solucionar problemas de la edición de
archivos guardados con tus jugadores que
ocultar los
datos de progreso para evitar trampas Ahora tenemos a los
jugadores
progresando, guardando y cargando
entre sesiones de juego. En la siguiente lección,
terminaremos mostrando
los créditos del juego. Te veré en la siguiente lección.
11. Créditos: Hola, amigos. En
la lección anterior, salvamos y cargamos
el progreso de los jugadores. En esta lección,
mostraremos los créditos del juego. Empecemos por crear una
nueva escena, la escena crediticia. Dado que esto suele ser solo un fondo
negro
con texto blanco, creo que un nodo
de
interfaz de usuario tiene más sentido
como nodo raíz. Vamos a darle
un guión a la nota raíz y
llamémosle créditos Gerente. Heredar de Scene Manager y ordenarlo en la carpeta de scripts del
administrador Podemos copiar la nota F de cualquier otra escena y
pegarla en la escena de crédito. Después asignarlo en el inspector, junto con agregar una
pista de música para la escena crediticia. En el guión del administrador de títulos, ahora
podemos establecer el comportamiento
del botón de créditos en el menú principal para cambiar
a la escena de crédito. También debemos guardar la
escena de crédito en la carpeta de escenas. Después, en el guión del
Administrador de créditos, agreguemos una función
que
regrese a la escena del título. En la función de entrada. Podemos verificar si el jugador ha
pulsado un botón específico. Solo reutilizaré el botón de salto, y si es así, volveré
a la escena del título. Nuestras escenas ahora están conectadas y pueden hacer una transición de un lado
a otro. La mayoría de los juegos que aún están en desarrollo
tendrán los créditos accesibles desde el menú
principal ya que aún no se ha completado el final del juego. Por lo que
no habrá forma de acceder a la escena del crédito
completando el juego. Tener tu
escena crediticia incluida lo largo del desarrollo
de tu juego también ayuda a seguimiento de todos los que hacen una contribución a ella a lo largo de todo
su ciclo de vida. Hablando de eso,
los créditos suelen ser solo una serie de etiquetas de texto organizadas
verticalmente, desplazándose
lentamente hacia arriba Entonces agregando un
contenedor de caja vertical a la escena, vamos a llamarlo scroll. Y tenerlo anclado
al fondo de la pantalla. Pero con la ambientación amplia. Ahora los anclajes
izquierdos están ambos en la parte inferior izquierda de la pantalla y los anclajes
derechos están ambos en la parte inferior
derecha de la Esto suele ser de donde se originarán los
créditos. Los créditos a menudo se desglosan en categorías o títulos de trabajo, seguidos de una lista de nombres de contribuyentes
en esa categoría. Así que dentro de nuestra
caja vertical de todos los créditos, podemos agregar más cajas verticales
para contener cada categoría. Voy a llamar a este diseño de un juego. Dentro de la categoría, debe
haber una etiqueta para el título
de la categoría. Y voy a tener que
decir diseño de juego. Los créditos suelen estar
alineados con el centro. Voy a hacer que la fuente sea blanca. Tamaño 64, y usar el más elegante de mis dos
fuentes para títulos de categoría Duplicemos esta etiqueta no para agregar otra
etiqueta para nuestro nombre. Después, reduce el tamaño de la fuente y cambia la fuente a una con más énfasis en la legibilidad Ahora estamos listados como
el diseñador de juegos en nuestra escena de crédito de juegos. Pero los créditos están comenzando
dentro de la ventana del juego. Deberían comenzar por la
parte inferior de la pantalla. Volvamos a
la caja vertical de desplazamiento y cambiemos sus
ajustes preestablecidos de anclaje a personalizados Esto mantendrá
los anclajes donde están, pero nos permitirá cambiar
cada configuración individualmente Queremos que la dirección de crecimiento de este elemento de control baje, no hacia arriba, cambiando la
configuración de arriba a abajo. Vamos a colapsar y duplicar la
categoría de diseño de juegos para crear nuestra siguiente categoría, el desarrollo de
juegos. Dado que todos los
ajustes están duplicados, solo
necesitamos
cambiar los nombres de los nodos y las
propiedades de texto de los nodos de etiqueta, y también agregar cualquier nombre
adicional a cada categoría según sea necesario. Y repite este proceso para seguir agregando
tantas categorías como necesites para tu
juego para asegurarte todos los involucrados sean acreditados. También voy a
dar créditos al artista que hizo
los modelos de personajes,
animaciones, y modelos de ambiente
, K Laberg Penzila, quien creó los activos de la interfaz de
usuario, y Eric el Funny Baron, quien produjo toda la música Y por último, terminar con un mensaje de
agradecimiento al jugador. También voy a hacer más grande el mensaje de
agradecimiento. Nuestros créditos están todos aquí, pero todos están apretados
juntos y difíciles de leer Agreguemos algo de separación
al contenedor de caja vertical
para separar las categorías. Voy a establecer cada categoría 256 píxeles separados entre sí
para darles mucho espacio. Y podemos ver que
el pergamino de crédito va a llegar muy largo muy rápido. Lo último que quiero
hacer es asegurarme de que el mensaje de
agradecimiento se muestre
por su cuenta al final. Así que le daré un valor de tamaño
y mínimo
personalizado que coincida con el ajuste del
tamaño de la ventana de mi juego, 720 píxeles, y centraré el texto verticalmente dentro de
este espacio usando la propiedad de
alineación vertical de etiquetas. De vuelta en el script del
Administrador de créditos, Vamos a exportar una variable para la velocidad de desplazamiento y darle un
valor predeterminado de algo así como 32 píxeles por segundo Y toma una referencia al
pergamino usando add on ready. Después en la función de proceso, que toma a Delta como
parámetro flotante representa los
segundos que han pasado desde el último fotograma, cambiar la posición y
del scroll, restando tiempos de velocidad Ya que al trabajar
en dos dimensiones, cero está en la parte superior
de la pantalla, y mover algo hacia arriba se mueve en dirección
negativa. Luego tenemos que
detener el desplazamiento una vez que el mensaje de agradecimiento
llegue a la pantalla Mirando en nuestra vista de dos d, seleccionando el
scroll y exponiendo el
valor de posición de transformación en el inspector, podemos mover el scroll hacia arriba hasta que alcance la posición
deseada, donde solo se muestra el
mensaje de agradecimiento. Echando un vistazo en el
inspector a la transformación, podemos ver que la
posición y del scroll ahora
es igual a la
porción y del tamaño, pero es un número negativo y más la altura
del tamaño de pantalla 720. De vuelta en el script,
podemos comprobar si la posición y del scroll
ha superado este valor. C agitando si es
menor que el negativo de tamaño punto y más la
altura de la ventana de 720 píxeles Podemos ser aún
más precisos con este cálculo accediendo a la clase
singleton del servidor de visualización y solicitándole el tamaño de la ventana
actual, luego acceder al valor y Si esto es cierto, entonces ha llegado
al final del pergamino, y el mensaje de agradecimiento está
en el centro de la pantalla. En este punto, nos gustaría que el scroll dejara de desplazarse L et's crean una
variable booleana llamada, que por defecto será false Entonces podemos establecerlo en true
cuando el scroll haya cumplido con esta condición y también establecer la posición y
para que coincida con este valor exactamente para que quede perfectamente centrado en caso de que
sobrepase la marca Ya que estamos realizando
este cálculo dos veces, cambiémoslo
a una variable y calculémoslo usando add on ready. Entonces en la parte superior de
la función de proceso, podemos verificar si el
scroll está al final, y si es así, regresar, evitando que ocurra el
comportamiento de desplazamiento Esto funciona, pero en lugar de simplemente salir cuando el jugador
presiona el botón de salto, prefiero tener
la velocidad de desplazamiento y solo regresar a la pantalla de
título al
final del En la función de entrada, si el jugador presiona
el botón de salto, entonces también verifica si se
ha alcanzado
el final del scroll antes de
cambiar a la escena del título. Exportando dos nuevas variables, llamémoslas
velocidad lenta y velocidad rápida, ambas como flotadores con valores
predeterminados de 32 y 512 píxeles por segundo La velocidad real de desplazamiento ya
no necesita ser exportada,
sino que, en cambio,
pongámosla a la velocidad lenta
usando add on ready Entonces podemos establecer la velocidad de desplazamiento a la
velocidad rápida si el jugador presiona
el botón de salto antes de que el scroll
haya llegado a su fin. Y configurarlo a velocidad lenta si
sueltan el botón. A Vamos a probarlo. Al hacer clic en el botón de créditos, cambia a la escena de crédito. Los créditos comienzan a desplazarse hacia arriba desde la parte inferior de
la pantalla lentamente Pero podemos acelerarlo
manteniendo pulsado el botón de salto. Una vez que se haya alcanzado el
mensaje de agradecimiento, el juego
esperará a que se presione el botón Jump para
volver a la escena del título. Y eso es todo por lo
esencial del desarrollo de juegos. Ahora tienes un proyecto esqueleto completamente
funcional que podría ser utilizado para
desarrollar un juego de cualquier género.
12. ¿Qué sigue?: Bienvenido a mi curso de Diálogo y Sistemas de eventos en Gado. Este curso es una continuación de los elementos esenciales de desarrollo de
juegos
en Gado pero se puede seguir y aplicar a cualquier proyecto que involucre
a un personaje que
el jugador pueda controlar para interactuar con NPC u objetos presionando un botón y
mostrando diálogo Te invitamos a unirte a
nuestro servidor de discordia para trabajar en este curso
junto a tus compañeros En este curso
cubriremos la creación de cuadros de diálogo, eventos
e interacciones. Luego átelos
con banderas de progreso, controles de
cámara y animaciones de
personajes. Cuando termines, tendrás un completo sistema de diálogo
y eventos para tu juego que
se puede utilizar para producir escenas de corte de
alta calidad y narrativas
complejas de ramificación que reaccionan a las elecciones de los jugadores y les
permiten
progresar en el También aprenderás habilidades útiles para trabajar con el motor de juego
Gada, organizando y diseñando tus proyectos para que
sean más escalables. Estarás
aprendiendo a codificar con script
GD con todo lo
explicado en detalle Aplicaremos principios de diseño
orientado a objetos en nuestros scripts,
herencia, encapsulación
y abstracción, junto con otros patrones de diseño de
ingeniería de software como Singleton y
Composite pattern, para mantenerlos organizados, personalizables y reutilizables
para un proyecto de cualquier tamaño Todos los archivos del proyecto
también están disponibles en Github, si necesitas revisar
el proyecto tal como estaba después de completar
cada lección. Estos videos fueron grabados
usando Gadot versión 4.2 0.2. El proyecto comienza
con activos de los packs remasterizados de
K Kits Character y
Dungeon hechos por K L auberg y el paquete básico
Guy Todos están disponibles para
descargar gratis en dot IO.