RibaSoft

Godot 4.5

Animações

• Adicionar Animações

  • Para não ter que ficar ajustando personagem toda vez que uma nova animação é criada ou editada, basta selecionar o nó AnimationPlayer do seu personagem, depois clicar na aba "Animação" no painel inferior, depois no botão "Animação" >> Gerenciar Animações e renomear e clicar no diskete para salvar em disco ou na lixeira para excluir, etc.

• Dicas

  • Ajustar o tempo da animação.

    $AnimationPlayer.speed_scale = 0.9

  • O valor ideal para deixar a transição entre animações suaves é 0.2, pode ser atribuida pelo script.

    $AnimationPlayer.playback_default_blend_time = 0.2

    Ou pelo Inspetor selecionando o nó AnimationPlayer -> Default Blend Time.

• Gerenciar animações

  • A forma que eu achei mais coerente por enquanto de tocar as animações é essa...

    #Criar um tipo enumerado com as animações que serão usadas. enum anim {nenhum, parado, andando, correndo, pulo_inicio, caindo, pulo_pouso} const VELOCIDADE = 5.0 const VELOCIDADE_CORRENDO = 20 var AninPlayer: AnimationPlayer var AnimacaoAtual: anim func _ready() -> void: AninPlayer = $AnimationPlayer AnimacaoAtual = anim.nenhum func _physics_process(delta: float) -> void: if is_on_floor(): if AnimacaoAtual == anim.caindo: Anima(anim.pulo_pouso) if direcao != Vector3.ZERO: if Input.is_action_pressed("correr"): velocity.x = direcao.x * VELOCIDADE_CORRENDO velocity.z = direcao.z * VELOCIDADE_CORRENDO Anima(anim.correndo) else: velocity.x = direcao.x * VELOCIDADE velocity.z = direcao.z * VELOCIDADE Anima(anim.andando) else: velocity.x = move_toward(velocity.x, 0, VELOCIDADE) velocity.z = move_toward(velocity.z, 0, VELOCIDADE) Anima(anim.parado) else: velocity += get_gravity() * delta Anima(anim.caindo) move_and_slide() #Gerencia para quando uma animação que já está sendo #tocada não inicie e que nenhum animação toque enquanto #uma que precisa terminar esteja tocando func Anima(acao: anim) -> void: #Animações que precisam terminar o ciclo if AnimacaoAtual in [anim.pulo_inicio, anim.pulo_pouso]: return match acao: anim.parado: if AnimacaoAtual != acao: AninPlayer.play("parado") AnimacaoAtual = acao anim.andando: if AnimacaoAtual != acao: AninPlayer.play("andando") AnimacaoAtual = acao anim.correndo: if AnimacaoAtual != acao: AninPlayer.play("correndo") AnimacaoAtual = acao anim.pulo_inicio: if AnimacaoAtual != acao: AninPlayer.play("pulo_inicio") AnimacaoAtual = acao anim.caindo: if AnimacaoAtual != acao: AninPlayer.play("caindo") AnimacaoAtual = acao anim.pulo_pouso: if AnimacaoAtual != acao: AninPlayer.play("pulo_pouso") AnimacaoAtual = acao #Evento "Sinal" para que uma animação que precisa #terminar avise que terminou resetando a "AnimaçãoAtual" func _on_animation_player_animation_finished(anim_name: StringName) -> void: if anim_name in ["pulo_inicio", "pulo_pouso"]: AnimacaoAtual = anim.nenhum

Audio

• Reprodução de Sons e Músicas

  • O formato mais indicado para audio é o .ogg

    @onready var tocador: AudioStreamPlayer2D = $sons/musica func _ready()->void: var musica: AudioStreamOggVorbis musica = load("res://sons/musicas/fase01.ogg") musica.loop = true tocador.stream = audio tocador.play()

  Para converter audios para .ogg use o Audacity, para baixa-lo clique AQUI .

• Comandos.

  • Tocar do inicio: tocador.play()

    Totar de um ponto específico: tocador.play(10.5)

    Parar tocador.stop()

    Pausar tocador.stream_paused = true

• Som grátis

  • freesound.org

    sfxr

await

• await "Aguarde"

  • Faz com que o código espere por um sinal ser emitido para continar para a próxima linha.

    await get_tree().create_timer(t).timeout

  • Pode ser usado dentro de uma função async para chamar outras funções async.

    async func iniciar_evento(): await exibir_mensagem("Cuidado! Um inimigo se aproxima!") await mover_camera_para("inimigo") await iniciar_batalha()

  • E pode er usado com SINAIS diversos, inclusives criados por script.

    signal carregamento_concluido async func iniciar(): print("Esperando carregamento terminar...") await self.carregamento_concluido print("Carregamento finalizado!")

Barra de Energia

• TextureProgressBar

  • O Nó TextureProgressBar, é geralmente usado em jogos 2D, mas com alguns recursos é possivel usá-lo em 3D.

    Adicione um Sprite3D como filho do seu personagem, um SubViewport como filho do Sprite3D e um TextureProgressBar como filho do SubViewport.

  • No TextureProgressBar, vá ao Inpertor -> TextureProgressBar -> Textures e arraste as imagens .png para:

    Under - fundo da barra.

    Over - borda da barra.

    Progress - a barra em sí.

    
    

    No script trabalhe com as propriedades "min_value", "max_value" e "value".

  • No SubViewport, Inspertor -> SubViewport ajuste o Size X e Y para ficar do tamanho da sua barra.

    Em Viewport ative o TransparentBG para tornar o fundo transparente.

  • E no Sprite3D, em Inspetor -> Sprite3D -> Texture selecione ViewportTexture, se selecione o nó SubViewport.

    Em Inpertor -> Sprite3D -> Flags ative o Bilboard para manter o Sprite sempre virado para a câmera ativa.

