Archivo de la etiqueta: Godot Engine

Dev snapshot: Godot 3.1 alpha 2

Dos meses después de nuestra versión alfa anterior, nos complace lanzar Godot 3.1 alpha 2, una nueva versión de desarrollo de la rama maestra, que avanza lenta pero constantemente hacia el estado beta.

Al contrario de nuestras versiones de mantenimiento (3.0.x), que incluyen solo correcciones de errores compatibles con versiones anteriores y revisadas a fondo, la versión 3.1 incluye todas las nuevas características (¡y errores subsiguientes!) Fusionadas en la rama maestra desde enero de 2018, y especialmente todas las que se muestran en nuestros devblogs pasados Han pasado 9 meses desde la versión 3.0 y cerca de 5,000 cambios, ¡así que espere muchas cosas buenas en la versión final 3.1!

La etapa alfa nos corresponde a una congelación de características (ver el anuncio en GitHub), lo que significa que ya no consideraremos solicitudes de extracción con nuevas características para fusionar en la rama maestra, y eso hasta que se libere Godot 3.1. De esta manera, podemos centrarnos en lo que ya tenemos, finalizar y pulir las características principales que aún están en progreso (por ejemplo, soporte de OpenGL ES 2.0) y corregir muchos de los errores antiguos y nuevos informados por la comunidad.

Las instantáneas alfa se publicarán regularmente durante esta fase, para probar continuamente la rama maestra y asegurarse de que siga siendo más estable, confiable y lista para la producción.

Aclaramos que

IMPORTANTE: esta es una compilación alfa, lo que significa que no es adecuada para su uso en producción, ni para revisiones de prensa de lo que Godot 3.1 estaría en su lanzamiento.

Todavía hay un largo camino para corregir errores y mejorar la usabilidad hasta que podamos lanzar la versión estable. Este lanzamiento es exclusivo para probadores que ya están familiarizados con Godot y pueden informar los problemas que experimentan en GitHub.

Tampoco hay garantía de que los proyectos iniciados con la compilación alfa 2 sigan funcionando en las compilaciones alfa 3 o posteriores, ya que nos reservamos el derecho de hacer los ajustes de ruptura necesarios hasta la etapa beta (aunque los cambios de compatibilidad en esta etapa deberían ser mínimos, en caso de presentarse).

Nota: los nuevos usuarios de Godot no deben usar esta versión para comenzar su aprendizaje. Godot 3.0.x es nuestra rama estable actual y aún recibe actualizaciones frecuentes.

Nuevas características

Las notas de la versión aún no están escritas, pero puede consultar el registro de cambios detallado en el que está trabajando nuestro colaborador Hugo Locurcio.

Como se mencionó anteriormente, nuestros devblogs anteriores también deberían darle una idea de los aspectos más destacados del próximo lanzamiento.

Este alfa 2 viene con una cantidad impresionante de correcciones de errores en comparación con el alfa 1. El backend de OpenGL ES 2.0 también ha visto mucho trabajo para empujarlo hacia la finalización de funciones, aún no está hecho, pero se está acercando.

Los redactores de documentación están trabajando duro para ponerse al día con las nuevas características, y la rama más reciente ya debería incluir detalles sobre muchas de las nuevas características 3.1.

Descargas

Los enlaces de descarga no se muestran en la página de descargas por ahora para evitar confusiones para los nuevos usuarios. En su lugar, navegue por uno de nuestro repositorio de descargas y busque el binario del editor que coincida con su plataforma:

IMPORTANTE: haga copias de seguridad de sus proyectos Godot 3.0 antes de abrirlos en cualquier versión de desarrollo 3.1. Una vez que se haya abierto un proyecto en 3.1, su archivo project.godot se actualizará a un nuevo formato para asignaciones de entrada que no es compatible con Godot 3.0; este último se negará a abrir un proyecto 3.1. Además, el uso de las nuevas características 3.1 en su proyecto significa que no puede volver a la versión 3.0, a menos que haga el trabajo necesario para eliminar el uso de esas características. Entonces, pruebe 3.1-alpha2 en una copia de sus proyectos 3.0 o inicie nuevos proyectos con él.

NOTA: esta versión todavía se llama «3.1.alpha» internamente, igual que alfa 1 y compilaciones diarias desde la rama maestra. Esto significa que las plantillas de exportación comparten la misma carpeta de instalación, pero debe asegurarse de reemplazar cualquier plantilla «3.1.alpha» que haya instalado actualmente con las de la distribución alfa 2.

