Godot Engine 4.0 Documentación - Manual - 2D

Este artículo es el resultado de la traducción al inglés de Google Translate, y DrGraph agregó algunas correcciones sobre esta base. Página original en inglés:

2D — Documentación de Godot Engine (estable) en inglés

Capa de lienzo¶

Elementos de ventana gráfica y lienzo¶

CanvasItem es la base de todos los nodos 2D, ya sean nodos 2D regulares como Node2D o Control . Ambos heredan de CanvasItem . Puede organizar elementos de lienzo en un árbol. Cada elemento heredará la transformación de su padre: cuando el padre se mueve, sus hijos también se mueven.

Los nodos CanvasItem y los nodos que heredan de ellos son hijos directos o indirectos del Viewport que los muestra .

La propiedad  Viewport.canvas_transform de la ventana gráfica permite que se apliquen transformaciones Transform2D personalizadas  a la jerarquía CanvasItem que contiene. Los nodos como Camera2D funcionan cambiando esa transformación.

Para lograr efectos como el desplazamiento, manipular las propiedades de transformación del lienzo es más eficaz que mover el elemento del lienzo raíz y toda la escena.

Pero por lo general, no queremos que todo en nuestro juego o aplicación esté sujeto a transformaciones de lienzo. Por ejemplo:

• Fondo Parallax : Un fondo que se mueve más lento que el resto del escenario.

• IU : imagine una interfaz de usuario (UI) o una pantalla de visualización frontal (HUD) superpuesta a nuestra visión del mundo del juego. Queremos que los contadores de vida, las pantallas de puntuación y otros elementos mantengan su posición en la pantalla incluso cuando cambia nuestra visión del mundo del juego.

• Transiciones : es posible que queramos que los efectos visuales de las transiciones (fundido, fusión) permanezcan en una posición fija de la pantalla.

¿Cómo resolver estos problemas en un solo árbol de escena?

Capas de lienzo¶

La respuesta es CanvasLayer , un nodo que agrega una capa de representación 2D separada a todos sus hijos y nietos. De forma predeterminada, los elementos secundarios de la ventana gráfica se dibujarán en la capa "0", mientras que CanvasLayer se dibujará en cualquier capa numérica. Las capas con números más altos se dibujarán encima de las capas con números más bajos. CanvasLayers también tiene sus propias transformaciones que no dependen de las transformaciones de otras capas. Esto permite que la interfaz de usuario permanezca fija en el espacio de la pantalla mientras cambia nuestra visión del mundo del juego.

Un ejemplo de esto es crear fondos de paralaje. Esto se puede hacer con un CanvasLayer de capa "-1". También se pueden crear pantallas con puntuaciones, contadores de vida y botones de pausa en el nivel "1".

Esto es lo que parece:

CanvasLayers son independientes del orden del árbol, solo dependen de su número de capa, por lo que se pueden instanciar cuando sea necesario.

notas

CanvasLayers no necesita controlar el orden en que se dibujan los nodos. La forma estándar de garantizar que los nodos se dibujen correctamente "delante" o "detrás" es manipular el orden de los nodos en el panel de escena. Tal vez de forma contraria a la intuición, los nodos superiores del panel de escena se dibujan detrás de los nodos inferiores de la ventana gráfica. Los nodos 2D también tienen una propiedad CanvasItem.z_index que controla el orden en que se dibujan .

Transformaciones de ventana gráfica y lienzo¶

Introducción¶ _

Esta es una descripción general de la transformación 2D que toma un nodo de lo que dibuja localmente a lo que dibuja en la pantalla. Esta descripción general analiza los detalles de muy bajo nivel del motor.

Transformación de lienzo¶

Como se mencionó en el tutorial anterior Capas de Canvas , cada nodo CanvasItem (recuerde, los nodos basados ​​en Node2D y Control usan CanvasItem como su raíz común) residirá en una Capa de Canvas . Cada capa de lienzo tiene una transformación (traducción, rotación, escalado, etc.) a la que se puede acceder como Transform2D .

Como también se presentó en el tutorial anterior, los nodos se dibujan en la capa 0 del lienzo integrado de forma predeterminada. Para colocar nodos en diferentes capas, puede usar nodos CanvasLayer.

Transformación de lienzo global¶

La ventana gráfica también tiene una transformación Global Canvas (también  Transform2D ). Esta es la transformación maestra y afecta a todas las transformaciones de capas de lienzo individuales . Generalmente, esta transformación no es muy útil, pero solo se usa en el Editor CanvasItem en el editor de Godot.

Estirar transformación¶

Finalmente, la ventana gráfica tiene una transformación de estiramiento que se usa al cambiar el tamaño o estirar la pantalla. Esta transformación se usa internamente (como se describe en Multiresolución ), pero también se puede configurar manualmente por ventana gráfica.

Los eventos de entrada multiplican esta transición pero carecen de los anteriores. Para convertir las coordenadas de InputEvent en coordenadas locales de CanvasItem, se agrega la función CanvasItem.make_input_local() para mayor comodidad.

Orden de transformación¶

Para que las coordenadas en las propiedades locales de CanvasItem sean coordenadas de pantalla reales, se debe aplicar la siguiente cadena de transformaciones:

Funciones de transformación¶

Conseguir cada transformación se puede lograr con la siguiente función:

tipo	convertir
proyecto de lienzo	CanvasItem.get_global_transform()
capa de lienzo	CanvasItem.get_canvas_transform()
CanvasLayer+LienzoGlobal+Estirar	CanvasItem.get_viewport_transform()

Finalmente, entonces, para convertir las coordenadas locales de CanvasItem en coordenadas de pantalla, simplemente multiplique en el siguiente orden:

Guión GD C#

var screen_coord = get_viewport_transform() * (get_global_transform() * local_pos)

Pero tenga en cuenta que, por lo general, no desea utilizar coordenadas de pantalla. El enfoque recomendado es simplemente trabajar en las coordenadas de Canvas ( ) CanvasItem.get_global_transform()para permitir que los ajustes automáticos de resolución de pantalla funcionen correctamente.

Proporcionar eventos de entrada personalizados¶

A menudo es necesario enviar eventos de entrada personalizados al árbol de escena. Armado con el conocimiento anterior, para hacer esto correctamente, se debe proceder de la siguiente manera:

Guión GD C#

var local_pos = Vector2(10, 20) # local to Control/Node2D 
var ie = InputEventMouseButton.new() 
ie.button_index = MOUSE_BUTTON_LEFT 
ie.position = get_viewport_transform() * (get_global_transform() * local_pos) 
get_tree().input_event(ie )

Luces y sombras 2D¶

Introducción¶ _

Por defecto, las escenas 2D en Godot no están sombreadas, sin luces ni sombras visibles. Si bien el renderizado es rápido, las escenas sin sombrear pueden parecer planas. Godot brinda la capacidad de usar luces y sombras 2D en tiempo real, lo que puede mejorar en gran medida la sensación de profundidad de un proyecto.

Sin luces ni sombras 2D, la escena no tiene sombras¶

Habilitar luces 2D (sin sombras) ¶

Habilitar luces y sombras 2D¶

nodo¶ _

Una configuración de iluminación 2D completa involucra varios nodos:

• CanvasModulate (para oscurecer el resto de la escena)

• PointLight2D (para luces omnidireccionales o puntuales)

• DirectionalLight2D (para la luz del sol o la luz de la luna)

• LightOccluder2D (para lanzadores de luz y sombra)

• Otros nodos 2D que reciben iluminación, como Sprite2D o TileMap.

CanvasModulate se usa para oscurecer la escena especificando un color que actuará como el color "ambiental" base. Este es el color de iluminación final para áreas que no pueden ser alcanzadas por ninguna luz 2D. Sin el nodo CanvasModulate, la escena final se vería demasiado brillante, ya que las luces 2D solo iluminarían la apariencia sin sombrear existente (parecería completamente iluminada).

Sprite2D se utiliza para mostrar la textura de la llamarada, el fondo y la sombra.

PointLight2D se utiliza para iluminar la escena. La forma en que generalmente funcionan las luces es agregando texturas seleccionadas al resto de la escena para simular la iluminación.

LightOccluder2D se usa para decirle al sombreador qué partes de la escena proyectan sombras. Estos oclusores se pueden colocar como nodos independientes o como parte de un nodo de TileMap.

Las sombras solo aparecen en el área cubierta por PointLight2D y su orientación se basa en  el centro de Light.

notas

El color de fondo no recibe ninguna iluminación. Si desea que el rayo golpee el fondo, debe agregar una representación visual del fondo, como un Sprite2D.

Las propiedades de la región de Sprite2D son útiles para crear rápidamente texturas de fondo repetitivas, pero recuerde configurar Textura  > Repetir en Habilitado en las propiedades de Sprite2D.

Punto de luz¶

Las luces puntuales (también conocidas como luces de posición) son el elemento más común en la iluminación 2D. Las luces puntuales se pueden usar para representar la luz de antorchas, fuego, proyectiles y más.

PointLight2D proporciona las siguientes propiedades para ajustar en el inspector:

• Textura: La textura utilizada como fuente de luz. El tamaño de la textura determina el tamaño de la luz. Las texturas pueden tener un canal alfa, que es útil cuando se usa el modo de fusión Mezclar de Light2D , pero no es necesario si se usan los modos de fusión Agregar (predeterminado) o Restar .

• Desplazamiento: el desplazamiento de la textura ligera. A diferencia de los nodos de luz en movimiento, cambiar el desplazamiento no hace que se muevan las sombras.

• Escala de textura: un multiplicador para el tamaño de la luz. Los valores más altos extenderán la luz más lejos. Las luces más grandes tienen un mayor costo de rendimiento ya que afectan a más píxeles en la pantalla, así que considere esto antes de aumentar el tamaño de las luces.

• Altura: la altura virtual de la luz en relación con el mapa normal. Por defecto, los rayos se colocan muy cerca de la superficie que recibe el rayo. Esto hará que la iluminación sea casi invisible si usa un mapa normal, así que considere aumentar este valor. Ajustar la altura de la luz solo hará una diferencia notable en las superficies que usan mapas normales.

Si no tiene una textura prefabricada para usar en sus luces, puede usar esta textura de luz de punto "neutral" (clic derecho> guardar imagen como... ):

Textura ligera neutra¶

Si necesita una atenuación diferente, puede crear la textura de manera procesal asignando un New GradientTexture2D en la propiedad Texture de la luz. Después de crear el recurso, expanda su sección Relleno y establezca el modo de relleno en Radial . Luego, debe ajustar el degradado para comenzar de blanco opaco a blanco transparente y mover su posición inicial al centro.

Luz direccional¶

Lo nuevo en Godot 4.0 es la capacidad de hacer iluminación direccional en 2D. La iluminación direccional se utiliza para representar la luz del sol o la luz de la luna. Los rayos se proyectan paralelos entre sí, como si el sol o la luna estuvieran infinitamente lejos de la superficie que recibe los rayos.

DirectionalLight2D proporciona las siguientes propiedades:

• Altura: La altura virtual de la luz con respecto al mapa normal ( 0.0 =paralelo a la superficie, 1.0=perpendicular a la superficie). Por defecto, el rayo es exactamente paralelo a la superficie que recibe el rayo. Esto hará que la iluminación sea casi invisible si usa un mapa normal, así que considere aumentar este valor. Ajustar la altura de la luz solo hará una diferencia visual en la superficie usando el mapa normal. La altura no afecta la apariencia de la sombra.

• Distancia máxima: la distancia máxima (en píxeles) entre el objeto y el objeto en el centro de la cámara antes de eliminar las sombras. Disminuir este valor evita que los objetos fuera de la cámara proyecten sombras (al mismo tiempo que mejora el rendimiento). La distancia máxima no tiene en cuenta la escala de Camera2D, lo que significa que, con valores de zoom más altos, las sombras parecen desvanecerse más rápido cuando se hace zoom en un punto determinado.

notas

Las sombras direccionales siempre aparecen infinitamente largas, independientemente del valor de la propiedad Altura . Esta es una limitación del método de renderizado de sombras utilizado en Godot para luces 2D.

Para obtener sombras direccionales que no sean infinitamente largas, debe deshabilitar las sombras en DirectionalLight2D y usar un sombreador personalizado que lea desde un campo de distancia con signo 2D en su lugar. Este campo de distancia se genera automáticamente a partir de los nodos LightOccluder2D presentes en la escena.

Propiedades de luz comunes¶

Tanto PointLight2D como DirectionalLight2D proporcionan propiedades públicas, que forman parte de la clase base Light2D:

• Habilitado: Permite alternar la visibilidad de la luz. A diferencia de ocultar los nodos de luz, al deshabilitar esta propiedad no se ocultan los nodos secundarios de la luz.

• Solo editor: si está habilitado, la luz solo es visible dentro del editor. Se desactivará automáticamente en los proyectos en ejecución.

• Color: El color de la luz.

• Energía: Un multiplicador de intensidad para la luz. Los valores más altos producen una luz más brillante.

• Modo de mezcla: la fórmula de mezcla utilizada para los cálculos de luz. La adición predeterminada  es adecuada para la mayoría de los casos de uso. La resta se puede usar para luz negativa, no es físicamente precisa pero es útil para efectos especiales. El modo de fusión Mix mezcla el valor de píxel correspondiente a la textura clara con el valor de píxel debajo de ella mediante interpolación lineal .

• Range > Z Min: El índice Z más bajo afectado por la luz.

• Range > Z Max: El índice Z más alto afectado por la luz.

