Módulo 02 – Conceitos Básicos de Programação

Introdução à Lógica de Programação

O que são Computadores?

Computadores são dispositivos eletrônicos programáveis projetados para processar, armazenar e exibir informações. Eles executam operações aritméticas e lógicas de acordo com um conjunto de instruções pré-determinado, conhecido como programa.

Com uma capacidade notável de realizar cálculos complexos e manipular grandes volumes de dados em alta velocidade, os computadores são essenciais para uma ampla variedade de aplicações, desde tarefas simples do dia a dia, como navegação na internet e processamento de textos, até funções mais complexas, como simulações científicas, controle de sistemas industriais, inteligência artificial e videogames.

Eles são compostos por componentes essenciais, incluindo a unidade central de processamento (CPU), memória, dispositivos de armazenamento e interfaces de entrada e saída.

Como os Computadores Funcionam?

Os computadores seguem três passos principais:

Entrada (Input)

O computador recebe dados de alguma fonte externa, como teclado, mouse, joystick, arquivo ou internet.

Processamento

O computador manipula os dados recebidos conforme as instruções especificadas.

Saída (Output)

O computador produz um resultado que é enviado para uma tela, armazenado em um arquivo ou enviado para outra máquina.

O que são Programas de Computador?

Um programa de computador é uma sequência de instruções que um computador pode executar para realizar uma tarefa específica. Imagine um programa como uma receita culinária: ele descreve passo a passo o que deve ser feito para alcançar um resultado final, seja este resultado um bolo, um cálculo matemático, ou a exibição de uma página web, a movimentação de um personagem, a exibição de um menu, etc.

Juntando vários programas e funcionalidades chegamos aos aplicativos e plataformas que oferecem um conjunto de ferramentas mais completo para o usuário.

Motores de Jogos (Game Engines)

As Game Engines são plataformas de software projetadas para simplificar o desenvolvimento de jogos eletrônicos, fornecendo uma estrutura integrada para criar e gerenciar gráficos, física, sons, scripts, etc.

A Godot é estruturada de forma modular e flexível, permitindo aos desenvolvedores criar jogos de maneira eficiente e organizada.

Com essa arquitetura, a Godot proporciona uma plataforma poderosa e versátil para o desenvolvimento de jogos, permitindo que desenvolvedores concentrem-se na criação de conteúdo e lógica de jogo, enquanto a engine cuida das complexidades subjacentes.

Os computadores, sendo máquinas, não possuem a capacidade de entender linguagem humana de forma direta. Por isso, utilizamos linguagens de programação para escrever instruções de maneira que o computador possa interpretá-las e executá-las. Essas linguagens seguem regras e sintaxes bem definidas que devem ser aprendidas para escrever programas corretamente.

Por exemplo, pense em um programa de calculadora. O usuário insere dois números (entrada), a calculadora soma esses números (processamento) e então exibe o resultado (saída).

Primeiros Passos com GDScript

Criando um Script Simples:

Na Godot, crie um novo nó (por exemplo, um Node2D).

Adicione um script a esse nó.

No editor de scripts, digite o seguinte código:

extends Node2D

func _ready():
     print("Olá GDScript")

Execute a cena para ver a mensagem “Olá, GDScript!” no console.

Sintaxe Básica do GDScript

Palavras-chave

Palavras-chave são palavras reservadas (tokens) usadas como identificadores. Operadores como in, not, and e or e nomes de tipos de dados como int, float e bool são palavras reservadas. Você pode encontrar a lista completa de palavras-chave usadas pelo GDScript na Documentação Oficial da Godot.

Indentação

O GDScript baseia sua sintaxe na indentação de blocos de código, ou seja, depende do recuo para definir onde começam e terminam os blocos. Isso torna o código visualmente limpo e fácil de ler. Compreender essas convenções simples é o primeiro passo para escrever códigos em GDScript.

# Exemplo de identação
if condicão_1:
	# Corpo do bloco
	var sentença_1
	var sentença_2
	# Bloco interno
	if condição_2:
		var sentença_3
		var sentença_4

Sentenças

As sentenças são instruções ou comandos individuais. Cada sentença normalmente termina com uma quebra de linha, embora várias sentenças possam ser declaradas em uma única linha se separadas por ponto e vírgula. No entanto, para melhorar a legibilidade, geralmente é recomendado ter uma instrução por linha.

# Multiplas sentenças em uma única linha - menos legível
var x = 5; var y = 10

# Cada sentença em uma linha separada - mais legível
var w = 5
var z = 10

