Módulo 1: Introdução à Godot Engine e GDScript

Aula: Introdução ao GDScript: Variáveis e Funções Básicas

Olá, futuro desenvolvedor de jogos! 👋 Nesta aula prática, daremos nossos primeiros passos no coração da Godot Engine: o GDScript. Você aprenderá como armazenar informações usando variáveis e como organizar seu código em blocos reutilizáveis com funções. Estes são os blocos de construção fundamentais de qualquer script em Godot!

1. Introdução ao GDScript: A Linguagem da Godot ✨

GDScript é a linguagem de programação de alto nível, tipada dinamicamente, e orientada a objetos, criada especificamente para a Godot Engine. Ela é inspirada no Python, o que a torna relativamente fácil de aprender, especialmente para iniciantes. Sua sintaxe é limpa e legível, permitindo que você se concentre mais na lógica do seu jogo e menos em detalhes complexos da linguagem.

Nesta aula, vamos focar em dois conceitos cruciais:

• Variáveis: Como guardar e manipular dados.
• Funções: Como agrupar código para executar tarefas específicas.

Vamos colocar a mão na massa! 🚀

2. Variáveis em GDScript: Armazenando Informações 📦

Uma variável é como uma caixa nomeada onde você pode guardar um valor. Esse valor pode ser um número, um texto, uma condição (verdadeiro/falso), ou até mesmo um objeto complexo do seu jogo.

2.1. Declarando e Atribuindo Valores

Em GDScript, você declara uma variável usando a palavra-chave var, seguida do nome da variável e, opcionalmente, um valor inicial.

# Declaração e atribuição de um valor inicial
var minha_pontuacao = 0
var nome_jogador = "Heroi"
var jogo_iniciado = false
var velocidade_personagem = 10.5

2.2. Inferência de Tipo vs. Dicas de Tipo (Type Hinting)

GDScript é uma linguagem de tipagem dinâmica por padrão, o que significa que ela tenta adivinhar o tipo da sua variável com base no valor que você atribui a ela.

var numero = 10        # GDScript infere que 'numero' é um inteiro (int)
var texto = "Olá Godot" # GDScript infere que 'texto' é uma String
var flutuante = 3.14    # GDScript infere que 'flutuante' é um float

No entanto, você pode (e deve, para scripts mais complexos e para melhor performance) usar dicas de tipo para declarar explicitamente o tipo de uma variável. Isso ajuda na legibilidade, na detecção de erros e pode otimizar o desempenho.

var vida_inimigo: int = 100
var nome_fase: String = "Floresta Encantada"
var esta_pulando: bool = false
var posicao_x: float = 0.0

Se você não atribuir um valor inicial, a variável terá um valor padrão (null para objetos, 0 para números, false para booleanos, etc.).

var meu_inteiro: int # Será 0 por padrão
var meu_texto: String # Será uma string vazia "" por padrão

2.3. Constantes

Quando você tem um valor que nunca muda durante a execução do seu jogo, você pode declará-lo como uma constante. Constantes são declaradas com a palavra-chave const e, por convenção, seus nomes são escritos em MAIÚSCULAS.

const VELOCIDADE_MAXIMA = 100
const NOME_DO_JOGO = "Aventura Godot"
const GRAVIDADE = 9.8

⚠️ Importante: Tentar modificar o valor de uma constante resultará em um erro!

Exemplo de Código Oficial (Adaptado da documentação Godot)

Vamos ver como isso se parece em um script real. Crie um novo nó Node na sua cena e anexe um novo script GDScript a ele.

# MyFirstScript.gd
extends Node
 
# Variáveis com inferência de tipo
var pontos = 0
var nome_personagem = "Godotinho"
var esta_vivo = true
 
# Variáveis com dicas de tipo explícitas
var nivel_atual: int = 1
var energia_maxima: float = 100.0
var mensagem_boas_vindas: String = "Bem-vindo ao jogo!"
 
# Constantes
const VELOCIDADE_PADRAO = 50
const PI = 3.14159
 