• Range > Layer Min: La capa visual más baja afectada por la luz.

• Range > Layer Max: La capa visual más alta afectada por la luz.

• Rango > Máscara de eliminación de elementos: controla qué nodos reciben luz de este nodo, según qué otros nodos tengan habilitada la capa de visibilidad Máscara de luz oclusiva . Esto se puede usar para evitar que ciertos objetos reciban luz.

Establecer sombras¶

Después de habilitar la propiedad Shadow > Enabled en un nodo PointLight2D o DirectionalLight2D , inicialmente no verá ninguna diferencia visual. Esto se debe a que los nodos de la escena aún no tienen oclusores , que se utilizan como base para la proyección de sombras.

要在场景中出现阴影，必须将 LightOccluder2D 节点添加到场景中。这些节点还必须具有旨在匹配精灵轮廓的遮挡多边形。

连同它们的多边形资源（必须设置为具有任何视觉效果），LightOccluder2D 节点具有 2 个属性：

• SDF Collision：如果启用，遮挡物将成为实时生成的有符号距离场的一部分，可用于自定义着色器。当不使用从这个 SDF 读取的自定义着色器时，启用它不会产生视觉差异并且没有性能成本，因此为了方便起见默认情况下启用它。

• Occluder Light Mask：这与 PointLight2D 和 DirectionalLight2D 的Shadow > Item Cull Mask属性一起使用，以控制哪些对象为每个光投射阴影。这可用于防止特定对象投射阴影。

有两种创建遮光器的方法：

自动生成遮光器¶

通过选择节点，单击2D 编辑器顶部的 Sprite2D菜单，然后选择Create LightOccluder2D Sibling ，可以从 Sprite2D 节点自动创建遮挡物。

在出现的对话框中，轮廓将围绕您的精灵的边缘。如果轮廓与精灵的边缘紧密匹配，您可以单击“确定”。如果轮廓离精灵的边缘太远（或者“侵蚀”到精灵的边缘），请调整Grow (pixels)和Shrink (pixels)，然后单击Update Preview。重复此操作，直到获得满意的结果。

Dibujar sombreadores manualmente¶

Cree un nodo LightOccluder2D, luego selecciónelo y haga clic en el botón "+" en la parte superior del editor 2D. Responda Sí cuando se le solicite crear un recurso de polígono  . Luego puede comenzar a dibujar el polígono de oclusión haciendo clic para crear un nuevo punto. Puede eliminar puntos existentes haciendo clic derecho sobre ellos o crear nuevos puntos a partir de líneas existentes haciendo clic en la línea y luego arrastrándola.

Las siguientes propiedades se pueden ajustar en una luz 2D con sombras habilitadas:

• Color: El color del área sombreada. De forma predeterminada, las áreas de sombra son completamente negras, pero esto se puede cambiar con fines artísticos. El canal alfa del color controla cuánto se tiñe la sombra con el color especificado.

• Filtro: modo de filtro para sombras. El valor predeterminado de Ninguno se procesa más rápido y es ideal para juegos con una estética de pixel art (debido a sus imágenes "en bloque"). Si desea sombras suaves, utilice PCF5 en su lugar  . PCF13 es más suave, pero el más exigente para el renderizado. Debido al alto costo de renderizado, PCF13 solo se puede usar para unas pocas luces a la vez.

• Suavizado de filtro: controla el grado de suavizado aplicado a las sombras cuando el filtro está configurado en PCF5 o PCF13 . Los valores más altos producen sombras más suaves, pero pueden generar artefactos de bandas visibles (especialmente cuando se usa PCF5).

• Item Cull Mask: Controla qué nodos LightOccluder2D proyectan sombras, según sus respectivas propiedades de Occluder Light Mask .

Sombras duras¶

Sombras suaves (PCF13, Filter Smooth 1.5) ¶

Sombras suaves con artefactos de rayas causados ​​por Filter Smooth demasiado alto (PCF5, Filter Smooth 4) ¶

Orden de dibujo del oclusor¶

LightOccluder2Ds sigue el orden habitual de dibujo 2D. Esto es importante para la iluminación 2D, ya que así es como controlas si el oclusor debe ocluir el objeto en sí.

Si el nodo LightOccluder2D es hermano del sprite , el oclusor ocluirá el sprite mismo cuando se coloque debajo del sprite en el árbol de la escena.

Si el nodo LightOccluder2D es un elemento secundario de un sprite,  el oclusor oscurecerá el sprite en sí mismo si Show Behind Parent está deshabilitado en el nodo LightOccluder2D (que es el valor predeterminado).

Mapas normales y especulares¶

Los mapas normales y especulares pueden mejorar en gran medida la percepción de la profundidad en la iluminación 2D. De manera similar a cómo funcionan en la representación 3D, los mapas normales pueden ayudar a que la iluminación se vea menos plana al cambiar su intensidad según la dirección en que una superficie recibe la luz (por píxel). Los mapas especulares ayudan aún más a mejorar las imágenes al hacer rebotar parte de la luz hacia el espectador.

Tanto PointLight2D como DirectionalLight2D admiten mapas normales y especulares. A partir de Godot 4.0, los mapas normales y especulares se pueden asignar a cualquier elemento 2D, incluidos los nodos heredados de Node2D o Control.

El mapa normal representa la dirección a la que "apunta" cada píxel. Luego, el motor usa esta información para aplicar correctamente la iluminación a las superficies 2D de una manera físicamente plausible. Los mapas normales generalmente se crean a partir de mapas de altura pintados a mano, pero también se pueden generar automáticamente a partir de otras texturas.

El mapa especular define cuánta luz debe reflejarse (y en qué color, si el mapa especular contiene colores) por píxel. Los valores más brillantes producirán reflejos más brillantes en un punto dado de la textura. Los mapas especulares generalmente se crean a través de la edición manual, utilizando una textura difusa como base.

pista

Si sus sprites no tienen mapas normales o especulares, puede usar la herramienta gratuita de código abierto Laigter  para generarlos.

Para establecer un mapa normal y/o un mapa especular en un nodo 2D, cree un nuevo recurso CanvasTexture para las propiedades que pintan la textura del nodo. Por ejemplo, en Sprite2D:

Crear recurso CanvasTexture para el nodo Sprite2D¶

Expanda el recurso recién creado. Puede encontrar varias propiedades para ajustar:

• Difuso > Textura: textura de color base. En esta propiedad, carga la textura que estás usando para el sprite mismo.

• Mapa normal > Textura: textura de mapa normal. En esta propiedad, cargue la textura de mapa normal que generó a partir del mapa de altura (vea el consejo anterior).

• Especular > Textura: textura de mapa especular, controla la intensidad especular de cada píxel en la textura difusa. El mapa especular suele ser en escala de grises, pero también puede contener color para aumentar el color reflejado en consecuencia. En esta propiedad, cargue la textura de mapa especular que creó (consulte la sugerencia anterior).

• Especular > Color: multiplicador de color para reflejos especulares.

• Especular > Brillo: el exponente de especularidad utilizado para los reflejos. Los valores más bajos aumentan el brillo de los reflejos y los hacen más difusos, mientras que los valores más altos hacen que los reflejos sean más localizados. Los valores altos son mejores para superficies de aspecto húmedo.

• Textura > Filtro: se puede configurar para anular el modo de filtrado de textura, independientemente de las propiedades del nodo configuradas (o la  configuración del elemento Representación > Texturas > Texturas de lienzo > Filtro de textura predeterminado ).

• Textura > Repetir: se puede configurar para anular el modo de filtrado de textura, independientemente de las propiedades del nodo configuradas (o la  configuración del elemento Representación > Texturas > Texturas de lienzo > Repetición de textura predeterminada ).

Después de habilitar los mapas normales, puede notar que las luces parecen desvanecerse. Para solucionar esto, aumente la propiedad Height en los nodos PointLight2D y DirectionalLight2D. También es posible que desee aumentar  ligeramente la propiedad de energía de la luz para acercarse a la intensidad de la luz antes de habilitar los mapas normales.

Usa sprites adicionales como una alternativa más rápida a las luces 2D¶

Si tiene problemas de rendimiento con las luces 2D, podría valer la pena reemplazar algunas de ellas con nodos Sprite2D que usan mezcla aditiva. Esto es especialmente útil para efectos dinámicos de corta duración, como balas o explosiones.

Los sprites adicionales se procesan mucho más rápido porque no necesitan pasar por una canalización de procesamiento separada. Además, este método se puede utilizar con AnimatedSprite2D (o Sprite2D + AnimationPlayer), lo que permite la creación de "luces" animadas en 2D.

Sin embargo, adjuntar sprites tiene algunas desventajas en comparación con las luces 2D:

• Las fórmulas de combinación son inexactas en comparación con la iluminación 2D "real". Esto no suele ser un problema en áreas bien iluminadas, pero evita que los sprites adicionales iluminen adecuadamente áreas completamente oscuras.

• Los sprites adjuntos no pueden proyectar sombras porque no son luces.

• Agregar sprites ignora los mapas normales y especulares usados ​​en otros sprites.

Para mostrar un sprite con combinación adicional, cree un nodo Sprite2D y asígnele una textura. En el inspector, desplácese hacia abajo hasta la sección CanvasItem > Material, expándalo y haga clic en el menú desplegable junto a la propiedad Material . Seleccione New CanvasItemMaterial , haga clic en el material recién creado para editarlo y establezca el modo de fusión en Add .

Cuadrícula 2D¶

Introducción¶ _

En 3D, las mallas se utilizan para mostrar el mundo. En 2D, son raros porque las imágenes se usan con más frecuencia. El motor 2D de Godot es un motor puramente 2D, por lo que en realidad no puede mostrar mallas 3D directamente (aunque se puede hacer Viewportcon y ViewportTexture).

ver también

Si está interesado en mostrar una malla 3D en una ventana gráfica 2D, consulte el tutorial Uso de la ventana gráfica como textura .

Una malla 2D es aquella que contiene geometría bidimensional (Z se puede omitir o ignorar) en lugar de 3D. Puede intentar SurfaceToolcrearlos usted mismo en código y mostrarlos en MeshInstance2Dun nodo.

Actualmente, la única forma de generar una malla 2D en el editor es importar un archivo OBJ como malla o convertirlo desde Sprite2D.

Optimización de píxeles dibujados¶

En algunos casos, este flujo de trabajo es útil para optimizar dibujos 2D. Al dibujar imágenes grandes con transparencia, Godot dibujará todo el cuadrante en la pantalla. Todavía se dibujan grandes áreas transparentes.

这会影响性能，尤其是在移动设备上，绘制非常大的图像（通常是屏幕大小），或将多个图像叠加在一起并具有大的透明区域（例如，使用 时）ParallaxBackground。

转换为网格将确保只绘制不透明部分，其余部分将被忽略。

将 Sprite2D 转换为 2D 网格¶

Sprite2D您可以通过将 a 转换为 a 来利用此优化MeshInstance2D。从边缘包含大量透明度的图像开始，就像这棵树：

将其放入 a 中Sprite2D，然后从菜单中选择“Convert to 2D Mesh”：

将出现一个对话框，显示如何创建 2D 网格的预览：

对于许多情况，默认值已经足够了，但您可以根据需要更改增长和简化：

最后，按下按钮，您的 Sprite2D 将被替换：Convert 2D Mesh

二维精灵动画¶

介绍¶

在本教程中，您将学习如何使用 AnimatedSprite2D 类和 AnimationPlayer 创建 2D 动画角色。通常，当您创建或下载动画角色时，它会以两种方式之一出现：作为单独的图像或作为包含所有动画帧的单个 sprite 表。两者都可以在 Godot 中使用 AnimatedSprite2D 类进行动画处理。

首先，我们将使用AnimatedSprite2D为单个图像的集合设置动画。然后我们将使用此类为精灵表制作动画。最后，我们将学习另一种使用AnimationPlayer和Sprite2D 的Animation属性为精灵表设置动画的方法。

笔记

El arte de los ejemplos a continuación es de ansimuz | OpenGameArt.org y tgfcoder.

Una sola imagen usando AnimatedSprite2D¶

En esta escena, tiene un conjunto de imágenes, cada una de las cuales contiene un cuadro de animación para un personaje. Para este ejemplo, usaremos las siguientes animaciones:

Puedes descargar la imagen aquí:  2d_sprite_animation_assets.zip

Descomprima las imágenes y colóquelas en la carpeta del proyecto. Configure el árbol de escenas con los siguientes nodos:

notas

El nodo raíz también puede ser Area2D o  RigidBody2D . Las animaciones se seguirán haciendo de la misma manera. Una vez completada la animación, puede asignar la forma a un CollisionShape2D. Ver Introducción a la Física para más detalles  .

Ahora seleccione AnimatedSprite2Dy seleccione "Nuevos SpriteFrames" en sus propiedades de SpriteFrames .

Haga clic en el nuevo activo de SpriteFrames y verá que aparece un nuevo panel en la parte inferior de la ventana del editor:

Desde el panel del sistema de archivos a la izquierda, arrastre 8 imágenes individuales a la sección central del panel SpriteFrames. A la izquierda, cambie el nombre de la animación de "Predeterminado" a "Ejecutar".

Use el botón Reproducir en la esquina superior derecha de la entrada Filtrar animaciones para obtener una vista previa de la animación. Ahora debería ver la reproducción de la animación en la ventana gráfica. Sin embargo, es un poco lento. Para solucionar esto, cambie la configuración de Velocidad (FPS) en el panel SpriteFrames a 10.

