133 projetos que abrem direto no editor. Todos são GDScript puro que monta a própria cena, então não há nada para importar.
Uma bola atravessando a tela e quicando nas bordas. O menor loop que existe: lê o delta, move, inverte a velocidade.
Duas formas perseguindo o mesmo alvo, uma com lerp e outra com move_toward. A diferença entre elas é a lição inteira.
Três Node2D aninhados e duas rotações. O filho orbita porque o pai gira, e o neto orbita o filho.
O fugitivo foge do mouse e o perseguidor segue o fugitivo. Os dois usam direction_to, só o sinal muda.
Uma nave estilo Asteroids e oito pedras que saem por uma borda e voltam pela outra. Duas chamadas de wrapf fazem isso.
Um Line2D que ganha um ponto onde o ponteiro está e descarta o mais antigo quando enche. A curva de largura e o gradiente fazem o desvanecer.
Segure o botão esquerdo para desenhar. Cada traço é um Line2D novo, e o botão direito limpa a tela.
Uma Curve2D montada ponto a ponto, desenhada com tessellate e percorrida por três PathFollow2D. O progresso é a única coisa que muda.
Uma mola criticamente amortecida e um seguidor com lerp rastreando o mesmo alvo em movimento. A mola acompanha, o lerp fica para trás.
Uma posição livre andando em loop e a mesma posição passada por snapped. O quadrado azul só para em nós da grade.
Nove formas na mesma onda senoidal, cada uma um passo de fase à frente da anterior. Sem Tween e sem AnimationPlayer.
A mesma constante de velocidade aplicada com e sem delta, com a distância percorrida em cada linha. A segunda só é rápida na medida da taxa de quadros.
Gravidade, pulo e detecção de chão com CharacterBody2D, sobre plataformas construídas por código.
Dezesseis caixas soltas entre duas paredes. A primeira coisa para experimentar quando você quer ver o solver trabalhando.
Doze elos presos uns nos outros e um peso na ponta. Clique para empurrar a corrente e veja ela se acomodar.
Três molas com o mesmo comprimento de repouso e rigidez e amortecimento diferentes, lado a lado.
Uma zona que conta o que cai por ela, usando os sinais body_entered e body_exited.
Vinte e oito raios abertos em leque na direção do mouse. Cada um fica vermelho onde bate numa parede, que é linha de visão na forma mais simples.
Uma caixa que pergunta onde pararia antes de se mover. O fantasma é a fração segura que o cast devolve.
Pule através das plataformas azuis por baixo e pouse nelas por cima. Uma propriedade faz tudo isso.
Três bolas soltas da mesma altura com três configurações de PhysicsMaterial. O valor de bounce é toda a diferença.
Duas esteiras que não andam um pixel. O constant_linear_velocity arrasta o que estiver encostando nelas.
Uma parede de 54 caixas e um clique que as afasta, com a força caindo pela distância.
Clique para soltar um RigidBody3D no chão e veja a pilha crescer. Os que você cria se limpam sozinhos depois de dez segundos.
Vinte peças numa curva e um impulso na primeira. Tudo depois disso é o solver.
Uma porta presa por uma dobradiça com limite de ângulo. Clique para empurrar e veja onde o limite trava o giro.
Três cubos SoftBody3D caindo com rigidez diferente. É a própria malha que deforma.
Um emissor que segue o mouse, com uma textura de ponto procedural e uma rampa de cor. Partículas de CPU, que são as que o renderizador web desenha.
Uma camada de faíscas one_shot sobre uma camada de fumaça one_shot, reiniciadas juntas. Clique para mover a explosão, ou espere o timer disparar de novo.
Um ponto percorrendo uma rota e um emissor que só roda enquanto ele se move. O emitting vem da velocidade medida, e o local_coords deixa o rastro para trás.
Dois emissores empilhados com rampas de cor diferentes, uma chama aditiva e uma coluna de fumaça acima dela. Clique para soprar uma brisa nos dois.
Chuva com o lifetime dimensionado para a queda, e um pool de emissores one_shot estourando na linha do chão. Clique para acrescentar o seu respingo.
Dois canhões disparando tiras de papel com gravidade e giro. Um color_initial_ramp constante entrega a cada pedaço uma cor chapada da paleta.
Os controles básicos numa tela só, cada um reportando ao mesmo label através do seu sinal.
As mesmas quatro caixas entregues a quatro containers. Layout no Godot é escolher quem organiza os filhos.
Seis painéis fixados com presets de layout. Redimensione o painel do jogo e cada um mantém o seu canto.
Os mesmos três nós duas vezes, e a diferença é um punhado de add_theme.
Negrito, cor, wave, shake e rainbow, tudo isso em tags BBCode dentro de um label. Sem nenhum nó de animação envolvido.
Um Timer enchendo uma barra, com pausar e retomar. A barra lê o time_left, ela não conta sozinha.
Fichas passando de um slot para outro. Três métodos fazem tudo: _get_drag_data, _can_drop_data e _drop_data.
Uma árvore de cena com duas colunas, construída de um dicionário aninhado por uma função recursiva.
Um ItemList com seleção múltipla, removendo as linhas selecionadas e devolvendo elas.
Um painel lateral e três abas dividindo a largura. Arraste o divisor e os dois lados acompanham.
Quatro nós com portas que você liga arrastando. O GraphEdit desenha a curva, aceitar a conexão é decisão sua.
O seletor completo ligado a uma prévia ao vivo, ao valor em hex e a uma fileira de amostras salvas.
Um menu de contexto e dois diálogos, cada um respondendo pelo próprio sinal.
Nove botões ligados em anel pelo focus_neighbor, percorridos com tab e as setas. Interface que funciona sem mouse.
Um analógico que se prende ao seu anel e conduz um ponto. No celular o mesmo código responde ao toque.
Seis cards numa grade que vai de três colunas para duas quando a viewport fica estreita.
As seis malhas primitivas num anel girando, cada uma com o próprio material: metal, rugoso e emissivo.
Uma grade de 196 cubos surfando uma onda senoidal. Dois loops aninhados na montagem, uma linha de matemática por quadro.
WASD conduzindo um CharacterBody3D entre pilares, com uma câmera que vem atrás. Sem olhar com o mouse.
Arraste com o botão esquerdo para girar a câmera em volta da peça central, e use a roda para dar zoom. Yaw, pitch e distância são todo o estado.
Oito cones rodando look_at no mesmo orbe em movimento. Uma chamada por quadro substitui toda a trigonometria.
Pivôs Node3D aninhados, cada um girando no próprio ritmo. Uma lua orbita seu planeta e herda a órbita do planeta de graça.
Uma caixa mantida em interseção com uma esfera, furada por três cilindros que alternam entre subtração, união e interseção a cada dois segundos.
Quatro mil árvores desenhadas por dois nós MultiMeshInstance3D, com uma cor por instância nas copas.
Gemas Sprite3D em billboard sobre uma textura pintada pixel a pixel em código, cada uma nomeada por um Label3D. A placa do centro mantém o billboard desligado para comparação.
A mesma geometria e o mesmo material branco três vezes. Uma cull mask dá a cada luz o seu terço da cena.
Esferas metálicas espelhando uma sala colorida sem reflexos em espaço de tela. Três valores de rugosidade mostram como o espelho vira borrão.
Cinco caixas e cinco Transform3D escritos à mão: identidade, origem, Basis rotacionada, Basis escalada e os três combinados. Um fantasma marca onde fica a identidade.
Um shader de canvas em tela cheia animado pelo TIME. Mude um uniform, salve, e o projeto recarrega.
O sprite guarda índices de paleta em vez de cores, então trocar a paleta repinta a arte inteira.
Curvatura, scanlines e separação cromática sobre uma cena 2D comum. O visual inteiro é um passe em tela cheia.
Dessaturação, vinheta e grão de filme sobre uma cena 3D, em onze linhas que leem a textura da tela.
Uma esfera cujos vértices surfam uma onda enquanto a emissão pulsa, escrita num shader spatial.
Uma textura de ruído gerada em GDScript e um discard no shader, com uma borda em brasa no limiar.
O ângulo entre a normal e a visão, elevado a uma potência. Três formas, três potências de contorno.
Iluminação dividida em faixas dentro da função light do shader, com um ponto especular duro.
Um pôr do sol procedural com estrelas, escrito como shader_type sky. O disco do sol segue o nó de luz.
Um quad na frente da câmera lendo a DEPTH_TEXTURE, então a névoa sabe a que distância está cada pixel.
Ruído empurrando a UV da tela, mascarado para a metade de baixo para a diferença ficar fácil de ver.
Ondas no vertex shader com a normal recalculada pela derivada, então a luz acompanha as ondas.
Um plano e nenhuma textura. O fwidth mantém cada linha com um pixel de largura, não importa a distância da câmera.
Quatro malhas sem mapa de UV, texturizadas por projeção dos três eixos do mundo e mescladas pela normal.
Os seis tipos de FastNoiseLite lado a lado, mesma seed e sem fractal, para o caráter de cada um aparecer.
Um mapa de altura virando uma ArrayMesh com SurfaceTool, colorido por altura através de cores de vértice.
Ruído multiplicado por uma máscara radial e pintado numa Image faixa por faixa. Clique para outra ilha.
Um labirinto perfeito escavado por backtracking. As passagens aparecem na ordem em que foram abertas, coloridas por essa ordem.
Salas posicionadas sem se sobrepor, e um passeio aleatório cavando o corredor entre cada par.
Uma string reescrita quatro vezes por duas regras e depois lida como movimentos de tartaruga, um Line2D por galho.
O ruído dá um ângulo a cada ponto da tela. As setas mostram o campo e as partículas o seguem.
O contorno de um campo de ruído, redesenhado conforme o limiar varre. O campo nunca muda, só o corte.
Uma malha limpa e reconstruída vértice a vértice a cada quadro, com uma tira de linhas e uma superfície de linhas.
O mesmo sólido gerado duas vezes pelo SurfaceTool, plano e suave. Só o grupo de suavização muda.
Uma MeshLibrary montada em tempo de execução e um GridMap preenchido por um mapa de altura, um cubo por célula.
Um TileSet cujo atlas é uma Image pintada pixel a pixel, colocada célula a célula num TileMapLayer.
Três chamadas de Geometry2D com o resultado desenhado: interseção de polígonos, envoltória convexa e offset de polígono.
Uma região de navegação gerada por código e um agente percorrendo quatro cantos por ela. Clique em qualquer lugar para mandá-lo para outro ponto.
A mesma ideia em três dimensões, com a NavigationMesh gerada de malhas primitivas no carregamento. Clique no chão para escolher o destino.
Três obstáculos entrando e saindo da malha de navegação. Cada troca refaz a região e o agente pega a faixa que ainda estiver aberta.
Uma grade onde paredes bloqueiam células e as amarelas custam seis vezes mais para atravessar. O resultado é a rota mais barata, não a mais curta.
Quarenta pontos ligados por distância, com o AStar2D traçando rota entre dois deles. Nada aqui é uma grade, o grafo é o que você conectar.
Buscar e fugir são as mesmas duas linhas com um sinal trocado. Os vetores desenhados são a velocidade desejada, a atual e a diferença entre elas.
Cada agente mira num ponto que desliza só um pouco em torno de um círculo à frente dele. É isso que faz perambular parecer intenção em vez de ruído.
Setenta e dois boids rodando separação, alinhamento e coesão contra tudo dentro de um raio pequeno. Cada um é colorido por quantos vizinhos consegue ver.
Um enum e um bloco match conduzindo patrulha, perseguição e retorno. A tira embaixo são os últimos segundos de estado.
Uma Camera2D com suavização de posição e as quatro propriedades de limite. A cruz amarela é o centro da câmera, então dá para vê-la parar na borda enquanto o jogador continua andando.
Trauma decaindo com o tempo, amostrado do FastNoiseLite para o offset e a rotação da câmera. Uma explosão dispara a cada 1,2 segundo e o slider escala o efeito.
Arraste para mover e role a roda para dar zoom no ponteiro em vez do centro da tela, o que são duas linhas de matemática em cima do Camera2D.zoom.
Uma cena 3D renderizada dentro de um SubViewport e mostrada como a textura de um monitor que fica numa tela 2D.
Dois SubViewports lado a lado com uma câmera cada, os dois olhando para o mesmo World3D. Cada painel segue o próprio cubo.
Uma Camera2D afastada num SubViewport que compartilha o World2D do jogo. O HUD fica fora desse mundo, que é por isso que ele não aparece no mapa.
Três camadas Parallax2D com scroll_scale diferente, repetidas pelo repeat_size para as cristas nunca acabarem enquanto a câmera anda.
Um SpringArm3D que puxa a câmera para perto quando uma parede entra entre ela e o personagem. O painel compara o spring_length com o comprimento que o braço realmente conseguiu.
Cinco quadrados atravessando a tela, um por curva de transição. O jeito mais rápido de ver o que cada easing faz.
Um tween rodando quatro passos em fila. O tween_callback acende o passo na tela e o parallel põe duas propriedades no mesmo passo.
Uma track de posição e uma de cor escritas chave por chave no início, sem nenhum arquivo .anim. A linha do tempo abaixo mostra as mesmas chaves que o código inseriu.
Uma Curve montada ponto a ponto e lida com sample(t). O gráfico é desenhado do mesmo recurso que move o quadrado, ao lado de um quadrado movido só pelo tempo.
Um ciclo de caminhada de oito quadros pintado em buffers de Image no início e entregue a um AnimatedSprite2D. A tira embaixo é o próprio SpriteFrames.
Um braço articulado feito de um único Polygon2D com skin em dois ossos. Girar um Bone2D move os vértices com peso nele.
O mesmo pulo com o mesmo tempo dos dois lados, e só o da direita faz tween na escala. Três linhas a mais são toda a diferença.
Parado, preparação, avanço e recuperação, cada um com seu tween. Entrar num estado mata o tween do anterior, então eles nunca brigam pela mesma propriedade.
Uma corrente de seis ossos criada por código e posicionada a cada quadro com set_bone_pose_rotation. Cada BoneAttachment3D carrega a malha que anda com o seu osso.
Senoide, quadrada e dente de serra escritas amostra por amostra num AudioStreamGenerator. O Line2D desenha a mesma onda com que o buffer está sendo preenchido.
Uma varredura gerada roteada para o próprio bus e medida pelo AudioEffectSpectrumAnalyzer. O marcador é a frequência da fonte, as barras são o que o analisador lê.
Uma grade de notas clicável rodando em loop. Cada célula acesa soma uma voz que decai ao mesmo buffer gerado.
Corpos caindo por pinos, com um blip criado em código e reafinado pelo pitch_scale a partir da velocidade que cada corpo trouxe para o impacto.
Um pluck gerado roteado de Voice para FX e daí para Master, com reverb e distorção que você liga e o nível de pico de cada bus na tela.
Uma fonte em movimento com max_distance e attenuation, ao lado de uma barra mostrando a mesma queda que o AudioStreamPlayer2D aplica ao tom gerado.
Cinco ações criadas com InputMap.add_action no início, nenhuma delas declarada nas configurações do projeto. O painel lista as teclas de cada uma e acende enquanto ela está pressionada.
Analógicos, gatilhos e botões lidos direto do Input e desenhados conforme se movem. Sem nada conectado ele avisa, e as setas continuam movendo o vetor de ui.
Os quatro valores de Input.mouse_mode atrás de quatro botões. O ponto anda pelo event.relative, que é o que continua funcionando depois que o ponteiro é capturado.
Arraste um card com um dedo e faça pinça com dois. O mesmo handler cai no botão do mouse e na roda, que é o caminho de um navegador no desktop.
Clique numa tecla, pressione outra, e a ação passa para ela. Roubar a tecla de outra ação deixa aquela sem atalho, que é o caso que uma tela de remapeamento precisa tratar.
Um nó declara um sinal e nunca fica sabendo quem escuta. Cinco painéis se conectam a ele e acendem quando chega a vez de cada um.
Setenta e dois quadrados divididos em quatro grupos. Um call_group alcança todo membro de uma turma sem uma única referência.
Um dicionário com o estado da cena gravado em user:// como JSON, com o conteúdo do arquivo mostrado ao lado dos valores vivos.
Um Resource com class_name usado como dado tipado. Seis itens compartilham o script e cada card se redesenha pelo sinal changed.
Duas fontes emitindo no mesmo ritmo, uma alocando cada partícula e outra pegando de volta de um pool. Os contadores é que discutem.
Quadros por segundo, memória estática e contagem de nós amostrados a cada quadro em três gráficos vivos, enquanto uma onda de nós é criada e removida.
Três colunas de três geradores. Os dois que compartilham a seed produzem os mesmos números toda vez, o terceiro não.
Seis operações guardadas num array como Callables, cinco lambdas e um método com bind, cada uma entregue ao Array.map sobre os mesmos números.