Debido a algunos problemas del sistema de compilación, alpha2 no tiene plantillas de exportación que funcionen para el objetivo ARM de UWP. Además, las características upnp y websockets faltan por completo en las plantillas de exportación de UWP.

Reporte de errores

Todavía hay cientos de informes de errores abiertos para el hito 3.1, lo que significa que ya estamos conscientes de muchos errores. Sin embargo, muchos de esos problemas pueden no ser críticos para la versión 3.1 y pueden volver a dirigirse a una versión posterior para permitir la liberación de Godot 3.1 en un futuro próximo.

Como probador, se recomienda que abra informes de errores si experimenta problemas con 3.1 alpha. Compruebe primero los problemas existentes, utilizando la función de búsqueda con palabras clave relevantes, para asegurarse de que el error que experimenta no se conoce ya.

La imagen de la ilustración es del juego FOSS Mystic Treasure Hunt 3D de Krzysztof Jankowski. Puedes leer más sobre su viaje como artista en su blog

Aclaro que esto es una traducción del blog original.

Nuevo panel de Sistema de Archivos para Godot 3.1

Antes que nada, nos gustaría agradecer a nuestro patrocinador Gamblify por haber donado esta nueva característica a la comunidad. Su participación y su apoyo constante para mejorar Godot son muy apreciados.

Para la próxima versión 3.1, Godot obtiene un nuevo sistema de archivos. Los archivos, no solo las carpetas, ahora se muestran directamente en la vista de árbol y tienen una vista previa:

Esta nueva pantalla, que se puede cambiar con la anterior con un botón en la parte superior de la base, evita dividir la base en dos áreas. Esto permite una interfaz más compacta, que también nos lleva a reconsiderar el diseño predeterminado para el editor. Como puede ver, ahora hay más espacio disponible para el inspector, lo que reduce el desplazamiento necesario allí:

Características

Este nuevo panel presenta varias cosas:

  • Los archivos ahora se pueden marcar como favoritos, no solo como carpetas.
  • Soporte completo al momento de arrastrar y soltar archivos, incluido arrastrar archivos y carpetas a la sección de favoritos:
  • Podemos tener iconos al lado de cada nombre de archivo. Para texturas y materiales, este icono se reemplaza por una miniatura pequeña del recurso.
  • Un campo de búsqueda, para filtrar las entradas en el árbol de recursos:
  • Un menú que desplegamos con el clic derecho para manejar archivos  funciona exactamente en la lista de archivos.
  • El botón «Marcar como favorito» se ha movido a una entrada de menú, que se encuentra al hacer clic con el botón derecho en archivos o carpetas.
  • El botón «Buscar escena actual en archivos» se ha movido a una entrada de menú, al hacer clic con el botón derecho en una pestaña de escena.

Esperamos que disfrute de este nuevo sistema de archivos. ¡Estamos esperando tus comentarios!

Nota: esta nueva característica a estado funcionando desde antes que la congelación de la función entrara en vigencia con Godot 3.1 alpha.

Este artículo es una traducción del oficial, puedes leer desde la web de Godot aquí: https://godotengine.org/article/godot-gets-new-filesystem-dock-3-1

Simplex Noise Lands in Godot 3.1 – Versión español

¡La generación de ruido simple acaba de aterrizar en Godot 3.1! Este algoritmo de generación de ruido, originalmente inventado por Ken Perlin, es rápido y tiene muy buenos resultados.  Todavía tiene algunas patentes privadas, por eso Godot utilizará OpenSimplex noise, de dominio público y una buena alternativa.

Sus aplicaciones

El ruido simple, como cualquier otro tipo de ruido, es especialmente útil en dos áreas del desarrollo de un juego: procedural generation y efectos visuales.

Procedural Generation

Generar contenido de procedural en vídeojuegos puede ser un desafío, las estructuras completamente aleatorias tienden a convertirse en un completo desastre y, por lo tanto, inutilizables. Es por eso que la «aleatoriedad controlada» del ruido simple se vuelve realmente útil. Si desea obtener más información sobre cómo funciona el ruido «fractal» y algunas otras técnicas de generación de terreno, recomiendo encarecidamente este artículo de Red Blob Games.

Un prototipo de Godot: voxel world prototype de Zylann, que utiliza su propio módulo OpenSimplex, puede ser reemplazado por la implementación incorporada.

Efectos visuales