Puede agregar animaciones adicionales haciendo clic en el botón "Agregar animación" y agregando imágenes adicionales.

Animación de control¶

Una vez que se completa la animación, puede controlar la animación a través del código usando play()los métodos y stop(). Aquí hay un breve ejemplo que reproduce una animación mientras mantiene presionada la tecla de flecha derecha y la detiene cuando se suelta la tecla.

Guión GD C#

extiende CharacterBody2D @onready var _animated_sprite = $AnimatedSprite2D func _process(_delta):
     if Input.is_action_pressed("ui_right"): 
        _animated_sprite.play("run") else : 
        _animated_sprite.stop()

 


    

Hoja de Sprite con AnimatedSprite2D¶

También puedes animar fácilmente desde una hoja de sprites usando la clase AnimatedSprite2D. Usaremos esta hoja de sprites de dominio público:

Haga clic derecho en la imagen y seleccione "Guardar imagen como" para descargarla, luego copie la imagen en la carpeta de su proyecto.

Configure el árbol de escenas de la misma manera que antes con una sola imagen. Seleccione AnimatedSprite2Dy seleccione "Nuevos SpriteFrames" en sus propiedades de SpriteFrames .

Haga clic en el nuevo recurso SpriteFrames. Esta vez, cuando aparezca el panel inferior, seleccione Add Frame from Sprite Sheet.

Se le pedirá que abra un archivo. Elige tu hoja de sprites.

Se abrirá una nueva ventana mostrando tu hoja de sprites. Lo primero que debe hacer es cambiar la cantidad de imágenes verticales y horizontales en la hoja de sprites. En esta hoja de sprites tenemos cuatro imágenes horizontales y dos imágenes verticales.

A continuación, seleccione los fotogramas de la hoja de sprites para incluirlos en la animación. Seleccionaremos los primeros cuatro y haremos clic en Add 4 Frames para crear la animación.

Ahora verá su animación debajo de la lista de animaciones en el panel inferior. Haga doble clic en predeterminado y cambie el nombre de la animación para saltar.

¡Finalmente, marque el botón de reproducción en el editor de SpriteFrames para ver cómo salta su rana!

Hoja de sprites con AnimationPlayer¶

Otra forma en que puede animar cuando usa hojas de sprites es usar  nodos Sprite2D estándar para mostrar texturas, luego use un AnimationPlayer para animar los cambios entre texturas.

Considere esta hoja de sprites con 6 cuadros de animación:

Haga clic con el botón derecho en la imagen y seleccione "Guardar imagen como" para descargar, luego copie la imagen en la carpeta de su proyecto.

Nuestro objetivo es recorrer estas imágenes. Comience configurando el árbol de escena:

notas

El nodo raíz también puede ser Area2D o  RigidBody2D . Las animaciones se seguirán haciendo de la misma manera. Una vez completada la animación, puede asignar la forma a un CollisionShape2D. Ver Introducción a la Física para más detalles  .

Arrastre la hoja de sprites a la propiedad Textura de Sprite y verá que la hoja completa aparece en la pantalla. Para dividirlo en fotogramas individuales, expanda la sección Animación en el inspector y establezca Hframes en 6. Hframes y Vframes son el número de fotogramas horizontales y verticales en la hoja de sprites.

Ahora intente cambiar el valor de la propiedad Frame. Verá que varía de 0a 5y la imagen que muestra el Sprite2D cambia en consecuencia. Esta es la propiedad que queremos animar.

Seleccione AnimationPlayery haga clic en el botón Animación, luego haga clic en Nuevo. Nombra la nueva animación "Caminar". Establezca la duración de la animación 0.6y haga clic en el botón Repetir para que nuestra animación se repita.

Ahora seleccione Sprite2Del nodo y haga clic en el icono de la llave para agregar una nueva pista.

Continúe agregando fotogramas en cada punto de la línea de tiempo ( 0.1segundos de forma predeterminada) hasta que tenga todos los fotogramas del 0 al 5. Verás que los fotogramas aparecen en la pista de animación:

Presione "Reproducir" en la animación para ver cómo se ve.

Controlando las animaciones de AnimationPlayer¶

play()Al igual que con AnimatedSprite2D, puedes controlar la animación a través del código usando los métodos y stop(). Nuevamente, aquí hay un ejemplo que reproduce una animación cuando se mantiene presionada la tecla de flecha derecha y la detiene cuando se suelta la tecla.

Guión GD C#

extiende CharacterBody2D @onready var _animation_player = $AnimationPlayer func _process(_delta):
     if Input.is_action_pressed("ui_right"): 
        _animation_player.play("walk") else : 
        _animation_player.stop()

 


    

notas

h_flipSi actualiza las animaciones y las propiedades individuales al mismo tiempo (por ejemplo, un juego de plataformas puede actualizar las propiedades de un sprite cuando un personaje gira al iniciar una animación de "giro" v_flip ), es importante recordar que play()no se aplicará inmediatamente. En su lugar, se aplicará la próxima vez que se elimine AnimationPlayer. Esto puede terminar en el siguiente cuadro, lo que resulta en un cuadro de "fallo" donde se aplica el cambio de propiedad pero no se aplica animación. Si esto resulta ser un problema, play()puede advance(0) llamar a la animación de actualización inmediatamente después de llamar.

General¶ _

Estos ejemplos ilustran dos clases que pueden usarse para animación 2D en Godot. AnimationPlayerUn poco más complejo que AnimatedSprite2D, pero brinda funcionalidad adicional porque también puede animar otras propiedades, como la posición o la escala. Esta clase AnimationPlayertambién se puede usar con AnimatedSprite2DExperimente para ver qué funciona mejor para sus necesidades.

Sistema de partículas 2D¶

Introducción¶ _

Los sistemas de partículas se utilizan para simular efectos físicos complejos como chispas, llamas, partículas mágicas, humo, niebla, etc.

La idea es que las "partículas" se emitan a intervalos fijos y con un tiempo de vida fijo. Durante su vida, cada partícula tendrá el mismo comportamiento básico. Lo que hace única a cada partícula y le da un aspecto más orgánico es la "aleatoriedad" asociada a cada parámetro. Esencialmente, crear un sistema de partículas significa establecer los parámetros físicos subyacentes y luego agregarles aleatoriedad.

Nodo de partículas¶

Godot proporciona dos nodos diferentes para partículas 2D, GPUParticles2D  y CPUParticles2D . GPUParticles2D es más avanzado y usa la GPU para manejar efectos de partículas. CPUParticles2D es una opción impulsada por CPU con una funcionalidad similar a GPUParticles2D, pero con menor rendimiento cuando se usa una gran cantidad de partículas. Por otro lado, CPUParticles2D puede funcionar mejor en sistemas de gama baja o cuellos de botella de GPU.

 Si bien GPUParticles2D se configura a través de ParticleProcessMaterial (y, opcionalmente, usa un sombreador personalizado), las opciones de coincidencia se proporcionan a través de las propiedades del nodo en CPUParticles2D (excepto para la configuración de la pista).

Puede convertir un nodo GPUParticles2D en un nodo CPUParticles2D haciendo clic en el nodo en el inspector y luego seleccionando Partículas > Convertir a CPUParticles2D en la barra de herramientas en la parte superior de la ventana del Editor 3D.

本教程的其余部分将使用 GPUParticles2D 节点。首先，将 GPUParticles2D 节点添加到场景中。创建该节点后，您会注意到只创建了一个白点，并且在场景停靠栏中的 GPUParticles2D 节点旁边有一个警告图标。这是因为节点需要 ParticleProcessMaterial 才能运行。

粒子处理材质¶

要将处理材料添加到您的粒子节点，请转到您的检查器面板中。单击 旁边的框，然后从下拉菜单中选择。Process MaterialMaterialNew ParticleProcessMaterial

您的 GPUParticles2D 节点现在应该向下发射白点。

质地¶

粒子系统使用单个纹理（将来可能会通过 spritesheet 扩展到动画纹理）。纹理通过相关的纹理属性设置：

时间参数¶

寿命¶

每个粒子存活的时间（以秒为单位）。当生命周期结束时，将创建一个新粒子来替换它。

寿命：0.5

寿命：4.0

一枪¶

启用后，GPUParticles2D 节点将发射一次所有粒子，然后再也不会发射。

预处理¶

粒子系统从发射零粒子开始，然后开始发射。这在加载场景和火炬、雾等系统时可能会带来不便。在您进入的那一刻就开始发光。预处理用于让系统在第一次实际绘制之前处理给定的秒数。

速度秤¶

速度刻度的默认值为1，用于调整粒子系统的速度。降低该值将使粒子变慢，而增加该值将使粒子更快。

爆发力¶

如果 lifetime 是1并且有 10 个粒子，则意味着每 0.1 秒发射一个粒子。explosiveness 参数改变了这一点，并强制粒子一起发射。范围是：

• 0：定期发射粒子（默认值）。

• 1: emite todas las partículas al mismo tiempo.

También se permiten valores intermedios. Esta función es útil para crear explosiones o estallidos repentinos de partículas:

Aleatoriedad¶ _

Todos los parámetros físicos se pueden aleatorizar. Los valores aleatorios van de 0a  1.La fórmula para aleatorizar el parámetro es:

valor_inicial = valor_parámetro + valor_parámetro * aleatoriedad

Velocidad de fotogramas fija¶

Esta configuración se puede usar para configurar el sistema de partículas para renderizar a un FPS fijo. Por ejemplo, cambiar el valor a 2hará que las partículas se rendericen a 2 fotogramas por segundo. Tenga en cuenta que esto no ralentiza el sistema de partículas en sí.

Delta fraccionario¶

Esto se puede usar para activar o desactivar Fract Delta.

Parámetros de dibujo¶

Rectángulo de visibilidad¶

El rectángulo de visibilidad controla la visibilidad de las partículas en la pantalla. Si este rectángulo está fuera de la ventana gráfica, el motor no mostrará las partículas en la pantalla.

Las propiedades del rectángulo Wy Hcontrolan su ancho y alto, respectivamente. y las propiedades controlan la posición de la esquina superior izquierda del rectángulo en relación con el emisor de partículas X.Y

Puedes hacer que Godot genere automáticamente un rectángulo de visibilidad usando la barra de herramientas arriba de la vista 2d. Para hacer esto, seleccione el nodo GPUParticles2D y haga clic. Godot simulará el nodo Partículas2D emitiendo partículas durante unos segundos, y configurará el rectángulo para que se ajuste a la superficie que adoptan las partículas.Particles > Generate Visibility Rect

Puede utilizar esta opción para controlar la duración de la emisión. El valor máximo es de 25 segundos. Si necesita más tiempo para que las partículas se muevan, puede cambiar temporalmente la duración en el nodo Partículas2D.Generation Time (sec)preprocess

Coordenadas locales¶

De forma predeterminada, esta opción está activada, lo que significa que el espacio en el que se emiten las partículas es relativo al nodo. Si mueves un nodo, todas las partículas se mueven con él:

Si está deshabilitado, las partículas se emitirán al espacio global, lo que significa que las partículas ya emitidas no se verán afectadas si se mueve el nodo:

Orden de dibujo¶

Esto controla el orden en que se dibujan las partículas individuales. Index Indica que las partículas se dibujan según su orden de emisión (predeterminado). LifetimeIndica que se trazan en orden de vida restante.

Configuración de material de proceso de partículas¶

dirección¶ _

Esta es la dirección base en la que se emiten las partículas. El valor predeterminado es hacer que las partículas se emitan hacia la derecha. Sin embargo, con la configuración de gravedad predeterminada, las partículas viajarán directamente hacia abajo.Vector3(1, 0, 0)

Para que esta propiedad sea notable, necesita una velocidad inicial mayor que 0. Aquí establecemos la velocidad inicial en 40. Notarás que las partículas se emiten hacia la derecha y luego caen debido a la gravedad .

Propagación¶ _

Este parámetro es el ángulo en grados que se agregará aleatoriamente a la base en cualquier dirección  Direction. 180Se emitirá una propagación en todas las direcciones (+/- 180). Para que la propagación haga algo, el parámetro de "velocidad inicial" debe ser mayor que 0.

Planitud¶ _

Esta propiedad solo es útil para partículas 3D.

Gravedad¶ _

La gravedad aplicada a cada partícula.

Velocidad inicial¶

Velocidad inicial es la velocidad (en píxeles/segundo) a la que se emiten las partículas. La velocidad puede cambiar más tarde debido a la gravedad u otras aceleraciones (descritas a continuación).

Velocidad angular¶

Velocidad angular es la velocidad angular inicial aplicada a la partícula.

Velocidad de giro¶

La velocidad de giro es la velocidad (en grados por segundo) a la que una partícula gira alrededor de su centro.

Velocidad orbital¶

La velocidad orbital se utiliza para hacer girar partículas alrededor de sus centros.

Aceleración lineal¶

La aceleración lineal aplicada a cada partícula.

Aceleración radial¶

Si esta aceleración es positiva, las partículas se aceleran alejándose del centro. Si es negativo, son absorbidos por él.

Aceleración tangencial¶

Esta aceleración utilizará el vector tangente al centro. Combinado con la aceleración radial funciona bien.

Reducción de choque¶

La amortiguación aplica fricción a las partículas, obligándolas a detenerse. Es especialmente útil para chispas o explosiones que generalmente comienzan a velocidades lineales altas y luego se detienen a medida que disminuyen.

ángulo¶ _

Determina el ángulo inicial de la partícula en grados. Este parámetro es más útil para la aleatorización.

escala¶ _

Determina la escala inicial de las partículas.