BoneAttachment3D

• Movimento seguindo ossos.

  • Para fazer um objeto acompanhar o movimento de algum osso, basta adicionar como filho do Skeleton3D um BoneAttachment3D clicar em Inspetor -> BoneAttachment3D -> Bone Name e escolher o osso desejado.

    Depois disso pode-se adicionar um Area3D como filho de BoneAttachment3D e um CollisionShape3D como filho do Area3D, depois clique em Inspetor -> CollisionShape3D -> Shape e escolha CylinderShape3D por exemplo para usa-lo como campo de visão em um osso de uma cabeça que gira por exemplo.

Cenas

• Descrição

  • Arquivos .tscn são os "Objetos" na Godot, são chamadas de Cenas e são compostas por diferentes tipos de componentes conhecidos como Nós.

    Essas cenas são arquivos salvos que podem ser adicionados dentro de outras cenas a qualquer momento apenas arrastando esses arquivos para a area de trabalho da Godot, ou sendo instanciadas via código dos scripts.

• • Mudar de cena.

    const JOGO: Resource = preload("res://cenas/jogo.tscn") Cena_antiga.queue_free() var nova_cena: Node2D = JOGO.instantiate() get_tree().root.add_child(nova_cena) get_tree().current_scene = nova_cena

  • Recarregar a cena atual

    get_tree().reload_current_scene()

Configurações

• Local das configurações

  • Windows

    C:\Users\usuario\AppData\Local\Godot C:\Users\usuario\AppData\Roaming\Godot

• Projeto 2D

  • Resolução HD

    Projeto >> Configuraçõs do Projeto... >> Geral >> Exibição >> Janela >> Largura do Viewport = 1280 Altura do Viewport = 720

  • Mostrar Warning para variaveis não tipadas.

    Projeto >> Configuraçõs do Projeto... >> Geral >> Depuração >> GDScript >> Untyped Declaration

  • Definir controles

    Projeto >> Configuraçõs do Projeto... >> Mapa de entrada

  • Script Global

    Projeto >> Configuraçõs do Projeto... >> >> Selecione ou crie o arquivo

DirectionalLight3D

• Sol

  • Para criar se sol adicione ao seu mundo um DirectionalLight3D, Inspetor -> DirectionalLight3D -> Shadow -> Enabled -> Ativo

    Inspetor -> DirectionalLight3D -> Transform -> Rotation -> x -> -70.

    Em outras situações o X=-30 e o Y=-45 tambem ficam bons.

• Dia e Noite com hora baseada no sol

  • Declare no início do script do seu mundo.

    @onready var sol = $DirectionalLight3D @onready var label_hora = $CanvasLayer/VBoxContainer/Label_hora var horaStr: String var horas: float var minutos: float

  • Inicie as variáveis

    func _ready() -> void: horaStr = '00:00' horas = 0 minutos = 0

  • Chame a função em _process

    func _process(delta: float) -> void: Sol(delta)

  • Crie a função

    func Sol(Delta: float) -> void: sol.rotate(Vector3.LEFT, Delta * (-0.001)) var graus = rad_to_deg(sol.rotation.x) + 270 if graus >= 360: graus = rad_to_deg(sol.rotation.x) - 90 horas = ( graus / 15) var fracao = (hora - int(hora)) minutos = (0.6 * (fracao * 100)) if int(horas) == 17: sol.light_energy = 1 - fracao - 0.01 if sol.light_energy < 0: sol.light_energy = 0 if int(horas) == 5: sol.light_energy = fracao + 0.01 if sol.light_energy > 1: sol.light_energy = 1 horaStr = str(int(horas)) + ":" + str(int(minutos)).pad_zeros(2) label_hora.text = 'Hora: ' + horaStr

• Outras configurações

  • E aconselhavel para celular usar no Directional Shadow >> Mode >> Ortogonal e ajustar o Max Distance de acordo com o tamanho da cena.

  • Para finalizar adicione um WorldEnvironment e no Environment um Environment, isso já melhora muito a iliminação mesmo sem mexer em mais nada.

Estrutura dos Nós

Tipos de Nós

• • Node3D

    E o objeto mais primitivo da area 3D sendo filho de Node que seria o TObject em Pascal.

• • CharacterBody3D

    E o corpo físico recomndado para players e mobs, controla a colisão, fisíca e vem com um script padrão para controla a movimentação padrão.

• • RigidBody3D

    E o corpo físico recomndado para objetos, controla a colisão, fisíca dos objetos de acordo com o Shape escolhido em um filho CollisionShape3D.

• • CollisionShape3D

    É responsável por dar a forma das áreas, quando filho de um Area3D pode detectar a entrada e saida de objetos, quando filho de um StaticBody3D, RigdBody3D, ChacacterBody3D, etc é responsável pelos limites de colisão.

• • AnimationPlayer

    Responsável por armazenar e gerenciar as animações.

    Veja mais AQUI.

• • CPUParticle3D

    Responsável por intanciar vários objetos repetidamente com muitas formas de configurações, usada em vários efeitos como fumaça, explosões, etc.

    Veja mais AQUI.