Comentários

Comentários são essenciais para documentar seu código. No GDScript, os comentários começam com o símbolo # e se estendem até o final da linha. Eles fornecem explicações, notas ou lembretes para que você e outras pessoas possam ler seu código. O uso estratégico de comentários contribui para clareza e compreensão do código.

# Este é um cometário

# Comentários também são úteis para desabilitar
# temporariamente linhas de código.

#var x = 5
var y = 10

Anotações

As anotações são alguns tokens especiais em GDScript que se assemelham a palavras-chave, mas operam de maneira diferente. Cada anotação começa com o caractere @ e é identificada por um nome específico.

As anotações podem ser listadas uma por linha ou agrupadas na mesma linha, afetando a declaração subsequente de não anotação. Os argumentos podem ser incluídos entre parênteses e separados por vírgulas.

@export var anotacao_a
@export var anotaco_b

@onready var label

Variáveis e Tipos de Dados

O que são Variáveis?

Definição:

Variáveis são como “caixas” que armazenam dados. Elas são usadas para guardar informações que podem ser manipuladas e referenciadas ao longo do código. As variáveis possuem um nome e um valor.

Em GDScript, assim como em todas as linguagens de programação de alto nível, algumas palavras são definidas como chave para a sintaxe dos programas.

Palavras-chave são termos reservados que possuem significados especiais dentro de uma linguagem de programação específica. Elas são usadas para definir a estrutura e o comportamento dos programas, e não podem ser utilizadas para outros fins, como nomes de variáveis ou funções.

Exemplos comuns de palavras-chave incluem if, else, while, for, function, return, entre outras.

Declaração de variáveis:

• Em GDScript, as variáveis são declaradas usando a palavra-chave var.

Declaração de Variáveis:

#
# Declaração de variávieis
#
var minha_variavel = 10
var meu_texto = "Olá GDScript!"

No exemplo anterior a variável de nome “minha_variável” armazena o valor “10” e a variável “meu_texto” armazena o valor “Olá GDScript”.

Constantes

Constantes são “caixas” cujo valor é definido uma vez e não pode ser alterado posteriormente. Elas são usadas para representar valores fixos que são usados repetidamente no programa.

No GDScript, declaramos constantes usando a palavra-chave const.

#
# Declaração de constantes
#

const GRAVIDADE = 980
const VELOCIDADE_MAXIMA = 350

Aqui, GRAVIDADE é uma constante que representa a força da gravidade no jogo. Ao usá-la, fica claro que esse valor não deve mudar durante a execução do jogo.

No segundo exemplo temos a velocidade máxima do personagem.

A constante VELOCIDADE_MAXIMA define a velocidade máxima que o personagem pode atingir. Isso evita que tenhamos que lembrar o valor exato da velocidade máxima em várias partes do código.

Tipos de Dados

# Inteiros
var idade = 25
# Floats
var altura = 1.75
# Strings
var nome = "Mario"
# Booleanos
var is_visible = true
# Arrays
var lista = [1, 2, 3, 4, 5]
# Dicionários
var dict = {"chave", "valor"}

Estruturas de Controle

As estruturas de controle são utilizadas para definir o fluxo de execução do programa. Elas permitem que você tome decisões, repita blocos de código e controle a ordem das operações. Abaixo, vamos explorar as principais estruturas de controle em GDScript:

Condicionais

if idade > 18:
    print("Maior de idade")
else:
    print("Menor de idade")

Laços de Repetição

for i in range(10):
    print(i)
while is_visible:
    print("Ainda visível")
    is_visible = false
for i in range(10):
    print(i)

Funções

func minha_funcao(param):
    print("Parametro recebido: ", param)
    return param * 2

var resultado = minha_funcao(5)

Classes e Objetos

class MinhaClasse:
    var atributo = 0

    func metodo():
        print(atributo)
    
func _init():
        var objeto = MinhaClasse.new(10)

objeto.metodo()

Entendendo Mensagens de Erro

A Importância das Mensagens de Erro

O Papel das Mensagens de Erro:

Mensagens de erro são ferramentas essenciais que ajudam os desenvolvedores a identificar e corrigir problemas no código. Elas fornecem informações valiosas sobre o que está errado e onde procurar a solução.

Benefícios de Entender Erros:

• Diagnóstico Rápido: Ajuda a localizar rapidamente o ponto de falha no código.
• Aprendizado: Compreender erros comuns aprimora suas habilidades de programação.
• Melhoria da Qualidade do Código: Identificar e corrigir erros resulta em código mais robusto e confiável.