color¶ _

Se utiliza para cambiar el color de las partículas emitidas.

Variación de tono¶

Este Variationvalor establece el cambio de matiz inicial aplicado a cada partícula. Este valor controla la relación de aleatoriedad del cambio de tinte.Variation Random

Forma de emisión¶

ParticleProcessMaterials le permite establecer una máscara de emisión, que determina el área y la dirección en la que se emiten las partículas. Estos se pueden generar a partir de texturas en el proyecto.

Asegúrese de que ParticleProcessMaterial esté configurado y que el nodo GPUParticles2D esté seleccionado. El menú Partículas debería aparecer en la barra de herramientas:

Ábralo y seleccione "Cargar máscara de emisión":

Luego elige una textura para usar como máscara:

Aparecerá un cuadro de diálogo con varias configuraciones.

Máscara de emisión¶

Se pueden generar tres tipos de máscaras de emisión a partir de texturas:

• Píxeles sólidos: las partículas se generarán desde cualquier área de la textura, excepto las áreas transparentes.

• Píxeles de borde: las partículas se generarán desde los bordes exteriores de la textura.

• Píxeles de borde dirigidos: similar a los píxeles de borde, pero agrega información adicional a la máscara para permitir que se emitan partículas desde el borde. Tenga en cuenta que se debe configurar un testamento para usarlo.Initial Velocity

Color de emisión¶

Capture from PixelHará que las partículas hereden el color de la máscara en su punto de generación.

Después de hacer clic en Aceptar, la máscara se genera y se establece en ParticleProcessMaterial en la siguiente sección:Emission Shape

Todos los valores en esta sección son generados automáticamente por el menú Cargar máscara de emisión, por lo que generalmente deben dejarse solos.

notas

Las imágenes no deben agregarse ni agregarse directamente. Siempre debe usarse el menú "Cargar máscara de inicio".Point TextureColor Texture

Suavizado 2D¶

ver también

Godot también admite suavizado en renderizado 3D. Esto se cubre en la página de antialiasing 3D .

Introducción¶ _

Las escenas renderizadas en 2D pueden aparecer con alias debido a la resolución limitada. Estos artefactos suelen aparecer en forma de un efecto de "escalera" en los bordes de la geometría y se notan más cuando se usan nodos como Line2D ,  Polygon2D o TextureProgressBar . Los dibujos personalizados en 2D también pueden tener alias para métodos que no admiten suavizado .

En el siguiente ejemplo, puede notar cómo los bordes tienen una apariencia de bloque:

La imagen se escala por un factor de 2 a través del filtrado del vecino más cercano para que el alias sea más visible. ¶

Para abordar esto, Godot admite varias formas de habilitar el suavizado en renderizados 2D.

Propiedades anti - aliasing en Line2D y gráficos personalizados¶

Este es el enfoque recomendado, ya que tiene menos impacto en el rendimiento en la mayoría de los casos.

Line2D tiene una propiedad Antialiased que puede habilitar en el inspector. Además, varios métodos para el trazado personalizado en 2D admiten parámetros opcionales que se pueden configurar al llamar a la función antialiased.true

Estos métodos no requieren que MSAA esté habilitado, lo que hace que su rendimiento básico  sea costoso. En otras palabras, si no dibuja ninguna geometría suavizada en algún momento, no aumentará el costo de forma permanente.

La desventaja de estos métodos de antialiasing es que funcionan generando geometría adicional. Esto puede ser un cuello de botella si está generando geometría 2D compleja que se actualiza en cada cuadro. Además, Polygon2D, TextureProgressBar y algunos métodos de dibujo personalizados no tienen propiedades de suavizado. Para estos nodos, puede utilizar Antialiasing multimuestra 2D en su lugar.

Antialiasing multimuestra (MSAA) ¶

Antes de habilitar MSAA en 2D, es importante comprender en qué se ejecutará MSAA. MSAA en 2D sigue restricciones similares a las de 3D. Si bien no presenta ningún desenfoque, su rango de aplicación es limitado. Las principales aplicaciones de 2D MSAA son:

• Bordes geométricos como dibujo de líneas y polígonos.

• Los bordes de sprite solo se aplican a los píxeles que tocan uno de los bordes de la textura . Esto funciona tanto para el filtrado lineal como para el vecino más cercano. Los bordes de los sprites creados con transparencia de imagen no se ven afectados por MSAA.

La desventaja de MSAA es que solo funciona en los bordes. Esto se debe a que MSAA aumenta la cantidad de muestras de cobertura, pero no la cantidad de muestras de color . Sin embargo, dado que la cantidad de muestras de color no aumenta, el sombreador de fragmentos solo se ejecuta una vez para cada píxel. Por tanto, MSAA no afecta en modo alguno a los siguientes tipos de alias:

• Aliasing en texturas filtradas del vecino más cercano (pixel art) .

• Aliasing causado por sombreadores 2D personalizados.

• Aliasing especular cuando se usa Light2D.

• Alias ​​​​en la representación de fuentes.

MSAA se puede habilitar en la configuración del proyecto cambiando el valor de la configuración Render > Antialiasing > Quality > MSAA 2D . Es importante cambiar el valor de la configuración MSAA 2D y no MSAA 3D , ya que son configuraciones completamente separadas.

Comparación entre ningún antialiasing (izquierda) y varios niveles de MSAA (derecha). La esquina superior izquierda contiene un nodo Line2D y la esquina superior derecha contiene 2 nodos TextureProgressBar. La parte inferior contiene 8 sprites de pixel art, 4 de los cuales están tocando los bordes (fondo verde) y 4 de los cuales no (logotipo de Godot):

  

Gráfico 2D personalizado¶

Introducción¶ _

Godot tiene nodos para dibujar sprites, polígonos, partículas y todo tipo de cosas. Para la mayoría de los casos, esto es suficiente. Si no hay un nodo que pueda dibujar lo que necesita, puede hacer que cualquier nodo 2D (por ejemplo, basado en Control o  Node2D ) dibuje comandos personalizados.

Útil para dibujos personalizados en nodos 2D . Estos son algunos casos de uso:

• Dibuje formas o lógica que los nodos existentes no pueden hacer, como imágenes con senderos o polígonos animados especiales.

• Visualizaciones que no son compatibles con Node, como tableros Tetris. (El ejemplo de Tetris usa una función de dibujo personalizada para dibujar los bloques).

• Dibujar muchos objetos simples. El dibujo personalizado evita la sobrecarga de usar una gran cantidad de nodos, lo que reduce potencialmente el uso de memoria y mejora el rendimiento.

• Cree controles de interfaz de usuario personalizados. Hay muchos controles disponibles, pero cuando tenga necesidades inusuales, es posible que deba personalizar los controles.

Dibujo¶ _

Agregue el script a cualquier nodo derivado de CanvasItem  , como Control o  Node2D . Luego anule esa _draw()función.

Guión GD C#

extiende la función Node2D _draw():
     # Tus comandos de dibujo pasan aquí


    

Los comandos de dibujo  se describen en la Referencia de la clase CanvasItem . Hay muchos.

Actualizando¶ _

La _draw()función se llama solo una vez, luego los comandos de dibujo se almacenan en caché y se recuerdan, por lo que no se necesitan más llamadas.

Si es necesario volver a dibujar debido a cambios de estado u otros, llame a CanvasItem.queue_redraw()_draw() en el mismo nodo y realice una nueva llamada.

Aquí hay un ejemplo un poco más complejo, una variable de textura que se volverá a pintar si se modifica:

Guión GD C#

extiende la exportación de Node2D 

(Textura) var textura setget _set_texture func _set_texture(valor):
     # Si la variable de textura se modifica externamente, # se llama a esta devolución de llamada. 
    textura = valor   # Se cambió la textura. 
    queue_redraw()   # Activar un redibujado del nodo. func _dibujar(): 
    dibujar_textura(textura, Vector2())


    

En algunos casos, puede ser necesario dibujar cada fotograma. Para hacer esto, llámalo queue_redraw()desde _process()la devolución de llamada, así:

Guión GD C#

extiende la función Node2D _draw():
     # Tus comandos de dibujo aquí pasan func _process(delta): 
    queue_redraw()


    

Coordenadas¶ _

La API de dibujo utiliza el sistema de coordenadas de CanvasItem, no necesariamente las coordenadas de píxeles. Esto significa que utiliza el espacio de coordenadas creado después de aplicar la transformación de CanvasItem. Además, puede aplicarle transformaciones personalizadas usando draw_set_transform o  draw_set_transform_matrix .

Al usarlo draw_line, se debe considerar el ancho de la línea. Cuando se utilizan anchos de tamaño impar, la posición debe cambiar para 0.5mantener la línea centrada, como se muestra a continuación.

Guión GD C#

func _dibujar(): 
    dibujar_línea(Vector2(1.5, 1.0), Vector2(1.5, 4.0), Color.VERDE, 1.0) 
    dibujar_línea(Vector2(4.0, 1.0), Vector2(4.0, 4.0), Color.VERDE, 2.0) 
    dibujar_línea (Vector2(7.5, 1.0), Vector2(7.5, 4.0), Color.VERDE, 3.0)

Lo mismo se aplica al draw_rectmétodo con.filled = false

Guión GD C#

func _dibujar(): 
    dibujar_rect(Rect2(1.0, 1.0, 3.0, 3.0), Color.VERDE) 
    dibujar_rect(Rect2(5.5, 1.5, 2.0, 2.0), Color.VERDE, falso, 1.0) 
    dibujar_rect(Rect2(9.0, 1.0) , 5.0, 5.0), Color.VERDE) 
    dibujar_rect(Rect2(16.0, 2.0, 3.0, 3.0), Color.VERDE, falso, 2.0)

Ejemplo: dibujar un arco¶

Ahora usaremos las capacidades de dibujo personalizadas del motor Godot para dibujar la funcionalidad que no proporciona Godot. Por ejemplo, Godot proporciona una draw_circle()función para dibujar un círculo completo. Pero, ¿qué pasa con dibujar parte de un círculo? Tendrás que escribir una función para hacer esto y dibujarla tú mismo.

Función de arco¶

Un arco se define por sus parámetros de círculo de apoyo, a saber, la posición central y el radio. El arco mismo se define entonces por el ángulo en el que comienza y el ángulo en el que se detiene. Estos son los 4 parámetros que debemos proporcionar a la función de trazado. También proporcionaremos valores de color, por lo que podemos dibujar arcos en diferentes colores si lo deseamos.

Básicamente, dibujar una forma en la pantalla requiere dividirla en una cierta cantidad de puntos que se conectan de un punto a otro. Como puede imaginar, cuantos más puntos tenga su forma, más suave se verá, pero también será más pesado en términos de costos de procesamiento. En general, si su forma es grande (o en 3D, cerca de la cámara), necesita dibujar más puntos que angulares. Por el contrario, si su forma es pequeña (o en 3D, lejos de la cámara), puede reducir su número de puntos para ahorrar costos de procesamiento; esto se denomina Nivel de detalle (LOD) . En nuestro ejemplo, simplemente usaremos un número fijo de puntos independientemente del radio.

Guión GD C#

func dibujar_círculo_arco(centro, radio, ángulo_desde, ángulo_hasta, color):
     var nb_puntos = 32
     var puntos_arco = PackedVector2Array() for i in range(nb_points + 1):
         var ángulo_punto = grados_a_rad(ángulo_desde + i * (ángulo_a-ángulo_desde) / nb_puntos - 90) 
        points_arc.push_back(center + Vector2(cos(angle_point), sin(angle_point)) * radio) for index_point in range(nb_points): 
        draw_line(points_arc[index_point], points_arc[index_point + 1], color)

    

    

¿Recuerdas la cantidad de puntos en los que se tuvo que dividir nuestra forma? Arreglamos nb_pointseste número en una variable como el valor 32. Luego, inicializamos uno vacío  PackedVector2Array, que es solo una Vector2matriz de s.

El siguiente paso consiste en calcular las posiciones reales de los 32 puntos que forman el arco. Esto se hace en el primer ciclo for: iteramos sobre el número de puntos donde se va a calcular la posición, más el último punto. Primero determinamos el ángulo de cada punto, entre el ángulo inicial y el ángulo final.

La razón por la que cada ángulo se reduce 90° es que usaremos la trigonometría (ya sabes, el coseno y el seno...) para calcular la posición 2D de cada ángulo. Sin embargo,  cos()se utilizan radianes sin(), no grados. Los ángulos de 0° (0 radianes) comienzan a las 3 en punto, aunque queremos contar desde las 12 en punto. Así que reducimos cada ángulo en 90° para contar desde las 12 en punto.

La posición real de un punto que se encuentra en el círculo en un ángulo (en radianes) angleestá dada por . Dado que los valores de suma y retorno están entre -1 y 1, la ubicación está en un círculo de radio 1. Para hacer que la ubicación se encuentre en un círculo de apoyo de radio, simplemente multiplicamos la ubicación por . Finalmente, necesitamos posicionar nuestro círculo de apoyo en esa ubicación, lo que hacemos al agregarlo a nuestro valor. Finalmente, insertamos el punto en el que definimos anteriormente.Vector2(cos(angle), sin(angle))cos()sin()radiusradiuscenterVector2PackedVector2Array