• • RayCast3D

    Tem o formato de ponta e detecta coliões sem precisar de sinais ou nós adicionais através da função $RayCast3D.is_colliding().

  Propriedades úteis:

  • enabled: ativa ou desativa o raycast (ele só funciona quando está ativado).

    collision_mask: define quais camadas de colisão o raycast considera.

    exclude_parent: se ativado, ignora o nó pai do RayCast3D (útil se ele estiver como filho de um corpo físico).

    target_position: posição final do raio em relação ao nó. Define o comprimento e direção.

    hit_from_inside: permite detectar colisões mesmo se o raycast estiver dentro do objeto.

  Métodos principais:

  • is_colliding() → retorna true se o raio está batendo em algo.

    get_collider() → retorna o objeto colidido (Node ou RID).

    get_collider_rid() → retorna o RID do colisor (útil para operações mais técnicas, como físicas avançadas).

    get_collider_shape() → retorna o índice da shape colidida dentro do collider.

    get_collision_point() → retorna a posição exata do impacto (Vector3).

    get_collision_normal() → retorna o vetor normal da superfície onde o raio bateu (muito útil para saber a inclinação).

    force_raycast_update() → força a atualização do raycast naquele exato momento, caso precise de precisão fora do ciclo _physics_process().

• • StaticBody3D

    Corpo físico usado para item estáticos do cenário.

GDScript Arrays

• Arrays Dinâmicos

  • Declarar Arrays Tipados vazios com tamanho infinito.

    var TesteArrayInt: Array[int] = [] var TesteArrayBool: Array[bool] = [] var TesteArrayColl: Array[CollisionPolygon2D] = []

  • Nos casos acima se usará por exemplo TesteArrayInt.append(7), para ir se adicionando os valores.

    O primeiro primeiro item será o indice Zero. var valor1 = TesteArrayInt[0]

    Para se ver o tamanho do array poderá se usar TesteArrayInt.size()

    Caso queira pré-definir o tamanho do array nos casos acima pode se usar TesteArrayInt.resize(3), daí não é necessário usar o .append(), pode-se atribuir o valor direto dentro do tamanho definido TesteArrayInt[2] = 8, lembrando que sendo de tamanho 3 o índice vai de 0 à 2.

• Arrays inicializados com tamanhos fixos.

  • Esses arrays já iniciados com valores poder ter seus valores alterados usando TesteArrayInt[0] = 5.

    var TesteArrayInt: Array[int] = [3, 6, 7] var TesteArrayBool: Array[bool] = [true, false, false, false] var TesteArrayColl: Array[CollisionPolygon2D] = [null, null, null, null]

• Array não tipado com tamanho indefinido.

  • Em casos simples tipo dentro de um for, pode se declar o array de forma bem simples.

    var TesteArray = []

GDScript Dicas

• Dicas diversas na escrita do código.

  • Para se pular quebrar a linha de um código muito comprido pode se usar a barra invertida "\".

    if Input.is_action_just_released("direita") || \ Input.is_action_just_released("esquerda") || \ Input.is_action_just_released("baixo") || \ Input.is_action_just_released("cima") || \ Input.is_action_just_pressed("direita") || \ Input.is_action_just_pressed("esquerda") || \ Input.is_action_just_pressed("baixo") || \ Input.is_action_just_pressed("cima"): if criando_selecao: marca_posicoes()

• Sinais de comparação.

  • Pode ser usadop em if, ou outras expressões.

    || ou or && ou and ! ou not != diferente == igual >= maior igual <= menor igual < menor > maior

• Comentários

  • Para se comentar o código se usa o #.

    #Comentário

    Pode se selecionar o texto e usar o atalho Ctrl + K também.

• Identação

  • Selecionado o código se usa o Tab para tabular para frente ou o Shift + Tab para tabular para trás.

• Formatação de String

  • Primeiro se escreve a string colocando % onde irão as variáveis.

    var nome = "Ribamar" print("Olá, %s!" % nome) # Saída: Olá, Ribamar!

  • Para formação de valores após o % se coloca 0 se quiser preencher com zeros à esquerda e depois, a quantidade minima de caracteres e por último o tipo.

    minutos = 3 segundos = 4 "%02d:%02d" % [minutos, segundos] # retorna: 03:04

  • Tipos permitidos

    Código	Significado	Exemplo
    %d	int	42
    %02d	int	02
    %f	float	3.141593
    %.2f	float com 2 decimais	3.14
    %s	Str	"texto"

• Outras funções

  • Determinar como igual quando dois pontos estão muito próximos.

    direcao_atual.is_equal_approx(direcao_anterior)

  • Parar processamentos de física

    set_physics_process(false)

  • Pular alguns frames

    if Engine.get_physics_frames() % 3 == 0:

  • Ao se comparar uma direção com .dot retornará valores de -1 para direçoes opostas e 1 para direções iguais.

    #Exemplo x: float = dir1.dot(dir2) #Mesma direção exata x = 1 #direção oposta exata x = -1 #direção perpendicular exata "90º" x = 0

GDScript Esperas "Delays"

• await

  • Semelhante ao Sleep de muitas linguagens

    Obs. Nunca usar no func _process(delta: float) -> void: pois as linhas anteriores continuaram sendo executadas a cada frame.

    await get_tree().create_timer(0.2).timeout

  • Esperar um frame

    await get_tree().process_frame

• deferred

  • Chamar função ao final dos processamentos

    ret.call_deferred("set_polygon", PackedVector2Array([ponto1, ponto2, ponto3, ponto4]))

  • Setar propriedades ao final do processamento

    $Node2D.set_deferred("position", Vector2(100, 200))

• Executar a cada quantidade de frames.

  • No exemplo abaixo executa a cada 10 frames.

    if Engine.get_physics_frames() % 10 == 0:

GDScript Range e Rand