Las texturas de ruido 2D son realmente útiles cuando se crean efectos nublados u ondulados. Por ejemplo, el nuevo recurso NoiseTexture se puede usar como un mapa normal para obtener un material de agua rápido y simple:

Las texturas de ruido también se pueden usar como mapas de rugosidad, texturas de luz 2D, etc. Pero el verdadero poder de las texturas de ruido está disponible cuando se utiliza en combinación con shaders de texto:

Empezando

GDScript

Generar ruido desde GDScript es tan simple como instaurar un nuevo generador de ruido, establecer sus parámetros y tomar muestras en las posiciones deseadas:

# Instantiate
var noise = SimplexNoise.new()

# Configure
noise.seed = randi()
noise.octaves = 4
noise.period = 20.0
noise.persistance = 0.8

# Sample
print(noise.get_noise_2d(1.0, 1.0))
print(noise.get_noise_3d(0.5, 3.0, 15.0))
print(noise.get_noise_3d(0.5, 1.9, 4.7, 0.0))

Otra forma de acceder a los valores de ruido es precomputar una imagen de ruido:

# This creates a 512x512 image filled with simplex noise (using the currently set parameters)
var noise_image = noise.get_image(512, 512)

# You can now access the values at each position like in any other image
print(noise_image.get_pixel(10, 20))

Para obtener más información acerca de SimplexNoise y cuál es el significado de cada parámetro, no olvide consultar la documentación.

Texturas de ruido

Si solo necesita acceso a una textura de ruido para efectos visuales, el nuevo tipo de recurso NoiseTexture es su mejor opción. Le permite especificar un generador de ruido y una textura. Los datos de textura se rellenarán automáticamente con ruido, utilizando los parámetros del generador. También puede habilitar el uso de ruido sin interrupciones (solo funciona con texturas cuadradas) y permitir la salida de datos de ruido como un mapa normal.

NOTA: Este artículo es una traducción de la noticia oficial, la puedes visitar en este enlace: https://godotengine.org/article/simplex-noise-lands-godot-31

Pasar entre tiles con OneWayCollision – Godot Engine

Hace unos días publiqué un tutorial en YouTube donde enseñaba la propiedad OneWayCollision para pasar entre «paredes» al estilo de Mario Bros. 

Aquí les escribiré un resumen sobre la propiedad que deben activar para tener el efecto. 

Crear/Editar los tiles que necesitamos

Vamos a dirigirnos a la escena donde guardemos los TileSet del juego, tenemos que seleccionar los tiles por los que queremos pasar sin activar la colisión, recuerden que la colisión se activará cuando nos encontremos encima del tile. 

Yo quiero que el único tile que me permita pasar entre él, sea el que tiene grama. Para eso abrimos su CollisionShape y activamos la propiedad OneWayCollision, así nos saldrá una línea indicando que sólo se activará la colisión cuando el jugador caiga en la parte de arriba del bloque.

Ya con esto podemos pasar entre el sin activar su colisión. Un bonito efecto para un juego de plataformas. 

Instanciar balas de nave espacial en Godot Engine

Una buena parte de los desarolladores indie han realizado un “Space Shooter” en su vida. Si quieres aprender a realizar los “disparos” con una nave espacial desde Godot, pasemos al artículo.

Nodos para la nave del jugador

Doy por hecho que su nave ya esta preparada: es un nodo KinematicBody2D y tiene su imagen. Además de eso, vamos a crear un nuevo nodo llamado “Position2D”, seguro adivinarán que se trata de una posición que podemos asignar en cualquier parte de la escena. La colocamos por encima del jugador, a cierta distancia.

Escena de la bala

La bala se creará por separado. Al igual que el jugador, su nodo principal es un KinematicBody2D que llamaremos “Bala”. Dentro de ella crearemos su Sprite y el CollisionShape2D, la guardamos con Control+S y añadimos un nuevo Script.

Script de la bala

Tienen permiso para eliminar todas las líneas de comentario. En el principio vamos a añadir dos variables:

var dir = -1
var speed = 500

La variable “dir” define la dirección que debe tomar la bala cuando es instanciada en la escena. Si es -1 subirá y en 1 bajará.

Activamos la función “_process()” y dentro de ella ponemos lo siguiente:

func _process(delta):
	var move = move_and_collide(Vector2(0,dir*speed*delta))
	if move != null:
		if move.collider.is_in_group("Enemigos"):
			move.collider.queue_free()
		elif move.collider.is_in_group("Jugador"):
			move.collider.queue_free()
		
		self.queue_free()
	
	if global_position.y > 720 || global_position.y < 0:
		self.queue_free()

La variable “move” sólo se puede usar dentro de la función _process(), es una variable local. Le ponemos un “move and collide” de valor, ya que esa función se usa para mover cuerpos Kinematic y consume menos recursos que un “move_and slide”. Al ser una función de movimiento, le vamos a pasar un parámetro de Vector2().

Dentro del Vector2() vamos a colocar nuestra formula de movimiento para que la bala se mueva. Su segundo parámetro corresponde al eje “Y” (el vertical). Como nuestra bala se moverá hacía arriba, sólo usaremos el eje vertical. La operación “dir*speed*delta” hará que cada segundo se aplique la aceleración en la bala, así veremos como se mueve en la escena. Cuando “dir” es negativo hace que la aceleración también sea negativa, pero cuando “dir” es positivo la aceleración queda positiva y la bala se mueve para abajo.

Cuando quieran comprobar una colisión con la bala, usan lo siguiente:

if move != null:
		if move.collider.is_in_group("Enemigos"):
			move.collider.queue_free()
		elif move.collider.is_in_group("Jugador"):
			move.collider.queue_free()

En caso de que la variable “move” no valga “null”, significa que chocamos con algo. Para saberlo usamos “move.collider” eso indica con que nodo chocamos. Ustedes se pueden inventar muchas cosas a partir de eso, yo pondré esto:

Si el “collider” sea quien sea, se encuentra en el grupo de “Enemigos” o “Jugador”, entonces elimina al collider.

Además, cada vez que la variable “move” sea verdadera eliminamos a la bala con self.queue_free().

Por último en el script de la “bala”, vamos a decir que si la posición en el eje «Y» es mayor que “720” (El 720 lo pueden cambiar por el tamaño de pantalla en “altura” que tengan en la configuración de ventana), entonces se autodestruye. En caso de que sea menor que 0, también la autodestruyes. Cuando sea menor que 0 es porque salió de la pantalla y esta muy alto.

Aquí cambiamos el 720 de altura por el numero que quieran…

Script del jugador

Ya que tenemos una bala para instanciar, vamos con el script del jugador. Primero vamos a añadir esta variable:

var bala = load("res://Bala/Bala.tscn")

Con el «load» estamos cargando un recurso de nuestra carpeta de proyecto. La ruta de la escena que contiene la bala la podemos obtener así:

Clic derecho en el recurso que queramos y después «Copiar ruta»

En la función _process() del jugador añadimos lo siguiente:

if Input.is_action_just_pressed("disparar"):
		_disparar()

El «Input.is_action_just_pressed()» va a ser verdadero cada vez que se presione una vez la acción que indiquemos como parámetro, en este caso estoy usando una acción llamada «disparar». La podemos crear de la siguiente manera:

La función _disparar() tampoco esta creada, la vamos a definir para poner el siguiente código:

func _disparar():
	var newBala = bala.instance()
	get_parent().add_child(newBala)
	newBala.global_position = $pos_bala.global_position
	newBala.dir = -1

Cada vez que hagamos clic en el botón de espacio (se active la acción disparar), una nueva variable «newBala» creará una instancia de la variable bala que creamos arriba.

Esa nueva instancia se volverá hija del padre del jugador. Con get_parent estamos accediendo al nodo que sea padre de la escena portadora del script, en nuestro caso, el jugador es el que esta usando el «get_parent». Ya con el add_child estamos colocando a la nueva instancia como hija del padre (hermana del jugador :p).

Recuerden que para acceder a las propiedades de un nodo sólo tienen que poner el «.» después de una variable que contenga la instancia del nodo. newBala contiene al nodo de la bala, si usamos un «.» vamos a poder acceder a sus propiedades. Colocamos su posición global igual a la posición global del nodo «pos_bala» que fue el nodo que añadimos junto con entrar en el tutorial.

Con el signo de dólar ($) podemos acceder a los nodos que sean hijos del portador del script. En nuestro caso desde el jugador podemos acceder al pos_bala, el Sprite y el CollisionShape.

Ya con esto hemos terminado el tutorial. Espero que sea de su agrado y aprendan algo :).

Puedes acceder al código del proyecto buscando «SpaceShip» en la Biblioteca De demos: https://gitlab.com/indielibre/bdd/