Ahora, tenemos que hacer realidad nuestro punto. Como puedes imaginar, no dibujamos simplemente 32 puntos: necesitamos dibujar todo entre cada punto. Podemos usar el método anterior para calcular nosotros mismos cada punto, y luego dibujarlos uno por uno. Pero eso es demasiado complicado e ineficiente (a menos que sea necesario explícitamente), así que solo dibujamos líneas entre cada par de puntos. A menos que nuestro círculo de apoyo tenga un radio muy grande, cada línea entre un par de puntos nunca será lo suficientemente larga para verlos. Si esto sucede, solo necesitamos aumentar la cantidad de puntos.

Dibujar un arco en la pantalla¶

Ahora tenemos una función que dibuja algo en la pantalla, es hora _draw()de llamarlo dentro de la función:

Guión GD C#

func _draw():
     var centro = Vector2(200, 200)
     var radio = 80
     var ángulo_desde = 75
     var ángulo_hasta = 195
     var color = Color(1.0, 0.0, 0.0) 
    dibujar_circulo_arco(centro, radio, ángulo_desde, ángulo_hasta, color)

resultado:

Función de polígono de arco¶

Podemos ir un paso más allá y escribir una función para dibujar no solo la parte plana del disco definida por el arco, sino también su forma. El método es exactamente el mismo que antes, excepto que dibujamos polígonos en lugar de líneas:

Guión GD C#

func draw_circle_arc_poly(center, radius, angle_from, angle_to, color):
     var nb_points = 32
     var points_arc = PackedVector2Array() 
    points_arc.push_back(center) var colors = PackedColorArray([color]) for i in range(nb_points + 1):
         var punto_ángulo = grados_hasta_rad(ángulo_desde + i * (ángulo_hasta - ángulo_desde) / nb_puntos - 90) 
        puntos_arco.empujar_atrás(centro + Vector2(cos(punto_ángulo), sin(punto_ángulo)) * radio) 
    dibujar_polígono(puntos_arco, colores)
    

    

Trazado personalizado dinámico¶

Ok, ahora podemos dibujar contenido personalizado en la pantalla. Sin embargo, es estático; hagamos que la forma gire alrededor del centro. La solución a esto es cambiar los valores de angle_from y angle_to con el tiempo. Para nuestro ejemplo, simplemente los aumentaremos en 50. Este valor delta debe permanecer constante, de lo contrario, la velocidad de rotación cambiará en consecuencia.

Primero, debemos hacer que las variables angle_from y angle_to sean globales en la parte superior del script. También tenga en cuenta que puede almacenarlos en otros nodos y usar get_node().

Guión GD C#

extiende Node2D var rotación_ángulo = 50
 var ángulo_desde = 75
 var ángulo_hasta = 195

Cambiamos estos valores en la función _process(delta).

También aumentamos los valores de angle_from y angle_to aquí. Sin embargo, ¡no debemos olvidarnos de wrap()los valores resultantes entre 0 y 360°! Es decir, si el ángulo es de 361°, en realidad es de 1°. Si no envuelves los valores, el script funcionará bien, pero los valores de los ángulos crecerán más y más con el tiempo hasta que alcancen el valor entero máximo ( ) que Godot puede administrar. Cuando esto sucede, Godot puede bloquearse o exhibir un comportamiento inesperado.2^31 - 1

Finalmente, no debemos olvidar llamar a la función queue_redraw(), se llamará automáticamente _draw(), de esta manera, puedes controlar cuándo se actualiza el marco.

Guión GD C#

func _process(delta): 
    ángulo_desde += ángulo_de_rotación 
    ángulo_hasta += ángulo_de_rotación # Solo envolvemos ángulos cuando ambos son mayores que 360. if ángulo_desde > 360 y ángulo_hasta > 360: 
        ángulo_desde = envolverf(ángulo_desde, 0, 360) 
        ángulo_hasta = envolver (ángulo_a, 0, 360) 
    cola_redraw()

    
    

Además, no olvide modificar la función _draw()para usar estas variables:

Guión GD C#

func _draw():
    var centro = Vector2(200, 200)
    var radio = 80
    var color = Color(1.0, 0.0, 0.0) 

   draw_circle_arc(centro, radio, ángulo_desde, ángulo_hasta, color)

¡corramos! Funciona, ¡pero el arco gira ridículamente rápido! ¿Qué ocurre?

原因是您的 GPU 实际上正在尽可能快地显示帧。我们需要用这个速度“规范化”绘图；为此，我们必须使用函数delta的参数_process()。delta包含两个最后渲染帧之间经过的时间。它通常很小（大约 0.0003 秒，但这取决于您的硬件），因此使用来delta控制您的绘图可确保您的程序在每个人的硬件上以相同的速度运行。

在我们的例子中，我们只需要 在函数rotation_angle中将变量乘以。这样，我们的2个角度会增加一个小很多的值，这个值直接取决于渲染速度。delta_process()

GD脚本C＃

func _process(delta):
    angle_from += rotation_angle * delta
    angle_to += rotation_angle * delta

    # We only wrap angles when both of them are bigger than 360.
    if angle_from > 360 and angle_to > 360:
        angle_from = wrapf(angle_from, 0, 360)
        angle_to = wrapf(angle_to, 0, 360)
    queue_redraw()

我们再跑一次！这一次，旋转显示正常！

抗锯齿绘图¶

Godot proporciona un parámetro de método en draw_line para habilitar el suavizado, pero no todos los métodos de dibujo personalizados proporcionan este antialiased parámetro.

Para antialiasedlos métodos de dibujo personalizados que no proporcionan parámetros, puede habilitar 2D MSAA, que afecta la representación en toda la ventana gráfica. Esto proporciona suavizado de alta calidad, pero a un mayor costo de rendimiento y solo para elementos específicos. Ver Antialiasing 2D para más detalles.

Herramientas¶ _

Es posible que también deba dibujar sus propios nodos cuando los ejecute en el editor. Esto se puede usar como una vista previa o visualización de cierta funcionalidad o comportamiento. Para obtener más información, consulte Ejecución de código en el editor.

Resumen de movimiento 2D¶

Introducción¶ _

Todos los principiantes se encuentran con: "¿Cómo muevo a mi personaje?" Según el estilo de juego que esté creando, es posible que tenga requisitos especiales, pero generalmente el movimiento en la mayoría de los juegos 2D se basa en una pequeña cantidad de diseño.

Usaremos CharacterBody2D en estos ejemplos , pero los principios también se aplican a otros tipos de nodos (Area2D, RigidBody2D).

Configuración¶ _

Cada uno de los ejemplos a continuación utiliza la misma configuración de escena. Comienza con a que tiene dos hijos CharacterBody2D: Sprite2Dy CollisionShape2D. Puedes usar el ícono de Godot ("icon.png") para la textura de Sprite2D o usar cualquier otra imagen 2D que tengas.

Abra y seleccione la pestaña Mapa de entrada. Agregue las siguientes acciones de entrada (vea InputEvent para más detalles ):Project -> Project Settings

Movimiento en 8 direcciones¶

En este caso, desea que el usuario presione las cuatro teclas direccionales (Arriba/Izquierda/Abajo/Derecha o W/A/S/D) y se mueva en la dirección seleccionada. El nombre "movimiento de 8 direcciones" proviene del hecho de que el jugador puede moverse en diagonal presionando dos teclas al mismo tiempo.

Agregue un script al personaje y agregue el siguiente código:

Guión GD C#

extiende CharacterBody2D @export var speed = 400 func get_input():
     var input_direction = Input.get_vector("izquierda", "derecha", "arriba", "abajo") 
    velocidad = input_direction * velocidad func _physics_process(delta): 
    get_input() 
    mover_y_deslizar()

 

En get_input()la función, usamos Entrada get_vector() para verificar cuatro eventos clave y la suma para devolver un vector de dirección.

Entonces podemos establecer nuestra velocidad multiplicando este vector de dirección de longitud 1por nuestra velocidad deseada.

pista

Si nunca has usado matemáticas vectoriales antes, o necesitas un repaso, puedes consultar una explicación del uso de vectores en Godot en Matemáticas vectoriales.

notas

Si el código anterior no hace nada cuando presiona una tecla, verifique que haya configurado la acción de entrada correctamente como se describe en la sección de configuración de este tutorial.

Girar+ Mover¶

Este tipo de movimiento a veces se denomina "estilo asteroide" porque se asemeja a la forma en que funcionan los juegos de arcade clásicos. Presiona izquierda/derecha para rotar tu personaje y arriba/abajo para moverlo hacia adelante o hacia atrás en cualquier dirección.

Guión GD C#

extiende CharacterBody2D @export var velocidad = 400
 @export var velocidad_rotación = 1.5 var dirección_rotación = 0 func get_input(): 
    dirección_rotación = Entrada.get_axis("izquierda", "derecha") 
    velocidad = transform.x * Entrada.get_axis("abajo" , "arriba") * función de velocidad _física_proceso(delta): 
    get_input() 
    rotación += dirección_rotación * velocidad_rotación * delta 
    move_and_slide()

  

Aquí hemos agregado dos variables para realizar un seguimiento de nuestra dirección y velocidad de rotación. La rotación se aplica directamente a las rotationpropiedades del cuerpo.

Para establecer la velocidad, tomamos la del cuerpo  transform.x, que es un vector que apunta en la dirección "hacia adelante" del cuerpo, y la multiplicamos por la velocidad.

Rotar+Mover (Ratón) ¶

Este estilo deportivo es una variación del anterior. Esta vez, la orientación la establece la posición del mouse en lugar del teclado. El personaje siempre "mirará" al puntero del ratón. Sin embargo, la entrada adelante/atrás sigue siendo la misma.

Guión GD C#

extiende CharacterBody2D @export var speed = 400 func get_input(): 
    look_at(get_global_mouse_position()) 
    speed = transform.x * Input.get_axis("down", "up") * speed func _physics_process(delta): 
    get_input() 
    move_and_slide( )

 

Aquí usamos métodos Node2D look_at() para señalar al jugador la posición del mouse. Sin esta función, puede obtener el mismo efecto configurando el ángulo de esta manera:

Guión GD C#

rotación = get_global_mouse_position().angle_to_point(posición)

Haz clic y mueve¶

El último ejemplo usa solo el mouse para controlar al personaje. Al hacer clic en la pantalla, el jugador se moverá a la ubicación de destino.

Guión GD C#

extiende CharacterBody2D @export var speed = 400 var target = position func _input(evento):
     if event.is_action_pressed("click"): 
        target = get_global_mouse_position() func _physics_process(delta): 
    velocidad = position.direction_to(target) * speed # mirar_en(objetivo) si position.distance_to(objetivo) > 10: 
        move_and_slide()

 






    
    

Tenga en cuenta distance_to()las comprobaciones que hacemos antes de moverse. Sin esta prueba, el cuerpo "se tambalea" cuando alcanza la posición objetivo, ya que se mueve ligeramente más allá de esa posición e intenta retroceder, solo para moverse demasiado y repetir.

Descomentar esa look_at()línea también hace que el cuerpo apunte en su dirección de movimiento, si lo desea.

pista

Esta técnica también se puede utilizar como base para un carácter de "seguimiento". La targetubicación puede ser la ubicación de cualquier objeto al que desee moverse.

General¶ _

Puede encontrar estos ejemplos de código útiles como punto de partida para sus propios proyectos. Siéntase libre de usarlos y experimentar con ellos para ver lo que puede hacer.

Puede descargar este proyecto de ejemplo aquí:  2d_movement_starter.zip

Usando TileSet¶

Introducción¶ _

Un mapa de mosaicos es una cuadrícula de mosaicos que se utiliza para crear diseños de juegos. Hay varios beneficios en el diseño de niveles usando nodos de TileMap . En primer lugar, le permiten dibujar diseños "dibujando" mosaicos en una cuadrícula, lo que es mucho más rápido que colocar nodos Sprite2D individuales uno tras otro . En segundo lugar, permiten niveles más grandes porque están optimizados para dibujar una gran cantidad de mosaicos. Finalmente, le permiten agregar más funcionalidad a sus mosaicos con formas de colisión, oclusión y navegación.

Para usar mapas de mosaicos, primero debe crear un TileSet. Un TileSet es una colección de mosaicos que se pueden colocar en un nodo TileMap. Después de crear TileSets, podrá colocarlos usando el editor de TileMap .

Para seguir esta guía, necesitará una imagen que contenga sus mosaicos, donde cada mosaico tenga el mismo tamaño (los objetos grandes se pueden dividir en varios mosaicos). Esta imagen se llama mosaico . Los mosaicos no tienen que ser cuadrados: pueden ser rectangulares, hexagonales o isométricos (perspectiva pseudo 3D).

Crear un nuevo TileSet¶

Usar tablas de mosaicos¶

Esta demostración utilizará los siguientes mosaicos tomados del paquete Abstract Platformer de Kenney . Usaremos esta tabla de mosaicos particular de la colección :

Un mosaico con mosaicos de 64×64. Crédito : Kenny¶

Cree un nuevo nodo TileMap , luego selecciónelo y cree un nuevo recurso TileSet en el inspector:

Crear un nuevo recurso TileSet en el nodo TileMap¶

Después de crear el recurso TileSet, haga clic en el valor para expandirlo en el inspector. La forma predeterminada del collage es cuadrada, pero también puede elegir equidistante, cuadrado medio desplazado o hexagonal (dependiendo de la forma de la imagen del collage). Si usa una forma de mosaico que no sea cuadrada, es posible que también deba ajustar las propiedades Diseño de mosaico y Eje de compensación de mosaico . Finalmente, habilitar la propiedad Procesar > Recorte UV puede ser útil si desea recortar mosaicos por coordenadas de mosaico. Esto asegura que los mosaicos no se puedan dibujar fuera del área asignada en la hoja de mosaico.