• Rand

  • Usado para aleatoridade, é necessário usar randomize() para ficar "aleatório" senão ele usará uma semente da godot e gerará sempre a mesma sequência.

    randomize() x = randi() #retorna algo entre 0 e 2³² - 1

  • Se quiser uma sequência única no lugar de randomize() use seed()

    seed(125) x = randi() #a cada chamada retornará a mesma sequência

  • O randfn() rebecebe como primeiro parametro um valor alvo e como segundo uma margem de aproximação para cima ou para baixo, quando mais distante do valor algo mais difícil de ocorrer.

    randfn(10, 2) #Retona a maioria das vezes entre 8 e 12, #mas pode retornar raramente de 5 a 15

  • Outras opçoes de rand.

    Função	Tipo	retorno
    randi()	int	entre 0 e 2³²
    randf()	float	entre 0.0 e 1.0
    randf_range(min, max)	float	entre min e max
    randi_range(min, max)	int	entre min e max
    randfn(alvo, media)	float	próximo ao alvo na média
    randomize()	-	inicializa com seed aleatória

• Range

  • Retorna um intervalos de valores, muito usado em loopins for.

    O primeiro parametro é o inicio, o segundo quantas vezes o loopin ocorrerá e o terceiro é o incremento.

    Exemplo de for

    for i in range(3): print(i) #resultado => 0, 1, 2

  • Função	Tipo valor	Tipo Retorno	Exemplo	Valor Retorno
    range()	int	obj	range(0,5)	0,1,2,3,4
    rangef()	float	array	rangef(0.0,1.0,0.2)	0.0,0.2, ..., 0.8
    stepfy()	Arredonda float	float	stepify(2.37, 0.25)	2.25

GridMap

• Criação dos "Tiles"

  • O primeiro passo é obter objetos ou cria-los no Blender, devem ser proporcionais geralmente em tamanhos 2x2 ou 1x1 metros e com seu ponto de origem bem centralizados para evitar problemas nas rotações.

    Assim como os demais modelos pode usar a forma de integração com o blender movendo os aquivos .blend para a pasta de recursos res://.

  Criação da biblioteca de Malhas "Mesh Library"

  • Primeiro crie uma nova cena 3D que já virá com um Node3D na base.

    Depois pode tratar casa objeto da forma que quiser reimportando como StaticBody3D, adicionando colisores,etc., e ir colocando-os na cena recém criada, não precisa organiza-los só adicionalos mesmo.

    Obs. 1 Pode usar os colisores nos Tiles sem medo pois a Godot processa todos de uma forma que não pesa no processamento.

    Obs. 2 Deixando o StaticBody3D como nó raíz os colisores não funcionaram, dai coloquei o MeshInstance3D como raíz e o StaticBody3D como filho do MeshInstance3D e funcionou normalmente.

    Depois clique em Cena -> Exportar Como... -> MeshLibrary... e salve esse arquivo "cena" como .tres.

  Usando o GridMap

  • Adicione um nó GridMap à sua cena, e em Inspetor -> GridMap -> Mesh Library adicione o recurso criado anteriormente.

    Agora é só usar as ferramentas e criar seu ambiente.

Instanciar Objetos

• Adicionar Objetos á uma cena.

  • Depois de criado um arquivo .tscn pode-se instância-lo, dentro de uma cena.

    Se tiver um Script Global pode se usar uma constante para pré carregar um arquivo e usar essa constante quantas vezes quiser, a vantagem é que o arquivo já é carregado no inicio do jogo e ficando disponivel na memória.

    Obs. Só pode haver um preload() apontando para o mesmo arquivo.

    const GALINHA: Resource = preload("res://cenas/galinha.tscn") var mundo: Node3D = get_node("/root/Mundo") var objeto: Node3D objeto = GALINHA.instantiate() mundo.add_child(objeto) objeto.global_position = Vector3D.ZERO

  • Outra forma de instanciar um objeto é usando uma variável com o metódo load().

    var pos_ini: Vector3 var recurso: Resource var pedra: StaticBody3D var mundo: Node3D pos_ini = Vector3(0, 0.408, 349.72) recurso = load("res://cenas/pedra_1.tscn") pedra = recurso.instantiate() mundo = get_node("/root/Mundo") mundo.add_child(pedra) pedra.global_position = pos_ini pedra.global_rotate(Vector3.UP, deg_to_rad(-90))

    Ou simplesmente

    var pos_ini = Vector3(0, 0.408, 349.72) var recurso = load("res://cenas/pedra_1.tscn") for i in 141: var pedra = recurso.instantiate() add_child(pedra) #Se estiver no script do mundo pedra.global_position = pos_ini pos_ini.x += 2.5 pedra.global_rotate(Vector3.UP, deg_to_rad(-90))

Integração com blender

• Descrição

  • Embora a Godot dê suporte para integração direta com o Blender, o mais indicado é criar tudo no Blender e exportar em formato glTF 2.0 arquivos .glb.

• Configuração

  • Para exportar os objetos vá em:

    Arquivo >> Exportar >> glTF 2.0

    Selecione o local para exportação e do lado direito altere:

    Dados >> Materiais >> Materiais >> Manter lugares

    Isso evita de mandar as imagens junto com o arquivo .glb deixando ele mais leve e permitindo mais liberdade para alterar as texturas no Godot, também evita recursos incompatíveis do blender que podem causar problemas, exemplo comportamento de sombras que podem não aparecer.

  • No Godot após criar a cena a partir do arquivo .glb, selecione as MeshInstance3D e no Inspetor expanda o Surface Material Override e crie um StandardMaterial3D para cada Slot disponível de acordo com as partes da malha desejada.

    Na Godot ao selecionar o material, marque Back Lighting para ajudar no pré-processamento das sombras.

