133 proyectos que se abren directamente en el editor. Todos son GDScript puro que arma su propia escena, así que no hay nada que importar.
Una pelota cruzando la pantalla y rebotando en los bordes. El bucle más pequeño que hay: lee el delta, mueve, invierte la velocidad.
Dos formas persiguiendo el mismo objetivo, una con lerp y otra con move_toward. La diferencia entre ambas es toda la lección.
Tres Node2D anidados y dos rotaciones. El hijo orbita porque el padre gira, y el nieto orbita al hijo.
El fugitivo huye del ratón y el perseguidor sigue al fugitivo. Ambos usan direction_to, solo cambia el signo.
Una nave estilo Asteroids y ocho rocas que salen por un borde y vuelven por el otro. Dos llamadas a wrapf lo hacen.
Un Line2D que gana un punto donde está el puntero y suelta el más viejo cuando se llena. La curva de ancho y el degradado hacen el desvanecido.
Mantén el botón izquierdo para dibujar. Cada trazo es un Line2D nuevo, y el botón derecho limpia el lienzo.
Una Curve2D construida punto a punto, dibujada con tessellate y recorrida por tres PathFollow2D. El progreso es lo único que cambia.
Un muelle críticamente amortiguado y un seguidor con lerp rastreando el mismo objetivo en movimiento. El muelle aguanta el ritmo, el lerp se queda atrás.
Una posición libre moviéndose en bucle y la misma posición pasada por snapped. El cuadrado azul solo se para en nodos de la rejilla.
Nueve formas en la misma onda senoidal, cada una un paso de fase por delante de la anterior. Sin Tween y sin AnimationPlayer.
La misma constante de velocidad aplicada con y sin delta, con la distancia recorrida en cada fila. La segunda solo es rápida en la medida de la tasa de fotogramas.
Gravedad, salto y detección de suelo con CharacterBody2D, sobre plataformas construidas por código.
Dieciséis cajas soltadas entre dos paredes. Lo primero que probar cuando quieres ver trabajar al solver.
Doce eslabones unidos entre sí y un peso al final. Haz clic para empujar la cadena y verla asentarse.
Tres muelles con la misma longitud de reposo y distinta rigidez y amortiguación, uno al lado del otro.
Una zona que cuenta lo que cae por ella, usando las señales body_entered y body_exited.
Veintiocho rayos abiertos en abanico hacia el ratón. Cada uno se pone rojo donde choca con un muro, que es línea de visión en su forma más simple.
Una caja que pregunta dónde se detendría antes de moverse. El fantasma es la fracción segura que devuelve el cast.
Salta a través de las plataformas azules desde abajo y aterriza sobre ellas desde arriba. Una propiedad hace todo eso.
Tres pelotas soltadas desde la misma altura con tres ajustes de PhysicsMaterial. El valor de bounce es toda la diferencia.
Dos cintas que no se mueven ni un píxel. constant_linear_velocity arrastra lo que las esté tocando.
Un muro de 54 cajas y un clic que las aparta, con la fuerza cayendo con la distancia.
Haz clic para soltar un RigidBody3D en el suelo y ver cómo se apila. Los que creas se limpian solos a los diez segundos.
Veinte piezas en una curva y un impulso en la primera. Todo lo demás es el solver.
Una puerta sujeta por una bisagra con límite de ángulo. Haz clic para empujarla y ver dónde el límite corta el giro.
Tres cubos SoftBody3D cayendo con distinta rigidez. Es la propia malla la que se deforma.
Un emisor que sigue al ratón, con una textura de punto procedural y una rampa de color. Partículas de CPU, que son las que dibuja el renderizador web.
Una capa de chispas one_shot sobre una capa de humo one_shot, reiniciadas juntas. Haz clic para mover la explosión, o espera a que el temporizador la dispare otra vez.
Un punto recorriendo una ruta y un emisor que solo funciona mientras se mueve. emitting sale de la velocidad medida, y local_coords deja la estela atrás.
Dos emisores apilados con rampas de color distintas, una llama aditiva y una columna de humo encima. Haz clic para soplar una brisa a través de ambos.
Lluvia con el lifetime ajustado a la caída, y un pool de emisores one_shot estallando en la línea del suelo. Haz clic para añadir tu propia salpicadura.
Dos cañones disparando tiras de papel con gravedad y giro. Un color_initial_ramp constante le da a cada trozo un color plano de la paleta.
Los controles básicos en una sola pantalla, cada uno reportando al mismo label a través de su señal.
Las mismas cuatro cajas entregadas a cuatro contenedores. El layout en Godot es elegir quién ordena a los hijos.
Seis paneles fijados con presets de layout. Redimensiona el panel del juego y cada uno mantiene su esquina.
Los mismos tres nodos dos veces, y la diferencia es un puñado de add_theme.
Negrita, color, wave, shake y rainbow, todo con etiquetas BBCode dentro de un label. Sin ningún nodo de animación de por medio.
Un Timer llenando una barra, con pausa y reanudación. La barra lee time_left, no cuenta por su cuenta.
Fichas moviéndose entre ranuras. Tres métodos lo hacen todo: _get_drag_data, _can_drop_data y _drop_data.
Un árbol de escena con dos columnas, construido desde un diccionario anidado por una función recursiva.
Un ItemList con selección múltiple, quitando las filas seleccionadas y devolviéndolas.
Un panel lateral y tres pestañas repartiéndose el ancho. Arrastra el divisor y ambos lados acompañan.
Cuatro nodos con puertos que conectas arrastrando. GraphEdit dibuja la curva, aceptar la conexión es cosa tuya.
El selector completo conectado a una vista previa en vivo, al valor hex y a una fila de muestras guardadas.
Un menú contextual y dos diálogos, cada uno respondiendo por su propia señal.
Nueve botones enlazados en anillo por focus_neighbor, recorridos con tab y las flechas. Interfaz que funciona sin ratón.
Un stick que se sujeta a su anillo y conduce un punto. En un móvil el mismo código responde al tacto.
Seis tarjetas en una rejilla que pasa de tres columnas a dos cuando la viewport se estrecha.
Las seis mallas primitivas en un anillo que gira, cada una con su propio material: metal, rugoso y emisivo.
Una rejilla de 196 cubos montados en una onda senoidal. Dos bucles anidados al montarla, una línea de matemáticas por fotograma.
WASD conduciendo un CharacterBody3D entre pilares, con una cámara que va detrás. Sin mirar con el ratón.
Arrastra con el botón izquierdo para girar la cámara alrededor de la pieza central, y usa la rueda para el zoom. Yaw, pitch y distancia son todo el estado.
Ocho conos ejecutando look_at sobre el mismo orbe en movimiento. Una llamada por fotograma sustituye toda la trigonometría.
Pivotes Node3D anidados, cada uno girando a su ritmo. Una luna orbita su planeta y hereda la órbita del planeta gratis.
Una caja mantenida en intersección con una esfera, perforada por tres cilindros que alternan entre sustracción, unión e intersección cada dos segundos.
Cuatro mil árboles dibujados por dos nodos MultiMeshInstance3D, con un color por instancia en las copas.
Gemas Sprite3D en billboard sobre una textura pintada píxel a píxel en código, cada una nombrada por un Label3D. El cartel del centro deja el billboard apagado para comparar.
La misma geometría y el mismo material blanco tres veces. Una cull mask le da a cada luz su tercio de la escena.
Esferas metálicas reflejando una sala de colores sin reflejos en espacio de pantalla. Tres valores de rugosidad muestran lo rápido que el espejo se vuelve borrón.
Cinco cajas y cinco Transform3D escritos a mano: identidad, origen, Basis rotada, Basis escalada y los tres combinados. Un fantasma marca dónde está la identidad.
Un shader de canvas a pantalla completa animado por TIME. Cambia un uniform, guarda, y el proyecto se recarga.
El sprite guarda índices de paleta en vez de colores, así que rotar la paleta repinta todo el arte.
Curvatura, scanlines y separación cromática sobre una escena 2D normal. Todo el aspecto es una sola pasada a pantalla completa.
Desaturación, viñeta y grano de película sobre una escena 3D, en once líneas que leen la textura de pantalla.
Una esfera cuyos vértices montan una onda mientras la emisión late, escrita en un shader spatial.
Una textura de ruido creada en GDScript y un discard en el shader, con un borde ardiendo en el umbral.
El ángulo entre la normal y la vista, elevado a una potencia. Tres formas, tres potencias de borde.
Iluminación dividida en bandas dentro de la función light del shader, con un punto especular duro.
Un atardecer procedural con estrellas, escrito como shader_type sky. El disco del sol sigue al nodo de luz.
Un quad delante de la cámara leyendo DEPTH_TEXTURE, así la niebla sabe a qué distancia está cada píxel.
Ruido empujando la UV de pantalla, enmascarado a la mitad de abajo para que la diferencia sea fácil de ver.
Olas en el vertex shader con la normal recalculada desde la derivada, así la luz las acompaña.
Un plano y ninguna textura. fwidth mantiene cada línea de un píxel de ancho por lejos que esté la cámara.
Cuatro mallas sin mapa UV, texturizadas proyectando desde los tres ejes del mundo y mezclando por la normal.
Los seis tipos de FastNoiseLite uno al lado del otro, misma semilla y sin fractal, para que se vea el carácter de cada uno.
Un mapa de altura convertido en ArrayMesh con SurfaceTool, coloreado por altura mediante colores de vértice.
Ruido multiplicado por una máscara radial y pintado en una Image banda a banda. Haz clic para otra isla.
Un laberinto perfecto excavado por backtracking. Los pasillos aparecen en el orden en que se abrieron, coloreados por ese orden.
Salas colocadas sin solaparse, y luego un paseo aleatorio cavando el pasillo entre cada par.
Una cadena reescrita cuatro veces por dos reglas y luego leída como movimientos de tortuga, un Line2D por rama.
El ruido le da un ángulo a cada punto de la pantalla. Las flechas muestran el campo y las partículas lo siguen.
El contorno de un campo de ruido, redibujado según barre el umbral. El campo nunca cambia, solo el corte.
Una malla limpiada y reconstruida vértice a vértice cada fotograma, con una tira de líneas y una superficie de líneas.
El mismo sólido generado dos veces con SurfaceTool, plano y suave. Solo cambia el grupo de suavizado.
Una MeshLibrary construida en tiempo de ejecución y un GridMap rellenado desde un mapa de altura, un cubo por celda.
Un TileSet cuyo atlas es una Image pintada píxel a píxel, colocada celda a celda en un TileMapLayer.
Tres llamadas de Geometry2D con el resultado dibujado: intersección de polígonos, envolvente convexa y offset de polígono.
Una región de navegación generada por código y un agente recorriendo cuatro esquinas por ella. Haz clic en cualquier sitio para mandarlo a otro lado.
La misma idea en tres dimensiones, con la NavigationMesh generada de mallas primitivas al cargar. Haz clic en el suelo para elegir destino.
Tres obstáculos entrando y saliendo de la malla de navegación. Cada cambio regenera la región y el agente toma el carril que siga abierto.
Una rejilla donde los muros bloquean celdas y las amarillas cuestan seis veces más de cruzar. El resultado es la ruta más barata, no la más corta.
Cuarenta puntos enlazados por distancia, con AStar2D trazando ruta entre dos de ellos. Aquí nada es una rejilla, el grafo es lo que tú conectes.
Buscar y huir son las mismas dos líneas con un signo cambiado. Los vectores dibujados son la velocidad deseada, la actual y la diferencia entre ambas.
Cada agente apunta a un punto que solo se desliza un poco alrededor de un círculo delante de él. Eso es lo que hace que deambular parezca intención y no ruido.
Setenta y dos boids ejecutando separación, alineación y cohesión contra todo lo que hay dentro de un radio pequeño. Cada uno se colorea según cuántos vecinos ve.
Un enum y un bloque match llevando patrulla, persecución y regreso. La tira de abajo son los últimos segundos de estado.
Una Camera2D con suavizado de posición y las cuatro propiedades de límite. La cruz amarilla es el centro de la cámara, así puedes verla detenerse en el borde mientras el jugador sigue andando.
Trauma que decae con el tiempo, muestreado de FastNoiseLite hacia el offset y la rotación de la cámara. Una explosión dispara cada 1,2 segundos y el slider la escala.
Arrastra para mover y gira la rueda para hacer zoom en el puntero en vez del centro de la pantalla, que son dos líneas de matemáticas sobre Camera2D.zoom.
Una escena 3D renderizada dentro de un SubViewport y mostrada como la textura de un monitor que está en una pantalla 2D.
Dos SubViewports lado a lado con una cámara cada uno, ambos mirando al mismo World3D. Cada panel sigue su propio cubo.
Una Camera2D alejada en un SubViewport que comparte el World2D del juego. El HUD está fuera de ese mundo, por eso no aparece en el mapa.
Tres capas Parallax2D con distinto scroll_scale, repetidas por repeat_size para que las crestas nunca se acaben mientras la cámara avanza.
Un SpringArm3D que acerca la cámara cuando una pared se mete entre ella y el personaje. El panel compara spring_length con el largo que el brazo consiguió de verdad.
Cinco cuadrados cruzando la pantalla, uno por curva de transición. La forma más rápida de ver qué hace cada easing.
Un tween ejecutando cuatro pasos seguidos. tween_callback enciende el paso en pantalla y parallel pone dos propiedades en el mismo paso.
Una pista de posición y otra de color escritas clave a clave al arrancar, sin ningún archivo .anim. La línea de tiempo de abajo muestra las mismas claves que insertó el código.
Una Curve construida punto a punto y leída con sample(t). La gráfica se dibuja del mismo recurso que mueve el cuadrado, junto a otro movido solo por el tiempo.
Un ciclo de caminata de ocho fotogramas pintado en buffers de Image al arrancar y entregado a un AnimatedSprite2D. La tira de abajo es el propio SpriteFrames.
Un brazo articulado hecho de un solo Polygon2D con skin en dos huesos. Girar un Bone2D mueve los vértices que tienen peso en él.
El mismo salto con el mismo tiempo en ambos lados, y solo el de la derecha hace tween de la escala. Tres líneas de más son toda la diferencia.
Reposo, preparación, embestida y recuperación, cada uno con su tween. Entrar en un estado mata el tween del anterior, así nunca pelean por la misma propiedad.
Una cadena de seis huesos creada por código y colocada cada fotograma con set_bone_pose_rotation. Cada BoneAttachment3D lleva la malla que viaja con su hueso.
Seno, cuadrada y sierra escritas muestra a muestra en un AudioStreamGenerator. El Line2D dibuja la misma onda con la que se está llenando el buffer.
Un barrido generado enrutado a su propio bus y medido por AudioEffectSpectrumAnalyzer. El marcador es la frecuencia de la fuente, las barras son lo que lee el analizador.
Una rejilla de notas clicable corriendo en bucle. Cada celda encendida suma una voz que decae al mismo buffer generado.
Cuerpos cayendo entre clavos, con un blip creado en código y reafinado por pitch_scale según la velocidad con la que cada cuerpo llegó al impacto.
Un pluck generado enrutado de Voice a FX y de ahí a Master, con reverb y distorsión que puedes activar y el nivel de pico de cada bus en pantalla.
Una fuente en movimiento con max_distance y attenuation, junto a una barra que muestra la misma caída que AudioStreamPlayer2D aplica al tono generado.
Cinco acciones creadas con InputMap.add_action al arrancar, ninguna declarada en los ajustes del proyecto. El panel lista las teclas de cada una y se enciende mientras está pulsada.
Sticks, gatillos y botones leídos directo de Input y dibujados según se mueven. Sin nada conectado lo avisa, y las flechas siguen moviendo el vector de ui.
Los cuatro valores de Input.mouse_mode tras cuatro botones. El punto viaja con event.relative, que es lo que sigue funcionando una vez capturado el puntero.
Arrastra una tarjeta con un dedo y haz pinza con dos. El mismo manejador cae en el botón del ratón y la rueda, que es el camino de un navegador de escritorio.
Haz clic en una tecla, pulsa otra, y la acción se muda a ella. Robarle la tecla a otra acción deja a esa sin asignar, que es el caso que una pantalla de reasignación tiene que resolver.
Un nodo declara una señal y nunca se entera de quién escucha. Cinco paneles se conectan a ella y se encienden cuando les toca.
Setenta y dos cuadrados repartidos en cuatro grupos. Un call_group alcanza a todos los miembros de un bloque sin una sola referencia.
Un diccionario con el estado de la escena escrito en user:// como JSON, con el contenido del archivo al lado de los valores en vivo.
Un Resource con class_name usado como dato tipado. Seis ítems comparten el script y cada tarjeta se redibuja con la señal changed.
Dos fuentes emitiendo al mismo ritmo, una reservando cada partícula y otra tomándolas de un pool. Los contadores son los que discuten.
Fotogramas por segundo, memoria estática y número de nodos muestreados cada fotograma en tres gráficas vivas, mientras una oleada de nodos se crea y se elimina.
Tres columnas de tres generadores. Los dos que comparten semilla producen los mismos números siempre, el tercero no.
Seis operaciones guardadas en un array como Callables, cinco lambdas y un método con bind, cada una entregada a Array.map sobre los mismos números.