Establezca el tamaño de mosaico en 64x64 en el inspector para que coincida con la tabla de mosaicos de ejemplo:

Establezca el tamaño de mosaico en 64 × 64 para que coincida con la tabla de mosaico de ejemplo¶

Si confía en la creación automática de mosaicos (como haremos aquí), debe establecer el tamaño del mosaico antes de crear el atlas . El atlas determinará qué teselas de la hoja de teselas se pueden agregar a un nodo de TileMap (ya que no todas las partes de una imagen pueden ser una tesela válida).

Abra el panel TileSet en la parte inferior del editor y haga clic en el ícono "+" en la esquina inferior izquierda para agregar un nuevo atlas:

Crea un nuevo atlas en un recurso de TileSet usando el panel inferior¶

Después de crear un atlas, debe asignarle una textura de mosaico. Esto se puede hacer seleccionándolo en la columna izquierda del panel inferior, luego haciendo clic en el valor de la propiedad Textura y seleccionando Carga rápida (o Cargar ). Utilice el cuadro de diálogo de archivo que aparece para especificar la ruta al archivo de imagen.

Cargar imagen de hoja de mosaico en el atlas de TileSet recién creado¶

Después de especificar una imagen válida, se le preguntará si desea crear mosaicos automáticamente. La respuesta es :

Crea mosaicos automáticamente basados ​​en el contenido de la imagen de la hoja de mosaico¶

Esto creará mosaicos automáticamente según el tamaño de mosaico que especificó anteriormente en el recurso TileSet. Esto acelera enormemente la configuración inicial de mosaicos.

notas

Las secciones de la tabla de sectores completamente transparentes no generan mosaicos cuando se utiliza la generación automática de mosaicos basada en el contenido de la imagen .

Si hay mosaicos en la tabla de mosaicos que no desea que aparezcan en el atlas, seleccione la herramienta de borrador en la parte superior de la vista previa del conjunto de mosaicos y haga clic en el mosaico que desea eliminar:

Use la herramienta de borrador para eliminar mosaicos no deseados de un atlas de TileSet¶

También puede hacer clic con el botón derecho en un mosaico y seleccionar eliminar como alternativa a la herramienta de borrador.

pista

Al igual que en los editores 2D y TileMap, puede desplazar el panel TileSet con el botón central o derecho del mouse y hacer zoom con la rueda del mouse o el botón superior izquierdo.

Si desea obtener mosaicos de varias imágenes de hojas de mosaico en un solo TileSet, cree atlas adicionales y asigne texturas a cada uno antes de continuar. También es posible usar una imagen por mosaico de esta manera (aunque se recomienda una tabla de mosaicos para una mejor usabilidad).

Puede ajustar las propiedades del atlas en la columna central:

Ajuste las propiedades del atlas de TileSet en el inspector dedicado (parte del panel de TileSet) ¶

Las siguientes propiedades se pueden ajustar en un atlas:

• ID: Identificador (único dentro de este TileSet), utilizado para ordenar.

• Nombre: Un nombre legible por humanos para el atlas. Por motivos de organización, aquí se utilizan nombres descriptivos (como "terreno", "decoración", etc.).

• Margen: el margen (en píxeles) en el borde de la imagen que no debe seleccionarse como mosaico. Aumentar este valor puede ser útil si descarga imágenes de mosaico con márgenes alrededor de los bordes (por ejemplo, para la atribución).

• Separación: el espacio en píxeles entre cada mosaico en el atlas. Aumentar este valor puede ser útil si está utilizando una imagen de mosaico que incluye guías como contornos entre cada mosaico.

• Tamaño de la región de textura: el tamaño (en píxeles) de cada mosaico en el atlas. En la mayoría de los casos, esto debería coincidir con el tamaño de mosaico definido en la propiedad TileMap (aunque esto no es estrictamente necesario).

• Usar relleno de textura: si está marcado, agrega un borde transparente de 1 píxel alrededor de cada mosaico para evitar que la textura se corra cuando el filtrado está habilitado. Se recomienda tener esta opción habilitada a menos que tenga problemas de renderizado debido a los rellenos de textura.

Tenga en cuenta que cambiar los márgenes de textura, las separaciones y los tamaños de las regiones puede provocar que falten mosaicos (ya que algunos de ellos estarán fuera de las coordenadas de la imagen del atlas). Para regenerar mosaicos automáticamente desde la tabla de mosaicos, use los tres botones de menú de puntos verticales en la parte superior del editor de TileSet y seleccione  Crear mosaicos en áreas de textura no transparentes :

Vuelva a crear mosaicos automáticamente después de cambiar las propiedades del atlas¶

Trabajando con colecciones de escenas¶

A partir de Godot 4.0, puedes colocar escenas reales como mosaicos. Esto le permite usar cualquier colección de nodos como mosaico. Por ejemplo, puede usar mosaicos de escena para colocar elementos del juego, como tiendas, con las que los jugadores pueden interactuar. También puede usar mosaicos de escena para colocar AudioStreamPlayer2D (para sonidos ambientales), efectos de partículas, etc.

advertir

Los mosaicos de escena tienen una sobrecarga de rendimiento mayor que los atlas porque cada escena se instancia individualmente para cada mosaico colocado.

Se recomienda usar mosaicos de escena solo cuando sea necesario. Para dibujar sprites en mosaicos sin ninguna operación avanzada,  use un atlas en su lugar .

Para este ejemplo, crearemos una escena con un nodo raíz CPUParticles2D. Guarde la escena en un archivo de escena (separado de la escena que contiene el TileMap), luego cambie a la escena que contiene el nodo TileMap. Abra el editor TileSet y cree una nueva colección de escenas en la columna de la izquierda:

Creando SceneAssemblies en el Editor TileSet¶

Después de crear el montaje de la escena, puede ingresar opcionalmente un nombre descriptivo para el montaje de la escena en la columna del medio. Seleccione esta colección de escenas y cree un nuevo espacio de escena:

Crear mosaicos de escena después de seleccionar un escenario en el editor de TileSet¶

Seleccione este espacio de escena en la columna de la derecha, luego use fastload (o  load ) para cargar el archivo de escena que contiene las partículas:

Cree espacios de escena y cargue archivos de escena en ellos en el editor TileSet¶

Ahora tiene un mosaico de escena en el TileSet. Después de cambiar al editor de TileMap, podrá seleccionarlo de la colección de escenas y pintarlo como cualquier otro mosaico.

Fusionando múltiples atlas en un solo atlas¶

El uso de múltiples atlas en un solo recurso de TileSet a veces es útil, pero también puede ser engorroso en algunos casos (especialmente si usa una imagen por mosaico). Godot te permite combinar múltiples atlas en uno para facilitar la organización.

Para hacer esto, debe crear varios atlas dentro de un recurso de TileSet. Utilice el botón de menú "tres puntos verticales" ubicado en la parte inferior de la lista de mapas y seleccione Abrir herramienta de combinación de mapas :

Abra la herramienta de combinación de atlas después de crear múltiples atlas¶

Esto abrirá un cuadro de diálogo en el que puede seleccionar varios atlas presionando Mayús o Ctrl y haciendo clic en varios elementos:

Usando el cuadro de diálogo de la herramienta de fusión de Atlas¶

Seleccione Fusionar para fusionar los atlas seleccionados en una sola imagen de atlas (convertida en un solo atlas en un TileSet). Los atlas no combinados se eliminarán en el TileSet, pero las imágenes originales del atlas permanecerán en el sistema de archivos . Si no desea eliminar el atlas no fusionado del recurso TileSet, seleccione Fusionar (mantener el atlas original) en su lugar .

pista

TileSet tiene un sistema de proxy de teselas. Un Tile Proxy es una tabla de mapeo que permite que un TileMap sea informado con un TileSet dado que un conjunto dado de identificadores de mosaico debe ser reemplazado por otro conjunto.

Los proxies de mosaico se configuran automáticamente cuando se fusionan diferentes atlas, pero también se pueden configurar manualmente gracias al cuadro de diálogo Administrar proxies de mosaico , al que se accede mediante el menú "tres puntos verticales" mencionado anteriormente.

La creación manual de proxies de teselas puede ser útil cuando cambia la ID del atlas o desea reemplazar todas las teselas en un atlas con teselas en otro. Tenga en cuenta que al editar un TileMap, puede reemplazar todas las celdas con los valores asignados correspondientes.

Agregar colisión, navegación y oclusión a TileSet¶

Ahora hemos creado con éxito un TileSet básico. Ahora podemos comenzar a usar el nodo TileMap, pero actualmente carece de cualquier forma de detección de colisiones. Esto significa que los jugadores y otros objetos pueden atravesar pisos o paredes.

Si usa navegación 2D , también deberá definir polígonos de navegación para mosaicos para generar una malla de navegación que los agentes pueden usar para encontrar su camino.

Finalmente, si usa luces y sombras 2D o GPUParticles2D, probablemente también querrá que sus TileSets puedan proyectar sombras y colisionar con partículas. Esto requiere definir polígonos de oclusión para los mosaicos "sólidos" en el TileSet.

Para poder definir formas de colisión, navegación y oclusión para cada mosaico, primero debe crear una capa física, una capa de navegación o una capa de oclusión para el activo TileSet. Para hacer esto, seleccione el nodo TileMap, haga clic en el valor de la propiedad TileSet en el inspector para editarlo, luego expanda la capa física y elija  Agregar elemento :

Crear capas físicas (dentro de los nodos de TileMap) en el inspector de recursos de TileSet¶

Si también necesita soporte de navegación, ahora es un buen momento para crear una capa de navegación:

Cree una capa de navegación (dentro de un nodo TileMap) en el inspector de recursos de TileSet¶

Si necesita soporte para oclusores de polígonos ligeros, ahora es un buen momento para crear una capa de oclusión:

Crear capas de oclusión en el Inspector de activos de TileSet (dentro del nodo TileMap) ¶

notas

Los próximos pasos de este tutorial están dedicados a la creación de polígonos de colisión, pero el proceso de navegación y oclusión es muy similar. Sus respectivos editores de polígonos se comportan de la misma manera, por lo que estos pasos no se repiten por brevedad.

La única salvedad es que la propiedad Polígono de oclusión del mosaico es parte de la subsección Renderizar en Atlas Inspector. Asegúrese de expandir esta sección para que pueda editar el polígono.

Después de crear una capa física, puede acceder a la sección Capas físicas en el TileSet Atlas Inspector :

Abre el editor de colisiones en modo de selección¶

Puede crear rápidamente una forma de colisión rectangular presionando F mientras el editor TileSet está enfocado. Si los atajos de teclado no funcionan, intente hacer clic en un espacio vacío alrededor del editor de polígonos para enfocarlo:

Use la forma de colisión rectangular predeterminada presionando F¶

En este editor de colisión de mosaicos, puede usar todas las herramientas de edición de polígonos 2D:

• Use la barra de herramientas sobre el polígono para alternar entre la creación de nuevos polígonos, la edición de polígonos existentes y la eliminación de puntos en los polígonos. El botón de menú "Tres puntos verticales" ofrece opciones adicionales, como rotar y voltear polígonos.

• Cree nuevos puntos haciendo clic y arrastrando la línea entre dos puntos.

• Elimine un punto haciendo clic con el botón derecho en él (o usando la herramienta de eliminación mencionada anteriormente y haciendo clic con el botón izquierdo).

• Panorámica en el editor haciendo clic con el botón central o con el botón derecho. (La panorámica con el botón derecho solo funciona en áreas sin puntos cercanos).

Puede usar la forma de rectángulo predeterminada para crear rápidamente una forma de colisión de triángulos eliminando uno de los puntos:

Crea formas de colisión triangular haciendo clic con el botón derecho en una de las esquinas para eliminarla¶

También puede usar rectángulos como base para formas más complejas agregando más puntos:

Dibuja colisiones personalizadas para formas de mosaico complejas¶

pista

Si tiene un conjunto de mosaicos grande, especificar colisiones para cada mosaico individualmente puede llevar mucho tiempo. Esto es especialmente cierto ya que los TileMaps tienden a tener muchos mosaicos con patrones de colisión comunes (como bloques sólidos o pendientes de 45 grados). Para aplicar rápidamente formas de colisión similares a varios mosaicos, use  la capacidad de asignar propiedades a varios mosaicos a la vez .

Asigna metadatos personalizados a los mosaicos de TileSet¶

Puede utilizar capas de datos personalizados para asignar datos personalizados por mosaico. Esto es útil para almacenar información específica de tu juego, como cuánto daño debe hacer una ficha cuando un jugador la toca, o si una ficha se puede destruir con un arma.

Los datos están asociados con mosaicos en un TileSet: todas las instancias de un mosaico colocado usarán los mismos datos personalizados. Si necesita crear una variación de mosaico con diferentes datos personalizados, puede hacerlo creando un mosaico alternativo y cambiando solo los datos personalizados del mosaico alternativo.

Cree una capa de datos personalizada (dentro de un nodo TileMap) en el inspector de recursos de TileSet¶

Ejemplo de una capa de datos personalizada configurada con propiedades específicas del juego¶

Puede reordenar los datos personalizados sin romper los metadatos existentes: el editor de TileSet se actualizará automáticamente después de reordenar las propiedades de los datos personalizados.

Tenga en cuenta que en el editor, los nombres de las propiedades no aparecen (solo se muestran sus índices, lo que coincide con el orden en que se definieron). Por ejemplo, para el ejemplo de capa de datos personalizados que se muestra arriba, estamos asignando un mosaico para  establecer damage_per_secondlos metadatos en :25destructiblefalse