• Sugestão de cores para modelagem

  • Folhas => #228B22

    Tronco => #CD853F

• Atalhos

  • Espaço = Tocar parar animação.

    Ctrl + J = Fundir objetos.

    Alt + Z = Visão de Raio X.

    Shift + Z = Visão armação.

    Z = Menu de visões.

    1 = Visão de frontal.

    3 = Visão pela esquerda.

    7 = Visão de cima.

    9 = Inverter visão atual.

    2, 4, 6, 8 = Rotação gradativa.

    0 = Visão da câmera.

    Ctrl + Alt + 0 = Alinhar camera à visão.

    Ctrl + 0 = Definir câmera como ativa.

    F12 = Renderizar imagem.

    Ctrl + F12 = Renderizar animação.

    Ctrl + F11 = Tocar animação renderizada.

    T = Menu (esquerdo) de ferramentas.

    N = Menu direito.

    A = Selecionar tudo.

    Alt + A = Descelecionar tudo.

    Ctrl + I = Inverter seleção.

    Tab = Alterar modo de edição.

    G = Mover, pode ser usar x, y, z para fixar o movimento global, xx, yy, zz para fixar no movimento local ou Ctrl para atrair magneticamente.

    S = Escalar com recursos semelhantes ao G.

    R = Rotacionar com os mesmos recursos acima.

    Shift + D = Duplicar.

    Ctrl + D = Duplicar de forma que alteração em um influencirá os outros.

    Ctrl + A = Aplicar Transformações.

    Alt + G = Resetar movimentação.

    Alt + R = Resetar rotação.

    Alt + S = Resetar escala.

    H = Ocultar selecionados.

    Alt + H = Desocultar ocultos.

    Ctrl + P = Ativar parentesco ao último selecionado.

    Alt + P = desativar parentesco.

Materias

• Materiais Básicos.

  Gere os mapas a partir de uma imagem AQUI .

  • Albedo

    É a imagem simples da textura.

    Aumentar o Scale Y do UV1 até deixar o tamanho da textura satisfatório.

  • Normal Map

    É o mapa de dará efeito de relevo, o Godot usa o padrão GL que é o Y apontando para cima, no site acima deixar o Z Range -1 to +1 marcado.

    Caso você já possua um NormalMap que esteja no formato DirectX, também é possivel converte-lo no Gimp, abrindo a imagem e indo em "cores -> componentes -> decompor". Depois escolha RGB e inverta o canal verde Y. Depois só ir novamente em "cores -> componentes -> combinar".

  • Roughness

    É a rugosidade, aspereza do material, o site acima gera o Specular que é o oposto do Roughness, para se obter o Roughness basta abrir a imagem no Gimp, e clicar em "cores -> inverter" e depois exportar como Roughness.jpg.

• Materiais Opcionais.

  • Ambient Occlusion

    Refina um pouco mais a iluminação, para usa-lo é necessário ativar o SSAO do Nó WorldEnvironment.

  • Displacement

    Deve ser adicionado ao Height, também gera um refino a mais.

Metadados

• Vincular objetos

  • É possível vincular objetos usando o set_meta().

    objeto1.set_meta("apelido",objeto2)

  • E para se pegar o objeto vinculado usa-se o get_meta().

    objeto2 = objeto1.get_meta("apelido")

Mouse

• Interações com o mouse

  • Selecionar objeto com o mouse.

    #Função do godot que captura eventos de entrada func _input(event: InputEvent) -> void: if event is InputEventMouseButton and event.button_index == MOUSE_BUTTON_LEFT and event.pressed: var origem = camera.project_ray_origin(event.position) var destino = origem + camera.project_ray_normal(event.position) * 1000 var estado = get_world_3d().direct_space_state var q = PhysicsRayQueryParameters3D.create(origem, destino) var retorno = estado.intersect_ray(q) if retorno: var objeto = retorno.collider print("Objeto: " + objeto.name)

  • Ocultar o mouse capturar, para poder move-lo sem que ele saia da tela do jogo.

    func _ready() -> void: Input.set_mouse_mode(Input.MOUSE_MODE_CAPTURED)

Movimentações

• Rotações

  • Funções de rotação

    A Godot usa geralmente radianos e não graus (degrees).

    Para rotacionar um objeto pode se usar Objeto.global_rotate(Vector3.UP, deg_to_rad(90)) para rotacionar em modo global.

    Ou Objeto.rotate_object_local(Vector3.UP, deg_to_rad(90)) para rotacionar em modo local.

    Lembrando que os dois métodos acima adicionam a rotação, para se definir a rotação exata se usa Objeto.rotation.x = deg_to_rad(90) para rotação local e Objeto.global_totation.x = deg_to_rad(90) para rotação global.

    Pode se passar um Vector3 também dessa forma Objeto.rotation = Vector3(0, deg_to_rad(90), 0).

    Ambos rotacionam o Objeto em 90º em Y, convertendo graus para radianos.

  • Tabela de conversões
    Graus (deg)	Radianos (rad)
    0°	0
    90°	π/2 ≈ 1.5708
    180°	π ≈ 3.1416
    270°	3π/2 ≈ 4.7124
    360°	2π ≈ 6.2832