Tipos Comuns de Mensagens de Erro no GDScript

Erros de Sintaxe:

Ocorre quando o código não segue a gramática da linguagem. No exemplo a seguir a sintaxe correta exige a colocação de dois pontos “:” após a condicional do comando “if”.

• Exemplo:

##
## Exemplo de erro de sintaxe
##

var x = 10

if x > 5
     print("%02d é menor que 5" %[x])

• Mensagem de Erro:

Error at (7, 9): Expected ":" after "if" condition.

Código corrigido:

##
## Código correto
##

var x = 10

if x > 5:
     print("%02d é menor que 5" %[x])

Erros de Tempo de Execução:

Acontece enquanto o jogo está rodando, geralmente devido a operações inválidas.

• Exemplo:

##
## Exemplo
##

var lista = [1, 2, 3 ]
# para execução do programa e exibe mensagem de erro
print(lista[3])

• Mensagem de Erro:

Invalid get index '3' (on base: 'Array).

Código corrigido:

##
## Código correto
##

var lista = [1, 2, 3 ]
# exibe o valor 3 no console
print(lista[2])

Erros de Tipagem:

Ocorre quando uma variável é usada de maneira incompatível com seu tipo.

• Exemplo:

##
## Exemplo de erro de tipagem
##

var numero = 10

var resultado = numero + "5"

• Mensagem de Erro:

Invalid operands 'init' and 'String' in operation '+'.

Técnicas de Depuração

Uso do Console:

• Utilize print() para exibir valores de variáveis e mensagens de depuração.

Breakpoints e Inspeção:

• Defina breakpoints no editor de scripts para pausar a execução e inspecionar variáveis.
• Acesse a janela de depuração para ver o estado atual do jogo.

Manipulação de Variáveis

Operadores

Os operadores são símbolos especiais que nos permitem realizar diversas operações em variáveis e valores, como adicionar números, comparar valores e muito mais. Eles são fundamentais para a lógica de qualquer programa, pois ajudam a manipular dados e tomar decisões com base em condições específicas.

GDScript oferece uma ampla variedade de operadores, incluindo aritméticos, relacionais, lógicos, de atribuição e outros. Cada tipo de operador tem uma função específica e é usado em diferentes contextos para resolver problemas e implementar funcionalidades no seu jogo.

Atribuição de Valores

As variáveis podem ser atualizadas com novos valores. Para atribuir valores a variáveis utilizamos o sinal de igual.

##
## Atribuição de valores
##

var contador = 10

func altera_contador():
     contador = 15

Operações Básicas

As quatro operações aritméticas básicas são representadas conforme vemos a seguir:

• soma (+)
• subtração (-)
• multiplicação (*)
• divisão (/)

##
## Operações aritméticas básica
##

var a = 4
var b = 2

func soma():
     var resultado = a + b
     print(resultado)

func subtracao():
     var resultado = a - b
     print(resultado)


func multiplicacao():
     var resultado = a * b
     print(resultado)

func divisao():
     var resultado = a / b
     print(resultado)

Concatenação de Strings

O operador + também é usado na concatenação de strings, ou seja, a junção de duas ou mais variáveis de texto.

##
## Concatenação de Strings
##

var nome = "Mario"
var sobrenome = "Xavier"

func nome_completo():
     var _nome_completo = nome + " " + sobrenome
     print(_nome_completo)

## imprime: Mario Xavier

Operadores Lógicos

As operaçoes lógicás são representadas através dos seguintes simbolos:

• AND (&&)
• OR (||)
• NOT (!)

O guia de codificação da Godot recomenda o uso das palavras-chave and, or e not ao invés dos símbolos.

##
## Operadores lógicos booleanos
##

var condicao_1
var condicao_2
var condicao_3

func condicoes():

     if (condicao_1 and condicao_2) or not condicao_3:
          print("Condições satisfeitas")

Conversão de Tipos

Como citado antes, o GDScript é uma linguagem flexível quanto a tipagem de variáveis. Portando quando utilizamos a tipagem dinâmica a própria engine se encarrega de fazer a conversão.

##
## Conversão de tipos
##

var inteiro = 2

func muda_inteiro():
	inteiro = "2"
	print("Este é o número " + inteiro)

## imprime: Este é o número 2

func muda_strings():
     var dois = "2"
     var tres = "3"
     print (dois + tres) # imprime 23

     dois = 2
     tres = 3
     print (dois + tres) # imprime 5

Por outro lado, se utilizarmos a tipagem estática, o código apresentará um erro porque, neste caso, não é permito atribuir um valor de texto a uma variável do tipo inteiro.

##
## Conversão de tipos
##

var inteiro:int = 2

func muda_inteiro():
	inteiro = "2"
	print("Este é o número " + inteiro)

## ERRO: Cannot assign a value of type "String" as "int"

Quando usamos a sintaxe tipada precisamos informar explicitamente ao GDScript que queremos converter a variável.

Para isso temos a disposição alguns métodos disponibilizados aos prórprios tipos como to_int() e to_float() para converter strings em números.

##
## Conversão de tipos
##

func muda_strings():
     var dois:String = "2"
     var tres:String = "3"

     print (dois + tres) # imprime 23

     print (dois.to_int() + tres.to_int()) # imprime 5

Linguagens Tipadas vs. Não Tipadas

Introdução

Na programação, a maneira como as variáveis e seus tipos são tratados pode ter um impacto significativo na forma como desenvolvemos software. As linguagens de programação podem ser tipadas ou não tipadas, cada uma com suas vantagens e desvantagens. Vamos explorar esses conceitos e entender como eles influenciam o desenvolvimento de jogos e aplicações, utilizando exemplos em GDScript, a linguagem de script nativa da Godot Engine.

Linguagens Tipadas

Nas linguagens tipadas, cada variável deve ter um tipo de dado específico, como int (inteiro), float (número de ponto flutuante), string (cadeia de caracteres), etc. Esse tipo pode ser definido explicitamente pelo programador ou inferido pelo compilador ou interpretador.

Vantagens das Linguagens Tipadas

1. Segurança de Tipo: Uma das maiores vantagens é a segurança de tipo. O compilador ou interpretador verifica os tipos durante a compilação ou execução, evitando erros comuns, como tentar realizar operações inválidas entre tipos diferentes.
2. Auto-completemento e Refatoração: Ferramentas de desenvolvimento podem oferecer melhores sugestões de auto-complete e refatoração, pois conhecem os tipos das variáveis.
3. Documentação Implícita: O tipo da variável serve como documentação, tornando o código mais legível e compreensível para outros desenvolvedores.
4. Detecção de Erros em Tempo de Compilação: Muitos erros podem ser detectados em tempo de compilação, antes de o programa ser executado, reduzindo o tempo gasto em debug.

Desvantagens das Linguagens Tipadas

1. Verbosidade: Requerer a especificação dos tipos pode tornar o código mais verboso e difícil de escrever rapidamente.
2. Flexibilidade Reduzida: Pode ser menos flexível ao trabalhar com dados dinâmicos ou ao prototipar rapidamente.

Linguagens Não Tipadas

Nas linguagens não tipadas, as variáveis não são restritas a um tipo específico e podem conter diferentes tipos de dados em diferentes momentos da execução.

Vantagens das Linguagens Não Tipadas

1. Flexibilidade: Permite maior flexibilidade e rapidez no desenvolvimento, especialmente útil para prototipagem e scripts curtos.
2. Menor Verbosidade: Menos código boilerplate, pois não é necessário declarar tipos explicitamente.

Desvantagens das Linguagens Não Tipadas

1. Maior Propensão a Erros: Erros de tipo só são detectados em tempo de execução, o que pode levar a bugs difíceis de rastrear.
2. Documentação e Leitura de Código: O código pode ser mais difícil de entender, pois o tipo das variáveis não é explícito.
3. Menos Suporte de Ferramentas: Ferramentas de desenvolvimento podem ter mais dificuldade em fornecer sugestões de auto-complete e refatoração eficazes.

Exemplo em GDScript

GDScript, a linguagem de script do Godot Engine, é um exemplo interessante, pois suporta ambos os estilos. Vamos ver como isso funciona na prática.

Código Tipado

##
## Variáveis tipadas e funções tipadas
##
var player_name: String = "Hero"
var health: int = 100
var speed: float = 5.5
func take_damage(amount: int) -> void:
    health -= amount
    if health <= 0:
        die()
func die() -> void:
    print(player_name + " has died.")

Código Não Tipado

#
# Variáveis não tipadas
#
var player_name = "Hero"
var health = 100
var speed = 5.5

func take_damage(amount):
    health -= amount
    if health <= 0:
        die()

func die():
    print(player_name + " has died.")

Como podemos ver, o código não tipado é mais curto e menos verboso, mas o código tipado oferece maior segurança e clareza sobre o que se espera de cada variável e função.