Editar datos personalizados en el editor TileSet en modo de selección¶

La pintura de propiedades de mosaico  también está disponible para datos personalizados:

Asigne datos personalizados en el editor de TileSet utilizando el dibujo de atributos de mosaico¶

Crear conjuntos de terreno (cosido automático) ¶

notas

Esta función se implementa de una forma diferente al mosaico automático en Godot 3.x. Los terrenos son esencialmente un reemplazo más poderoso para los mosaicos automáticos. A diferencia de los mosaicos automáticos, los terrenos pueden admitir transiciones de un terreno a otro, ya que un solo mosaico puede definir varios terrenos al mismo tiempo.

A diferencia de antes, los mosaicos automáticos son un tipo específico de mosaico y el terreno es simplemente un conjunto de propiedades asignadas a los mosaicos de atlas. Luego, estos atributos son utilizados por el modo de pintura de TileMap dedicado, que selecciona de manera inteligente mosaicos con datos del terreno. Esto significa que cualquier mosaico de terreno se puede dibujar como un terreno o como un solo mosaico como cualquier otro mosaico.

El mosaico "pulido" a menudo tiene variantes que debe usar en esquinas o bordes de plataformas, pisos, etc. Si bien es posible colocarlos manualmente, esto puede volverse tedioso rápidamente. Manejar esta situación con niveles generados por procedimientos también es difícil y requiere mucho código.

Godot proporciona terreno para automatizar esta unión de mosaicos. Esto le permite utilizar automáticamente la variante de mosaico "correcta".

Los terrenos se agrupan en TerrainSets. A cada conjunto de terreno se le asigna un modo de  Igualar esquinas y lados , Igualar esquinas y Igualar lados . Definen cómo los terrenos en un conjunto de terreno coinciden entre sí.

notas

Los modos anteriores corresponden a los autotiles de modo de máscara de bits anteriores utilizados en Godot 3.x: 2×2, 3×3 o 3×3 mínimo. Esto también es similar a lo que hace el editor de mosaicos .

Con el nodo TileMap seleccionado, vaya al inspector y cree un nuevo conjunto de terreno en el recurso TileSet:

Crear TerrainSets (dentro de los nodos de TileMap) en el Inspector de activos de TileSet¶

Después de crear un conjunto de terreno, se deben crear uno o más terrenos en el conjunto de terreno :

Creando terrenos en conjuntos de terreno¶

En el editor de TileSet, cambie al modo de selección y haga clic en un mosaico. En la columna del medio, expanda la sección Terrenos y asigne al mosaico un ID de conjunto de terreno y un ID de terreno. significa "Sin conjunto de terreno" o "Sin terreno", lo que significa que primero debe-1 configurar el Conjunto de terreno en o más grande antes de poder  configurar el Terreno en o más grande.00

notas

Los ID de conjunto de terreno y los ID de terreno son independientes entre sí. También comienzan con 0, en lugar de 1.

Configurar el terreno en mosaicos individuales en el modo de selección del editor TileSet¶

Después de hacer esto, ahora puede configurar la sección Terrain Peering Bits visible en la columna central . El bit de alineación determina qué mosaico se colocará en función de los mosaicos adyacentes. -1Un valor especial que se refiere al espacio vacío.

Por ejemplo, si un mosaico tiene todos los bits configurados en 0o más, solo aparecerá si los 8 mosaicos adyacentes usan un mosaico con la misma ID de terreno. Existe en esquinas o costados. Si los bits de un mosaico están configurados en 0o más, pero los bits superior izquierdo, superior y superior derecho están configurados -1, solo aparecerá si hay un espacio vacío encima (incluidas las líneas diagonales).

Configurar la equivalencia de terreno en mosaicos individuales en el modo de selección del editor de TileSet¶

Una configuración de ejemplo para una tabla de mosaico completa se ve así:

Ejemplo de una tabla de fichas completa para un juego de desplazamiento lateral¶

Ejemplo de una tabla de fichas completa para un juego de desplazamiento lateral con equivalencia de terreno visible¶

Asigna propiedades a múltiples mosaicos a la vez¶

Hay dos formas de asignar propiedades a varios mosaicos a la vez. Dependiendo de su caso de uso, un método puede ser más rápido que el otro:

Usar la selección de mosaicos múltiples¶

Si desea configurar varias propiedades a la vez, seleccione el modo de selección en la parte superior del editor de TileSet:

Una vez que Shift hace esto, puede seleccionar varios mosaicos en la columna derecha manteniendo presionados y luego haciendo clic en los mosaicos. También puede realizar una selección rectangular manteniendo presionado el botón izquierdo del mouse y luego arrastrando el mouse. Shift Finalmente, puede anular la selección de un mosaico ya seleccionado (sin afectar el resto de la selección) manteniendo presionado y luego haciendo clic en un mosaico seleccionado.

A continuación, puede asignar propiedades mediante los inspectores de la columna central del editor de TileSet. Solo las propiedades que cambie aquí se aplicarán a todos los mosaicos seleccionados. Al igual que en el inspector del editor, las distintas propiedades del mosaico seleccionado seguirán siendo diferentes hasta que lo edites.

Con los atributos de número y color, también verá una vista previa del valor del atributo en todos los mosaicos del atlas después de editar el atributo:

Use el modo de selección para seleccionar múltiples mosaicos, luego aplique atributos¶

Pintar con atributos de mosaico¶

Si desea aplicar un atributo a varios mosaicos a la vez, puede usar el modo de pintura de atributos para esto.

Configure los atributos para pintar en la columna central, luego haga clic (o mantenga presionado el botón izquierdo del mouse) en los mosaicos en la columna derecha para "pintar" los atributos en los mosaicos.

Dibujar propiedades de tesela utilizando el editor TileSet¶

La pintura de atributos de mosaico es especialmente útil para configurar manualmente atributos que consumen mucho tiempo, como formas de colisión:

Dibuja el polígono de colisión, luego haz clic izquierdo en el mosaico para aplicarlo¶

Crear mosaicos alternativos¶

A veces, desea usar una sola imagen de mosaico (que se encuentra solo una vez en el atlas), pero configurarla de manera diferente. Por ejemplo, es posible que desee utilizar la misma imagen de mosaico, pero rotarla, voltearla o modularla con un color diferente. Esto se puede hacer usando fichas sustitutas .

Para crear una tesela alternativa, haga clic con el botón derecho en la tesela base en el atlas que se muestra en el editor de TileSet y seleccione Crear tesela alternativa :

Cree mosaicos alternativos haciendo clic con el botón derecho en el mosaico base en el editor de TileSet¶

Si actualmente se encuentra en el modo de selección, el mosaico alternativo ya estará seleccionado para su edición. Si actualmente no está en el modo de selección, aún puede crear mosaicos alternativos, pero deberá cambiar al modo de selección y seleccionar el mosaico alternativo para editar.

Si no ve un mosaico alternativo, desplácese a la derecha de la imagen del atlas, ya que los mosaicos alternativos siempre aparecen en el editor de TileSet a la derecha del mosaico base para un atlas determinado:

Configurar mosaicos alternativos después de hacer clic en el editor de TileSet¶

Después de seleccionar un mosaico alternativo, puede usar la columna central para cambiar cualquier propiedad como lo haría en el mosaico base. Sin embargo, la lista de propiedades expuestas difiere del mosaico base:

• Id. alternativo: un identificador numérico único para este mosaico alternativo. Cambiarlo romperá el TileMap existente, ¡así que tenga cuidado! Este ID también controla el orden en la lista de mosaicos alternativos que se muestra en el editor.

• Representación > Voltear H: si true, el mosaico se voltea horizontalmente.

• Representación > Voltear V: si true, el mosaico se voltea verticalmente.

• Representación > Transponer: si true, el mosaico se gira 90 grados en sentido contrario a las agujas del reloj. Úselo con Flip H y/o Flip V para realizar rotaciones de 180 o 270 grados.

• Representación > Origen de la textura: el origen utilizado para dibujar el mosaico. Esto se puede usar para compensar visualmente la tesela en comparación con la tesela base.

• Renderizar > Modulación: el multiplicador de color que se usará al renderizar el mosaico.

• Representación > Material: el material que se utilizará para este mosaico. Esto se puede usar para aplicar diferentes modos de fusión o sombreadores personalizados a mosaicos individuales.

• Índice Z: el orden de clasificación de este mosaico. Los valores más altos harán que los mosaicos se representen frente a otros mosaicos en la misma capa.

• Y Sort Origin: Desplazamiento vertical para clasificar los mosaicos en función de su coordenada Y en píxeles. Esto permite usar capas como si estuvieran a diferentes alturas para un juego de arriba hacia abajo. Ajustar esto puede ayudar a aliviar los problemas con la clasificación de ciertos mosaicos. Solo funciona cuando Y Sort Enabled coloca mosaicos en la capa TileMap.true

Puede crear otras variaciones de mosaico alternativo haciendo clic en el ícono grande "+" al lado del mosaico alternativo. Esto es equivalente a seleccionar el mosaico base y hacer clic con el botón derecho en él para seleccionar "Crear mosaico de reemplazo" nuevamente .

notas

Cuando se crea una tesela de reemplazo, no se hereda ninguna de las propiedades de la tesela base. Si desea que las propiedades sean las mismas en los mosaicos base y de reemplazo, debe establecer las propiedades nuevamente en el mosaico de reemplazo.

Usando TileMaps¶

ver también

Esta página asume que ya ha creado o descargado un TileSet. De lo contrario, lea primero Uso de un TileSet , ya que necesitará un TileSet para crear un TileMap.

Introducción¶ _

Un mapa de mosaicos es una cuadrícula de mosaicos que se utiliza para crear diseños de juegos. Hay varios beneficios en el diseño de niveles usando nodos de TileMap . En primer lugar, pueden dibujar diseños "dibujando" mosaicos en la cuadrícula, lo que es mucho más rápido que colocar nodos Sprite2D individuales uno tras otro . En segundo lugar, permiten niveles más grandes porque están optimizados para dibujar una gran cantidad de mosaicos. Finalmente, puede agregar formas de colisión, oclusión y navegación a sus mosaicos, agregando aún más poder a su TileMap.

notas

Godot 4.0 ha movido varias propiedades por mosaico (como la rotación de mosaico) de TileMap a TileSet. Ya no es posible rotar mosaicos individuales en el editor de TileMap. En su lugar, se debe usar el editor TileSet para crear mosaicos rotados alternativos.

Este cambio permite una mayor consistencia en el diseño, ya que no es necesario rotar o voltear todos los mosaicos dentro de un TileSet.

Especificar TileSet en TileMap¶

Si siguió la página anterior sobre Uso de TileSets, debería tener un recurso de TileSet integrado en su nodo de TileMap. Esto es bueno para la creación de prototipos, pero en los proyectos del mundo real, a menudo tendrá varios niveles que reutilizan el mismo conjunto de fichas.

La forma recomendada de reutilizar el mismo TileSet en varios nodos de TileMap es guardar el TileSet en un recurso externo. Para hacer esto, haga clic en el menú desplegable junto al recurso TileSet y elija Guardar :

Guardar recursos integrados de TileSet en archivos de recursos externos¶

Crear capa de TileMap¶

A partir de Godot 4.0, puede colocar varias capas en un solo nodo de TileMap . Por ejemplo, esto le permite distinguir entre mosaicos de primer plano y mosaicos de fondo para una mejor organización. Puede colocar un mosaico por nivel en una ubicación determinada y, si tiene más de un nivel, puede superponer varios mosaicos uno encima del otro.

De forma predeterminada, un nodo de TileMap tiene automáticamente una capa prefabricada. No es necesario que cree capas adicionales si solo necesita una capa, pero si desea hacerlo ahora, seleccione el nodo TileMap y expanda la sección Capas en el inspector :

Crear capas en nodos de TileMap (ejemplo con 'fondo' y 'primer plano') ¶

Cada capa tiene varias propiedades que se pueden ajustar:

• Nombre: el nombre legible por humanos que se muestra en el editor de TileMap. Esto podría ser "fondo", "edificio", "vegetación", etc.

• Habilitado: si true, la capa es visible en el editor y cuando se ejecuta el proyecto.

• Modulación: el color utilizado como multiplicador para todas las teselas de la capa. Esto también se multiplica por la propiedad Modulate de cada mosaico y la propiedad Modulate del nodo TileMap . Por ejemplo, puede usar esto para oscurecer los mosaicos de fondo para que los mosaicos de primer plano se destaquen más.

• Y Sort Enabled: Si true, los mosaicos se ordenan según su posición Y en el TileMap. Esto se puede usar para evitar problemas de pedido con ciertos conjuntos de mosaicos, especialmente mosaicos isométricos.

• Origen de clasificación Y: el desplazamiento vertical (en píxeles) utilizado para clasificar cada mosaico en Y. Solo es válido cuando Y Sort Enabled es true.

• Índice Z: controla si esta capa se dibuja delante o detrás de otras capas de TileMap. Este valor puede ser positivo o negativo, la capa con el índice z más alto se dibuja encima de las demás. Si varias capas tienen la misma propiedad de índice Z, la última capa de la lista de capas (la que aparece en la parte inferior de la lista) se dibujará en la parte superior.

Puede reordenar las capas arrastrando y soltando el ícono de las "tres barras horizontales" a la izquierda de las entradas en la sección "Capas ".

notas