• Direções

  • Importante

    Um personagem no Bleder na visão frontal deve ficar olhando para a câmera enquanto na Godot na visão frontal deve ficar de costas para a camêma, mas estou me referindo a malha e não ao CharacterBody3D, a rotação em Y do CharacterBody3D enquanto a rotação em Y da malha deverá ser -180º.

    Não seguir essa regra, bagunçará todo o script de movimento e rotação.

  • Movimentação de Personagem

    func _physics_process(delta: float) -> void: if not is_on_floor(): velocity += get_gravity() * delta if Input.is_action_just_pressed("pula") and is_on_floor(): velocity.y = VELOCIDADE_PULO var entrada_direcao: Vector2 var direcao: Vector3 entrada_direcao = Input.get_vector("esquerda", "direita", "frente", "traz") direcao = (transform.basis * Vector3(entrada_direcao.x, 0, entrada_direcao.y)).normalized() direcao = direcao.rotated(Vector3.UP, $SpringArm3D.rotation.y) if direcao != Vector3.ZERO: velocity.x = direcao.x * VELOCIDADE velocity.z = direcao.z * VELOCIDADE var Filho_CharacterBody3D: Node3D Filho_CharacterBody3D = $Rig Filho_CharacterBody3D.rotation.y = lerp_angle(Filho_CharacterBody3D.rotation.y, atan2(velocity.x, velocity.z), delta * 10) else: velocity.x = move_toward(velocity.x, 0, VELOCIDADE) velocity.z = move_toward(velocity.z, 0, VELOCIDADE) move_and_slide()

  Explicação

  • Tudo ocorrerá dentro da função _physics_process que é um looping infinito e a cada volta passa por parametro delta que é o tempo calculado entre os frames de acordo com a potência do computador, oque faz com que a física seja processada da melhor forma possível no tempo correto idependente do fps.

    velocity é um Vector3 que faz parte do ChacacterBody3D ele recebe a dados da direção + velocidade que serão aplicados ao objeto pela função move_and_slide().

    As direções de um controle comum são para 2 eixos 4 direções, enquanto em um cenário 3D é formado por 3 eixos e 6 direções, por isso a direção final é calculada usando a direção de entrada se adicionando o 3º eixo, multiplicando pelo transform.basis que é um vetor de localização mais refinado e passado ao normalize() que faz mais calculos trigonométricos para normalizar as direções.

    direcao.rotated() adiciona uma rotação à direção envolvendo mais cálculos trigonometrícos baseado na rotação do $SpringArm3D que é tipo um "braço mola" que segura a câmera que acompanha o personagem.

    Depois é verificado se existe uma direção aplicada se houver é acrescentado essa direção + a velocidade ao velocity.

    A malha do personagem fica em um nó filho do CharacterBody3D, para que seja rotaciona a malha e não o objeto inteiro, usando-se a função learp_angle() com o arco da tangente do velocity fazendo assim uma rotação suave da direção da malha para o direção em que o objeto está indo.

    Se não houver uma direção é usada a função move_toward() que faz o objeto parar suavemente e não bruscamente.

    E por último o move_and_slide() que aplica tudo para o objeto se mover e deslizar simulando física.

MultiMeshInstance3D

• Criar varias Malhas aleatóriamente

  Preparando o Mesh

  • Primeiro é preciso extrair uma Mesh como recurso .res.

    Para isso clique duas vezes no arquivo .blend pelo proprio gerenciador de arquivos do godot para reimportar o modelo.

    Na aba Malhas selecione a malha desejada e selecione Habilitado em Salvar como arquivo ecolha o caminho de preferencia para uma pasta de recursos e clique em Reimportar.

    Fazendo isso você terá um arquivo .res para usa-lo como Mesh.

  Adicionado o Nó

  • Adicione o Nó MultiMeshInstance3D como filho do Nó raiz da cena e adicione um script à ele.

  Script

  • extends MultiMeshInstance3D var grama = preload("res://recursos/grama1.res") var terreno: MeshInstance3D var tamanho_terreno: Vector3 func _ready() -> void: terreno = $"../CollisionShape3D/MeshInstance3D" tamanho_terreno = terreno.mesh.get_aabb().size multimesh = MultiMesh.new() multimesh.mesh = grama #Essas duas próximas linhas precisam estar nessa ordem multimesh.transform_format = MultiMesh.TRANSFORM_3D multimesh.instance_count = 10000 for i in multimesh.instance_count: var x = randf_range(-tamanho_terreno.x / 2, tamanho_terreno.x / 2) var z = randf_range(-tamanho_terreno.y / 2, tamanho_terreno.y / 2) var rotacaoY = randf_range(0, TAU) var escala = randf_range(0.8,1.2) var posicao = Transform3D() posicao.origin = Vector3(x,0,z) posicao.basis = Basis(Vector3.UP, rotacaoY).scaled(Vector3.ONE * escala) multimesh.set_instance_transform(i, posicao)

Partículas

• Partículas 2D em ambiente 3D.

  • Adicione o nó GPUParticles3D na cena desejada.

    Vá em Inspetor >> GPUParticles3D >> Draw Passes >> Passes 1 e selecione QuadMesh clique no QuadMesh >> Material >> StandardMaterial3D clique mo Material e arraste a imagem .png para Texture e ative a Transparency >> Alpha.

    Em Inspetor >> GPUParticles3D >> Process Material selecione ParticleProcessMaterial, nesse momento já será visível as particulas.

    Agora só ajustar as propriedades em Time de acordo com suas preferências.

  • As propriedades mais comuns são:

    Emitting = ativa as partículas.

    Ammount Ratio = quantidade gerada por vez.

    Time >> Lifetime = tempo da duração.

    Time >> One Shot = se ativo executa apenas uma vez.

    Time >> Lifetime = tempo da duração.

    Drawing >> Transform Align >> Z-Billboard = para ficar da direção da câmera ativa.

    Process Material >> Spawn >> Position >> Emission Shape = forma da emissão.

    Process Material >> Accelerations >> Gravity = se quiser inverter a gravidade.

    Draw Passes >> Pass 1 >> QuadMesh >> Material >> Billboard >> Mode >> Enable = Para garantir que a textura aponte para a câmera ativa.