# A função _ready() é uma função especial da Godot que é chamada uma vez
# quando o nó e todos os seus filhos estão prontos e no SceneTree.
func _ready():
	print("--- Variáveis em Ação ---")
	print("Pontos iniciais: ", pontos)
	print("Nome do personagem: ", nome_personagem)
	print("Está vivo? ", esta_vivo)
	print("Nível atual: ", nivel_atual)
	print("Energia máxima: ", energia_maxima)
	print("Mensagem: ", mensagem_boas_vindas)
	print("Velocidade padrão do jogo: ", VELOCIDADE_PADRAO)
	print("Valor de PI: ", PI)
 
	# Modificando variáveis (exceto constantes!)
	pontos = 100
	nivel_atual = 2
	esta_vivo = false
	print("--- Após modificação ---")
	print("Novos pontos: ", pontos)
	print("Novo nível: ", nivel_atual)
	print("Está vivo agora? ", esta_vivo)
 
	# Isso causaria um erro se descomentado:
	# VELOCIDADE_PADRAO = 60

Quando você rodar a cena, verá a saída no painel "Saída" (Output) do editor Godot.

3. Funções Básicas em GDScript: Bloco de Código Reutilizável 🛠️

Funções são blocos de código nomeados que executam uma tarefa específica. Elas são essenciais para organizar seu código, torná-lo mais legível e evitar repetições (o famoso princípio DRY: Don't Repeat Yourself).

3.1. Definindo uma Função

Você define uma função usando a palavra-chave func, seguida do nome da função, parênteses () e dois pontos :. O código dentro da função deve ser indentado.

func minha_primeira_funcao():
	print("Esta é a minha primeira função!")
	print("Ela faz algo útil.")

3.2. Chamando uma Função

Para executar o código dentro de uma função, você precisa "chamá-la" pelo seu nome, seguido de parênteses.

func _ready():
	minha_primeira_funcao() # Chama a função

3.3. Parâmetros e Argumentos

Funções podem receber informações externas para trabalhar. Essas informações são chamadas de parâmetros (na definição da função) ou argumentos (quando a função é chamada). Você pode adicionar dicas de tipo aos parâmetros para maior clareza.

# Função com um parâmetro 'nome'
func saudar_jogador(nome: String):
	print("Olá, ", nome, "! Bem-vindo ao jogo.")
 
# Função com múltiplos parâmetros e dicas de tipo
func somar_numeros(a: int, b: int):
	var resultado = a + b
	print("A soma de ", a, " e ", b, " é: ", resultado)
 
func _ready():
	saudar_jogador("Maria") # Chama a função com o argumento "Maria"
	saudar_jogador("João")
 
	somar_numeros(5, 3) # Chama a função com os argumentos 5 e 3
	somar_numeros(10, 20)

3.4. Valores de Retorno

Funções podem não apenas executar ações, mas também retornar um valor como resultado de sua operação. Você usa a palavra-chave return para isso. Você também pode adicionar uma dica de tipo para o valor de retorno.

# Função que retorna um valor (int)
func calcular_area_quadrado(lado: int) -> int:
	var area = lado * lado
	return area
 
# Função que retorna um valor (String)
func obter_status_personagem(vida: int, max_vida: int) -> String:
	if vida <= 0:
		return "Morto"
	elif vida < max_vida / 2:
		return "Ferido"
	else:
		return "Saudável"
 
func _ready():
	var area_do_meu_quadrado = calcular_area_quadrado(7)
	print("A área do quadrado é: ", area_do_meu_quadrado) # Saída: 49
 
	var status1 = obter_status_personagem(20, 100)
	print("Status do personagem 1: ", status1) # Saída: Ferido
 
	var status2 = obter_status_personagem(100, 100)
	print("Status do personagem 2: ", status2) # Saída: Saudável
 
	var status3 = obter_status_personagem(0, 100)
	print("Status do personagem 3: ", status3) # Saída: Morto

Exemplo de Código Oficial (Adaptado da documentação Godot)

Combinando variáveis e funções em um script Godot.

# Player.gd
extends CharacterBody2D # Ou Node2D, dependendo do seu caso. Para este exemplo, Node é suficiente.
 
# Variáveis do jogador
var vida: int = 100
var nome: String = "Aventureiro"
var esta_atacando: bool = false
const DANO_ATAQUE: int = 10
 
# Função que é chamada quando o nó é iniciado
func _ready():
	print("--- Jogo Iniciado ---")
	mostrar_status_jogador()
	simular_combate()
	mostrar_status_jogador()
 
# Função para mostrar o status atual do jogador
func mostrar_status_jogador():
	print("Nome: ", nome)
	print("Vida: ", vida)
	print("Está atacando? ", esta_atacando)
	print("---")
 
# Função para o jogador receber dano
func receber_dano(quantidade: int):
	vida -= quantidade
	print(nome, " recebeu ", quantidade, " de dano. Vida restante: ", vida)
	if vida <= 0:
		print(nome, " foi derrotado!")
 
# Função para o jogador atacar
func atacar_inimigo() -> int:
	esta_atacando = true
	print(nome, " atacou! Causando ", DANO_ATAQUE, " de dano.")
	esta_atacando = false # Reseta o estado após o ataque
	return DANO_ATAQUE
 
# Função para simular um pequeno combate
func simular_combate():
	print("--- Simulação de Combate ---")
	var dano_causado = atacar_inimigo()
	# Imagine que o inimigo ataca de volta
	receber_dano(25) # O jogador recebe 25 de dano
	receber_dano(40) # O jogador recebe mais 40 de dano
	print("--- Fim do Combate ---")

Execute esta cena para ver a sequência de eventos e a interação entre as variáveis e funções.

4. Exercícios/Desafios Práticos 🧑‍💻

Agora é sua vez de praticar! Siga os passos abaixo no editor Godot.

Desafio 1: Criando um Script de Item 🎒

Crie um novo nó Node na sua cena e anexe um novo script GDScript chamado Item.gd.

• Declare Variáveis:
  • Uma variável nome_item do tipo String com o valor "Espada Lendária".
  • Uma variável quantidade do tipo int com o valor 1.
  • Uma variável eh_consumivel do tipo bool com o valor false.
  • Uma constante PESO_ITEM do tipo float com o valor 2.5.
• Crie Funções:
  • Uma função mostrar_detalhes() que imprima no console todos os detalhes do item (nome, quantidade, se é consumível, peso).
  • Uma função usar_item() que imprima "Você usou [nome_item]!" e, se eh_consumivel for true, diminua a quantidade em 1 e imprima a nova quantidade.
• Teste no _ready():
  • No _ready() do seu script Item.gd, chame mostrar_detalhes().
  • Chame usar_item().
  • Altere eh_consumivel para true e quantidade para 3.
  • Chame usar_item() novamente duas vezes.
  • Chame mostrar_detalhes() novamente para ver as mudanças.

Desafio 2: Calculadora Simples ➕➖

Crie um novo nó Node e anexe um novo script GDScript chamado Calculadora.gd.

• Declare Variáveis:
  • Duas variáveis numero1 e numero2 do tipo int com valores de sua escolha (ex: 15 e 7).
• Crie Funções:
  • Uma função somar(a: int, b: int) -> int que retorna a soma de a e b.
  • Uma função subtrair(a: int, b: int) -> int que retorna a subtração de a e b.
  • Uma função multiplicar(a: int, b: int) -> int que retorna a multiplicação de a e b.
  • Uma função dividir(a: int, b: int) -> float que retorna a divisão de a por b. (Lembre-se de verificar divisão por zero!)
• Teste no _ready():
  • No _ready(), chame cada uma das funções de cálculo usando numero1 e numero2 como argumentos.
  • Imprima os resultados de cada operação no console de forma clara (ex: "A soma é: X", "A subtração é: Y").
  • Teste a divisão por zero: dividir(10, 0) e veja o que acontece. Tente adicionar uma lógica na função dividir para evitar o erro e imprimir uma mensagem de aviso.

5. Resumo e Próximos Passos 🏁

Parabéns! 🎉 Você deu um grande passo no aprendizado do GDScript.

Nesta aula, você aprendeu:

• O que são variáveis e como declará-las em GDScript, usando inferência de tipo ou dicas de tipo explícitas.
• A diferença entre variáveis e constantes.
• O que são funções e como defini-las para organizar seu código.
• Como passar parâmetros para funções e como elas podem retornar valores.
• A importância da função especial _ready() em Godot.

Estes conceitos são a base para construir qualquer lógica de jogo. Continue praticando e experimentando!

Próximos Passos:

Na próxima aula, exploraremos os Operadores e Estruturas de Controle de Fluxo (como if/else e for/while), que permitirão que seus jogos tomem decisões e executem ações repetidamente. Prepare-se para adicionar ainda mais inteligência aos seus scripts!