Puede crear, cambiar el nombre o reordenar capas en el futuro sin afectar los mosaicos existentes. Sin embargo, tenga cuidado, ya que al eliminar una capa también se eliminarán los mosaicos colocados en esa capa.

Abrir el editor de mapas de mosaicos¶

Seleccione el nodo TileMap y abra el panel TileMap en la parte inferior del editor:

Abra el panel TileMap en la parte inferior del editor. El nodo TileMap debe seleccionarse primero. ¶

Seleccionando mosaicos para pintar¶

Primero, asegúrese de haber seleccionado la capa en la que desea pintar si creó otras capas encima:

Seleccionar capas para pintar en el editor de TileMap¶

pista

En el editor 2D, las capas que no esté editando actualmente desde el mismo nodo de TileMap aparecerán atenuadas en el editor de TileMap. Puede deshabilitar este comportamiento haciendo clic en el icono junto al menú de selección de capas ( resalta la información sobre herramientas de la capa TileMap seleccionada ).

Si no ha creado otras capas, puede omitir los pasos anteriores, porque la primera capa se selecciona automáticamente al ingresar al editor de TileMap.

Antes de colocar mosaicos en el editor 2D, debe seleccionar uno o más mosaicos en el panel TileMap ubicado en la parte inferior del editor. Para hacer esto, haga clic en un mosaico en el panel TileMap o mantenga presionado el botón del mouse para seleccionar varios mosaicos:

Seleccionando un mosaico en el editor de TileMap haciendo clic en¶

pista

Al igual que en los editores 2D y TileSet, puede usar el botón central o derecho del mouse para desplazarse por el panel TileMap y usar la rueda del mouse o el botón superior izquierdo para hacer zoom.

También puede mantener presionada la tecla Mayús para agregar a la selección actual. Cuando se selecciona multibloque, el multibloque se coloca cada vez que se realiza una operación de pintura. Esto se puede usar para dibujar estructuras hechas de múltiples mosaicos (como grandes plataformas o árboles) con un solo clic.

La selección final no tiene que ser contigua: si hay un espacio entre los mosaicos seleccionados, se dejará vacío en el patrón dibujado en el editor 2D.

Seleccione múltiples mosaicos en el editor de TileMap manteniendo presionado el botón izquierdo del mouse¶

Si creó mosaicos alternativos en el TileSet, puede seleccionarlos para que se dibujen a la derecha del mosaico base:

Seleccionar mosaico alternativo en el editor de TileMap¶

Finalmente, si creó su colección de escenas en un TileSet, puede colocar mosaicos de escenas en un TileMap:

Usando el editor de TileMap para colocar mosaicos de escenas que contienen partículas¶

Modos de dibujo y herramientas¶

Usando la barra de herramientas en la parte superior del editor de TileMap, puede elegir entre varios modos de pintura y herramientas. Estos modos afectan el comportamiento de hacer clic en el editor 2D, no el panel TileMap en sí.

De izquierda a derecha, los modos de pintura y las herramientas que puede elegir son:

Seleccionar¶ _

Seleccione mosaicos haciendo clic en un solo mosaico, o mantenga presionado el botón izquierdo del mouse para seleccionar múltiples mosaicos usando un rectángulo en el editor 2D. Tenga en cuenta que las áreas vacías no se pueden seleccionar: si crea una selección rectangular, solo se seleccionarán mosaicos que no estén vacíos.

Para agregar a la selección actual, mantenga presionada la tecla Mayús y seleccione un mosaico. Para eliminar de la selección actual, mantenga presionada la tecla Ctrl y seleccione un mosaico.

Esta selección se puede usar en cualquier otro modo de pintura para crear rápidamente una copia del patrón colocado.

Mientras está en el modo de selección, no puede colocar nuevos mosaicos, pero aún puede borrar mosaicos haciendo clic derecho después de hacer una selección. No importa dónde haga clic en la selección, se eliminará toda la selección.

Mientras está en el modo de pintura, puede alternar temporalmente este modo manteniendo presionada la tecla Ctrl y luego realizando una selección.

pista

Puede copiar y pegar mosaicos colocados realizando una selección y presionando . Pegar la selección después del clic izquierdo. Puede realizar más copias de esta forma pulsando de nuevo. Haga clic derecho o presione Cancelar Pegar. Ctrl + CCtrl + VCtrl + VEscape

Dibujar¶ _

El modo de pintura estándar le permite colocar mosaicos haciendo clic o manteniendo presionado el botón izquierdo del mouse.

Si hace clic con el botón derecho, el mosaico actualmente seleccionado se eliminará del mapa de mosaicos. En otras palabras, será reemplazado por un espacio en blanco.

Si selecciona varios mosaicos en el TileMap o usa la herramienta de selección, se colocarán cada vez que haga clic o arrastre el mouse mientras mantiene presionado el botón izquierdo del mouse.

pista

En el modo de dibujo, puede dibujar una línea manteniendo presionado el botón izquierdo del mouse  antes de Shift y luego arrastrando el mouse hasta el punto final de la línea. Esto es lo mismo que usar la herramienta de línea que se describe a continuación.

También puede dibujar un rectángulo manteniendo  presionado el botón izquierdo del mouse antes de presionar Ctrl y Shift y luego arrastrando el mouse hasta los extremos del rectángulo. Esto es lo mismo que usar la herramienta de rectángulo que se describe a continuación.

Ctrl Finalmente, puede seleccionar mosaicos existentes en el editor 2D manteniendo presionado y haciendo clic en un mosaico (o manteniendo presionado y arrastrando el mouse). Esto cambiará el mosaico dibujado actualmente al que acaba de hacer clic. Esto es lo mismo que usar la herramienta de selección que se describe a continuación.

línea¶ _

Con el modo de dibujo de líneas seleccionado, puede dibujar una línea que siempre tenga 1 mosaico de grosor (independientemente de su orientación).

Si hace clic con el botón derecho en el modo de dibujo lineal, borrará una línea.

Si ha seleccionado varios mosaicos en el TileMap o con la herramienta de selección, puede colocarlos en un patrón repetitivo en una línea.

Mientras está en el modo de pintura o borrador, puede alternar temporalmente este modo manteniendo presionada la tecla Mayús y luego dibujando.

Dibuja la plataforma en diagonal con la herramienta de línea después de seleccionar dos fichas¶

rectángulo¶ _

Después de seleccionar el modo de dibujo de rectángulo, puede dibujar un rectángulo alineado con el eje.

Si hace clic con el botón derecho en el modo Pintar rectángulo, borrará el rectángulo alineado con el eje.

Si ha seleccionado varios mosaicos en el TileMap o con la herramienta de selección, se pueden colocar en un patrón repetitivo dentro de un rectángulo.

Mientras está en el modo Paint o Eraser, puede alternar temporalmente este modo manteniendo presionada la tecla Ctrl y luego Shift mientras dibuja.

balde lleno¶

Cuando se selecciona el modo Cubo de relleno, puede elegir si la pintura debe limitarse a áreas contiguas activando la casilla de verificación Contigua que aparece en el lado derecho de la barra de herramientas .

Si "Contiguo" está activado (predeterminado), solo se reemplazarán los mosaicos coincidentes que tocan la selección actual. Esta verificación continua se realiza horizontal y verticalmente, pero no en diagonal.

Si Contiguo está deshabilitado , todas las teselas con la misma ID en todo el mapa de teselas serán reemplazadas por la tesela actualmente seleccionada. Si se selecciona un mosaico vacío con Contiguo sin marcar , se reemplazarán todos los mosaicos dentro del rectángulo que contiene el área válida de TileMap.

Si hace clic con el botón derecho en el modo Cubo lleno, reemplazará los mosaicos coincidentes con mosaicos vacíos.

Si ha seleccionado varios mosaicos en el TileMap o con la herramienta de selección, se pueden colocar en un patrón repetitivo dentro del área de relleno.

Usando la herramienta de llenado de cubo¶

Selectores¶ _

Con el modo de selección seleccionado, puede seleccionar mosaicos existentes en el editor 2D manteniendo presionada la tecla Ctrl y haciendo clic en un mosaico. Esto cambiará el mosaico dibujado actualmente al que acaba de hacer clic. También puede elegir varias fichas a la vez manteniendo presionado el botón izquierdo del mouse y formando una selección rectangular. Solo se pueden elegir fichas que no estén vacías.

Mientras está en el modo de pintura, puede alternar temporalmente este modo manteniendo presionada la tecla Ctrl y haciendo clic o arrastrando el mouse.

Borrador¶ _

Este modo se combina con cualquier otro modo de pintura (Pintura, Línea, Rectángulo, Relleno de cubeta). Con el modo de borrador habilitado, los mosaicos se reemplazan con mosaicos vacíos cuando se hace clic con el botón izquierdo en lugar de dibujar una nueva línea.

Puede alternar temporalmente este modo haciendo clic con el botón derecho en lugar de hacer clic con el botón izquierdo en cualquier otro modo.

Pintura aleatoria con dispersión¶

Al pintar, puede optar por habilitar la aleatorización . Cuando está habilitado, la pintura seleccionará aleatoriamente un mosaico entre todos los mosaicos seleccionados actualmente. Esto es compatible con las herramientas de relleno de pintura, línea, rectángulo y cubeta. Para dibujar al azar de manera efectiva, debe seleccionar varios mosaicos en el editor de TileMap o usar la dispersión (ambos métodos se pueden combinar).

Si Dispersión se establece en un valor superior a 0, existe la posibilidad de que no se coloquen fichas cuando se dibujen. Esto es útil para agregar detalles ocasionales que no se repiten en áreas grandes (como agregar pasto o migas de pan en un gran TileMap de arriba hacia abajo).

Ejemplo al usar el modo de pintura:

Selección aleatoria de selección múltiple, luego mantenga presionado el botón izquierdo del mouse para dibujar¶

Ejemplo cuando se usa el modo Cubo lleno:

Use la herramienta de llenado de cubeta para un solo mosaico, pero con la aleatorización y la dispersión habilitadas¶

notas

El modo borrador no tiene en cuenta la aleatorización ni la dispersión. Todos los mosaicos de la selección siempre se eliminan.

Guardar y cargar ubicaciones de mosaicos prefabricados usando patrones¶

Si bien puede copiar y pegar mosaicos en el modo de selección, es posible que desee guardar patrones de mosaicos prefabricados para armarlos en cualquier momento. Esto se puede hacer para cada TileMap seleccionando la pestaña Patrones del editor de TileMap .

Para crear un nuevo patrón, cambie al modo de selección, haga una selección y presione . Haga clic en un área vacía en la pestaña Patrón (debería aparecer un rectángulo de enfoque azul alrededor del área vacía) y presione: Ctrl + CCtrl + V

Crear un nuevo esquema a partir de una selección en el editor de TileMap¶

Para usar un patrón existente, haga clic en su imagen en la pestaña Patrones , cambie a cualquier modo de pintura y haga clic con el botón izquierdo en algún lugar del editor 2D:

Colocar patrones existentes usando el editor de TileMap¶

Al igual que con la selección de mosaicos múltiples, el patrón se repetirá si se usa con los modos de pintura Línea, Rectángulo o Relleno de cubeta.

notas

A pesar de la edición en el editor de TileMap, el patrón aún se almacena en el recurso TileSet. Esto permite la reutilización de patrones en diferentes nodos de TileMap después de cargar un recurso de TileSet guardado en un archivo externo.

Manejar automáticamente las uniones de baldosas con Terrain¶

Para usar terrenos, un nodo de TileMap debe tener al menos un conjunto de terreno y un terreno en ese conjunto de terreno. Si no ha creado un conjunto de terreno para un TileSet, consulte Creación de un conjunto de terreno (mosaico automático).

Las conexiones de terreno tienen 3 modos de dibujo:

• Conectar , donde el mosaico se conecta a los mosaicos circundantes en la misma capa de TileMap.

• Ruta donde se conectan mosaicos con mosaicos dibujados con el mismo trazo (hasta que se suelta el botón del mouse).

• Anulaciones específicas de mosaico para resolver conflictos o manejar situaciones no cubiertas por el sistema de terreno.

El modo de conexión es más fácil de usar, pero Path es más flexible porque le permite al artista tener más control sobre el proceso de pintura. Por ejemplo, Path podría permitir que las carreteras estén directamente adyacentes entre sí sin conectarse, mientras que Connect obligaría a dos carreteras a conectarse.

Seleccione el modo de unión en la pestaña Terreno del editor de TileMap¶

Seleccione el modo de ruta en la pestaña Terreno del editor de TileMap¶

Finalmente, puedes seleccionar mosaicos específicos del terreno para resolver conflictos en ciertas situaciones:

Dibujar con mosaicos específicos en la pestaña Terrenos del editor de TileMap¶

Cualquier mosaico con al menos un bit establecido en el valor de la ID de terreno correspondiente aparecerá en la lista de mosaicos para su selección.

Manejo de fichas faltantes¶

Si elimina un mosaico en un TileSet al que se hace referencia en el TileMap, el TileMap mostrará un marcador de posición que indica que se colocó una ID de mosaico no válida:

Faltan mosaicos en el editor de TileMap debido a una referencia rota de TileSet¶

Estos marcadores de posición no están visibles en un proyecto en ejecución , pero los datos del mosaico aún se guardan en el disco. Esto le permite cerrar y volver a abrir dichas escenas de forma segura. Una vez que vuelva a agregar mosaicos con ID coincidentes, aparecerán como mosaicos nuevos.

notas

Es posible que los marcadores de posición de mosaico que faltan no estén visibles hasta que seleccione el nodo TileMap y abra el editor de TileMap.