Polígonos 2D

• Criar um poligono através de uma line2D

  • Cria um retangulo na largura de w com espessura e direção de p1 e p2.

    var p1: Vector2 var p2: Vector2 var w: float p1 = Corte[0] p2 = Corte[Corte.size() - 1] w = 10 var dir: Vector2 var normal: Vector2 dir = (p2 - p1).normalized() normal = Vector2(-dir.y, dir.x) #aumenta 5 pixels atraz do inicio p1 -= dir * 5 var P1: Vector2 = p1 + normal * (w / 2) var P2: Vector2 = p2 + normal * (w / 2) var P3: Vector2 = p2 - normal * (w / 2) var P4: Vector2 = p1 - normal * (w / 2) var pontos: PackedVector2Array pontos = [P1,P2,P3,P4] var novo = CollisionPolygon2D novo = CollisionPolygon2D.new() grupo_poligonos.add_child(novo) novo.call_deferred("set_polygon", pontos) novo.position = Vector2.ZERO

• Criar um poligono através de uma line2D com curvas

  • var w: float = 10 var corte: PackedVector2Array = PackedVector2Array(Pontos.duplicate()) #Recuo do inicio var dir_ini: Vector2 dir_ini = (corte[1] - corte[0]).normalized() corte[0] -= dir_ini * 5 var contorno = Geometry2D.offset_polyline(corte, w / 2, Geometry2D.JOIN_MITER, Geometry2D.END_SQUARE) var pontos_contorno: PackedVector2Array = contorno[0] if contorno.size() > 0 else PackedVector2Array() var novo = CollisionPolygon2D novo = CollisionPolygon2D.new() grupo_poligonos.add_child(novo) novo.call_deferred("set_polygon", pontos_contorno) novo.position = Vector2.ZERO return novo

• Junta 2 polígonos sobrepostos

  • Para se mesclar dois polígonos, primeiro se cada cada ponto de cada um para posições globais, se faz o merge, converte os pontos para posição local novamente, é feito um for em mesclado pois se os poligonos não estiverem sobrepostos será retornado dois polígonos sepados novamente.

    Depois só adicionar o polígono, polígonos novos à cena e remover os antigos.

    func Mesclar(Ret1, Ret2: CollisionPolygon2D): var poly1_global = [] for point in Ret1.polygon: poly1_global.append(Ret1.to_global(point)) var poly2_global = [] for point in Ret2.polygon: poly2_global.append(Ret2.to_global(point)) var mesclado = Geometry2D.merge_polygons(poly1_global, poly2_global) var retangulos = get_node("../retangulos") for poly in mesclado: var novo = CollisionPolygon2D.new() retangulos.add_child(novo) var poly_local = [] for point in poly: poly_local.append(retangulos.to_local(point)) novo.call_deferred("set_polygon",poly_local) novo.position = Vector2.ZERO base = novo Ret1.queue_free() Ret2.queue_free()

• Cortar fazendo buracos.

  • var w: float = 10 var pontos: PackedVector2Array = PackedVector2Array(Pontos.duplicate()) var contorno: PackedVector2Array = PackedVector2Array() contorno = Geometry2D.offset_polygon(pontos, (w / 2), Geometry2D.JOIN_MITER) var A = CollisionPolygon2D A = CollisionPolygon2D.new() grupo_poligonos.add_child(A) A.call_deferred("set_polygon", contorno[0]) A.position = Vector2.ZERO

• Forma mais prática de passar pontos para Global ou local

  • Global

    var transform_corte: Transform2D = corte.get_global_transform() var corte_global: PackedVector2Array = PackedVector2Array([]) corte_global = transform_corte * corte.polygon

  • Local

    var transform_local: Transform2D = nova_area_para_corte.get_global_transform().affine_inverse() var pontos_local: PackedVector2Array = PackedVector2Array([]) pontos_local = transform_local * pontos novo_coll.polygon = pontos_local novo_img.polygon = pontos_local

Propriedades

• • Alterar uma propriedade com segurança agendando-a para o final do processamento para evitar erros.

    $shape.set_deferred("disabled",true)

Save

• Salvar e Carregar

  • O local indicado para salvar dados do jogo é "user:/save.dat" ele criará um save na pasta "C:\Usuarios\usuario\AppData\Roaming\Godot\app_userdata" do Windows.

    const LOCAL_SAVE: String = "user:/save.dat"

  • Função para Salvar

    func salva()->void: var f: FileAccess = FileAccess.open(LOCAL_SAVE, FileAccess.WRITE) f.store_8(fase) f.store_16(pontuacao) f.store_16(tempo_restante) f.store_8(vidas) f.close()

  • Função para Carregar

    func carregar_jogo()->void: if not FileAccess.file_exists(local_save): return var f: FileAccess = FileAccess.open(local_save, FileAccess.READ) fase = f.get_8() pontuacao = f.get_16() tempo_restante = f.get_16() vidas = f.get_8() f.close()

Shaders

• Links

  • Godot Shaders

  • Indicações

    Super Hex

Sinais

• Sinais "Eventos"

  • Para criar um sinal basta declara-lo logo após o Extends

    extends Node signal nome_sinal

  • Depois cria-se a função que será executada quando o sinal for disparado.

    func _funcao_a_ser_executada()->void: print("Sucesso!!!")

  • Depois se faz a conexão do sinal com a função.

    connect("nome_sinal", No_que_contem_a_funcao, "_funcao_a_ser_executada")

  • E por último se emite o sinal quando for necessário.

    emit_signal("nome_sinal")

• Sinais com parâmetros

  • Para criar um sinal com parametros basta declará-lo seguido dos parametros que serão utilizados.

    extends Node signal nome_sinal(mensagem: String, numero: int)

  • Depois cria-se a função que será executada quando o sinal for disparado com os mesmos parametros.

    func _funcao_a_ser_executada(mensagem: String, numero: int)->void: print("Mensagem: ", mensagem) print("Número: ", str(numero))

  • Depois se faz a conexão do sinal com a função na mesma forma do exemplo anterior.

    connect("nome_sinal", No_que_contem_a_funcao, "_funcao_a_ser_executada")

  • E por último se emite o sinal quando for necessário passando os parametros.

    emit_signal("nome_sinal", "Ribamar", 46)

SpringArm3D

• Pivot da Câmera

  • É um nó que pode ser usado como filho do ChacterBody3D e pai de uma Camera3D, ele é tipo um braço mecânico que age como uma mola que segura a camera atrás do personagem a uma distância personalizada e caso o personagem encoste as costas em algo, a câmera se desloca para frente impedindo de entrar dentro das paredes e bugar a visão.

    Abaixo um script para adicionar nele para que ele rotacione de acordo com o movimento do mouse criando a jogabilidade padrão de movimento de camera 3D em 3º pessoa.

    extends SpringArm3D const sensibilidade_mouse: float = 0.005 func _unhandled_input(event: InputEvent) -> void: if event is InputEventMouseMotion: global_rotate(Vector3.UP, -event.relative.x * sensibilidade_mouse) rotate_object_local(Vector3.RIGHT, -event.relative.y * sensibilidade_mouse) rotation.x = clamp(rotation.x, -PI/4, PI/4) rotation.z = 0

  • O código é auto explicativo, movendo o pivot globalmente em x e localmente em y, usando uma regulagem de sensibilidade do mouse, limitando a rotação em x com o clamp() e impedindo a rotação em z.

tween

• Faz transiçoes suaves

  • Exemplo de Transição do canal alpha para 0 "Transparente".

    var img_temp: Polygon2D var tween: Tween = create_tween() tween.tween_property(img_temp, "modulate:a", 0.0,0.3) await tween.finished

    await tween.finished espera a transição terminar antes de continuar para a proxima linha.

  • Mover Objeto

    create_tween().tween_property(sprite, "position", Vector2(400, 200), 1.0)

  • Girar

    create_tween().tween_property(sprite, "rotation_degrees", 360, 2.0)

WorldEnvironment

• Configuração do Ambiente

  • Ambiente Básico

    Primeiro adicione o Sol AQUI.

    Para configurar o ambiente de uma forma leve e básica, adicione um nó WorldEnvironment ao seu mundo, vá em Inspetor -> Environment, escolha Environment e clique nele.

    Altere Backgroud -> Mode -> Sky.

    Sky -> Sky -> Sky.

    Sky -> Sky Material -> ProcedureSkyMaterial

    Clicando em ProcedureSkyMaterial ajuste as cores do céu e do horizonte em Sky e as cores do chão em Ground.

• Colorir céu de acordo com a hora

  • Declar varíaveis

    @onready var mundo = $WorldEnvironment.environment var ceu: Sky var material_ceu: ProceduralSkyMaterial

  • Iniciar varíaveis

    func _ready() -> void: ceu = mundo.sky material_ceu = ceu.sky_material

  • Chamar função

    func _process(delta: float) -> void: Ceu()

  • Criar a função

    func Ceu() -> void: var valor = 0 var cor_atual: Color var cor_noite = Color(0,0,0) var cor_T_manha = Color(0.15,0.25,0.4) var cor_H_manha = Color(0.9, 0.4, 0.2) var cor_T_dia = Color(0.35,0.6,0.9) var cor_H_dia = Color(0.65, 0.8, 1) var cor_T_tarde = Color(0.1, 0.15, 0.3) var cor_H_tarde = Color(1, 0.35, 0.1) #Amanhecer if int(horas) == 5: valor = clamp(minutos * 0.03, 0, 1) cor_atual = cor_noite.lerp(cor_T_manha, valor) material_ceu.sky_top_color = cor_atual cor_atual = cor_noite.lerp(cor_H_manha, valor) material_ceu.sky_horizon_color = cor_atual #Dia if int(horas) == 6: valor = clamp(minutos * 0.03, 0, 1) cor_atual = cor_T_manha.lerp(cor_T_dia, valor) material_ceu.sky_top_color = cor_atual cor_atual = cor_H_manha.lerp(cor_H_dia, valor) material_ceu.sky_horizon_color = cor_atual #Tarde if int(horas) == 17: valor = clamp(minutos * 0.03, 0, 1) cor_atual = cor_T_dia.lerp(cor_T_tarde, valor) material_ceu.sky_top_color = cor_atual cor_atual = cor_H_dia.lerp(cor_H_tarde, valor) material_ceu.sky_horizon_color = cor_atual #Noite if int(horas) == 18: valor = clamp(minutos * 0.03, 0, 1) cor_atual = cor_T_tarde.lerp(cor_noite, valor) material_ceu.sky_top_color = cor_atual cor_atual = cor_H_tarde.lerp(cor_noite, valor) material_ceu.sky_horizon_color = cor_atual