petcarescript/docs/guia-estudos.md

PetCareScript - A modern, expressive programming language designed for humans

# PetCareScript - Guia Completo de Estudos

## 🎯 Bem-vindo ao PetCareScript!

**PetCareScript** é uma linguagem de programação moderna, expressiva e humanizada, projetada para tornar a programação mais acessível e intuitiva. Com sintaxe próxima à linguagem natural, é ideal para iniciantes aprenderem programação e para desenvolvedores experientes prototiparem rapidamente.

### 📚 Sobre Este Guia

Este guia está estruturado em módulos progressivos, levando você desde os conceitos mais básicos até técnicas avançadas de programação. Cada módulo inclui:

- **Teoria**: Conceitos fundamentais
- **Sintaxe**: Como escrever código
- **Exemplos**: Código prático e funcional
- **Exercícios**: Atividades para praticar
- **Projetos**: Aplicações do mundo real

### 🛣️ Trilha de Aprendizado

```
📍 Módulo 1: Fundamentos
📍 Módulo 2: Estruturas de Dados
📍 Módulo 3: Funções e Escopo
📍 Módulo 4: Estruturas de Controle
📍 Módulo 5: Programação Orientada a Objetos
📍 Módulo 6: Projetos Práticos
📍 Módulo 7: Tópicos Avançados
```

### ⚡ Instalação Rápida

```bash
# Via NPM (recomendado)
npm install -g petcarescript

# Verificar instalação
pcs --version

# Executar arquivo
pcs meucodigo.pcs

# REPL interativo
pcs repl
```

---

## 📍 Módulo 1: Fundamentos

### 🎯 Objetivos do Módulo
- Entender a filosofia do PetCareScript
- Aprender sintaxe básica
- Trabalhar com variáveis e tipos
- Usar comentários e formatação

### 1.1 Primeiro Programa

**Todo programa começa com "Olá, Mundo!"**

```javascript
// meu_primeiro_programa.pcs
show "Olá, Mundo!";
```

**Para executar:**
```bash
pcs meu_primeiro_programa.pcs
```

### 1.2 Comentários

```javascript
// Comentário de linha única

/* 
   Comentário de 
   múltiplas linhas 
*/

/* 
TODO: Implementar nova funcionalidade
FIXME: Corrigir bug na função de cálculo
NOTE: Esta seção pode ser otimizada
*/
```

### 1.3 Variáveis e Tipos

#### Declaração de Variáveis
```javascript
// Palavra-chave 'store' para declarar variáveis
store nome = "Maria";
store idade = 25;
store ativo = yes;
store vazio = empty;
```

#### Tipos de Dados Primitivos
```javascript
// Números
store inteiro = 42;
store decimal = 3.14159;
store negativo = -17;

// Strings (texto)
store mensagem = "Bem-vindo ao PetCareScript!";
store template = 'Texto com aspas simples';
store emoji = "🚀 Linguagem incrível! 🎉";

// Booleanos
store verdadeiro = yes;      // true
store falso = no;            // false

// Nulo
store indefinido = empty;    // null/undefined
```

#### Convenções de Nomenclatura
```javascript
// ✅ Boas práticas
store userName = "joao";           // camelCase
store user_age = 30;               // snake_case
store MAX_USERS = 100;             // CONSTANTES

// ❌ Evitar
store 123abc = "erro";             // Não pode começar com número
store user-name = "erro";          // Hífen não permitido
store store = "erro";              // Palavra reservada
```

### 1.4 Operações Básicas

#### Operadores Aritméticos
```javascript
store a = 10;
store b = 3;

store soma = a + b;           // 13
store subtracao = a - b;      // 7
store multiplicacao = a * b;  // 30
store divisao = a / b;        // 3.333...

show "Soma: " + soma;
show "Divisão: " + divisao;
```

#### Concatenação de Strings
```javascript
store primeiro_nome = "João";
store ultimo_nome = "Silva";
store nome_completo = primeiro_nome + " " + ultimo_nome;

show "Nome completo: " + nome_completo;  // "Nome completo: João Silva"

// Misturando tipos
store produto = "Notebook";
store preco = 2500;
store mensagem = "O " + produto + " custa R$ " + preco;
show mensagem;  // "O Notebook custa R$ 2500"
```

### 1.5 Entrada e Saída

#### Saída Simples
```javascript
show "Texto simples";
show 42;
show yes;
show [1, 2, 3];

// Múltiplas variáveis
store nome = "Ana";
store pontos = 95;
show nome + " tem " + pontos + " pontos";
```

### 🏋️ Exercícios do Módulo 1

#### Exercício 1.1: Variáveis Pessoais
```javascript
// Complete o código abaixo com suas informações
store meu_nome = "SEU_NOME_AQUI";
store minha_idade = 0;  // Sua idade
store gosto_programacao = yes;  // ou no

show "Olá! Meu nome é " + meu_nome;
show "Tenho " + minha_idade + " anos";
show "Gosto de programação: " + gosto_programacao;
```

#### Exercício 1.2: Calculadora Básica
```javascript
// Crie uma calculadora que soma dois números
store numero1 = 15;
store numero2 = 25;

store resultado = numero1 + numero2;
show numero1 + " + " + numero2 + " = " + resultado;

// Agora faça para subtração, multiplicação e divisão
```

#### Exercício 1.3: Informações de Produto
```javascript
// Sistema de loja simples
store produto_nome = "Smartphone";
store produto_preco = 899;
store produto_disponivel = yes;

// Mostre as informações formatadas
show "=== INFORMAÇÕES DO PRODUTO ===";
show "Nome: " + produto_nome;
show "Preço: R$ " + produto_preco;
show "Disponível: " + produto_disponivel;
```

---

## 📍 Módulo 2: Estruturas de Dados

### 🎯 Objetivos do Módulo
- Trabalhar com arrays (listas)
- Manipular objetos
- Acessar e modificar dados
- Entender estruturas complexas

### 2.1 Arrays (Listas)

#### Criação e Acesso
```javascript
// Criando arrays
store numeros = [1, 2, 3, 4, 5];
store frutas = ["maçã", "banana", "laranja"];
store misto = [1, "texto", yes, empty];
store vazio = [];

// Acessando elementos (índice começa em 0)
store primeira_fruta = frutas[0];    // "maçã"
store segunda_fruta = frutas[1];     // "banana"
store ultimo_numero = numeros[4];    // 5

show "Primeira fruta: " + primeira_fruta;
```

#### Modificação de Arrays
```javascript
store cores = ["vermelho", "azul", "verde"];

// Modificar elemento existente
cores[1] = "amarelo";
show cores;  // ["vermelho", "amarelo", "verde"]

// Adicionar elemento (simulação)
store novo_indice = length(cores);
cores[novo_indice] = "roxo";
show cores;  // ["vermelho", "amarelo", "verde", "roxo"]
```

#### Trabalhando com Arrays
```javascript
store notas = [8.5, 7.2, 9.1, 6.8, 8.9];

// Encontrar tamanho
store total_notas = length(notas);
show "Total de notas: " + total_notas;

// Calcular soma manual
store soma = notas[0] + notas[1] + notas[2] + notas[3] + notas[4];
store media = soma / total_notas;
show "Média: " + media;
```

### 2.2 Objetos

#### Criação e Estrutura
```javascript
// Objeto simples
store pessoa = {
    nome: "Carlos",
    idade: 28,
    profissao: "Programador",
    ativo: yes
};

// Acessando propriedades
store nome_pessoa = pessoa.nome;
store idade_pessoa = pessoa.idade;

show "Nome: " + nome_pessoa;
show "Idade: " + idade_pessoa;
```

#### Objetos Complexos
```javascript
store empresa = {
    nome: "TechCorp",
    fundacao: 2020,
    endereco: {
        rua: "Rua das Flores, 123",
        cidade: "São Paulo",
        cep: "01234-567"
    },
    funcionarios: [
        { nome: "Ana", cargo: "Developer" },
        { nome: "Bruno", cargo: "Designer" },
        { nome: "Carla", cargo: "Manager" }
    ]
};

// Acessando dados aninhados
store nome_empresa = empresa.nome;
store cidade_empresa = empresa.endereco.cidade;
store primeiro_funcionario = empresa.funcionarios[0].nome;

show "Empresa: " + nome_empresa;
show "Localizada em: " + cidade_empresa;
show "Primeiro funcionário: " + primeiro_funcionario;
```

#### Modificando Objetos
```javascript
store produto = {
    nome: "Notebook",
    preco: 2500,
    categoria: "Eletrônicos"
};

// Modificar propriedades
produto.preco = 2200;
produto.categoria = "Computadores";

// Adicionar nova propriedade
produto.desconto = 10;

show "Produto: " + produto.nome;
show "Novo preço: R$ " + produto.preco;
show "Desconto: " + produto.desconto + "%";
```

### 2.3 Estruturas Mistas

#### Array de Objetos
```javascript
store biblioteca = [
    {
        titulo: "1984",
        autor: "George Orwell",
        ano: 1949,
        disponivel: yes
    },
    {
        titulo: "Dom Casmurro", 
        autor: "Machado de Assis",
        ano: 1899,
        disponivel: no
    },
    {
        titulo: "O Hobbit",
        autor: "J.R.R. Tolkien", 
        ano: 1937,
        disponivel: yes
    }
];

// Acessando livros
store primeiro_livro = biblioteca[0];
store titulo_primeiro = primeiro_livro.titulo;
store autor_segundo = biblioteca[1].autor;

show "Primeiro livro: " + titulo_primeiro;
show "Autor do segundo livro: " + autor_segundo;
```

#### Objeto com Arrays
```javascript
store loja = {
    nome: "SuperMercado ABC",
    categorias: ["Alimentação", "Limpeza", "Bebidas"],
    produtos: [
        { nome: "Arroz", preco: 4.50, categoria: "Alimentação" },
        { nome: "Detergente", preco: 2.80, categoria: "Limpeza" },
        { nome: "Refrigerante", preco: 5.00, categoria: "Bebidas" }
    ],
    funcionarios: {
        gerente: "Maria Silva",
        caixas: ["João", "Ana", "Pedro"],
        estoquistas: ["Carlos", "Lucia"]
    }
};

// Navegando pela estrutura
store nome_loja = loja.nome;
store total_categorias = length(loja.categorias);
store gerente = loja.funcionarios.gerente;
store primeiro_caixa = loja.funcionarios.caixas[0];

show loja.nome + " tem " + total_categorias + " categorias";
show "Gerente: " + gerente;
show "Primeiro caixa: " + primeiro_caixa;
```

### 🏋️ Exercícios do Módulo 2

#### Exercício 2.1: Lista de Compras
```javascript
// Crie uma lista de compras com 5 itens
store lista_compras = ["pão", "leite", "ovos", "frutas", "carne"];

// Mostre cada item com seu número
show "=== LISTA DE COMPRAS ===";
show "1. " + lista_compras[0];
show "2. " + lista_compras[1];
show "3. " + lista_compras[2];
show "4. " + lista_compras[3];
show "5. " + lista_compras[4];

// Adicione mais um item à lista
store novo_item = "chocolate";
store novo_indice = length(lista_compras);
lista_compras[novo_indice] = novo_item;

show "Total de itens: " + length(lista_compras);
```

#### Exercício 2.2: Perfil de Usuário
```javascript
// Crie um perfil completo de usuário
store usuario = {
    informacoes_pessoais: {
        nome_completo: "João Silva Santos",
        idade: 30,
        email: "joao@email.com"
    },
    endereco: {
        rua: "Rua A, 123",
        cidade: "Rio de Janeiro",
        estado: "RJ"
    },
    hobbies: ["leitura", "natação", "programação"],
    redes_sociais: {
        twitter: "@joaosilva",
        linkedin: "joao-silva-santos"
    }
};

// Exiba um resumo formatado do usuário
show "=== PERFIL DO USUÁRIO ===";
show "Nome: " + usuario.informacoes_pessoais.nome_completo;
show "Idade: " + usuario.informacoes_pessoais.idade + " anos";
show "Cidade: " + usuario.endereco.cidade + "/" + usuario.endereco.estado;
show "Hobbies: " + usuario.hobbies[0] + ", " + usuario.hobbies[1] + ", " + usuario.hobbies[2];
```

#### Exercício 2.3: Sistema de Notas
```javascript
// Sistema para calcular média de um aluno
store aluno = {
    nome: "Maria Oliveira",
    disciplina: "Matemática",
    notas: [8.5, 7.0, 9.2, 6.8],
    faltas: 2
};

// Calcule a média das notas
store soma_notas = aluno.notas[0] + aluno.notas[1] + aluno.notas[2] + aluno.notas[3];
store media = soma_notas / length(aluno.notas);

// Determine se está aprovado (média >= 7.0 e faltas <= 5)
store aprovado = (media >= 7.0) also (aluno.faltas <= 5);

show "=== BOLETIM ESCOLAR ===";
show "Aluno: " + aluno.nome;
show "Disciplina: " + aluno.disciplina;
show "Média: " + media;
show "Faltas: " + aluno.faltas;
show "Situação: " + (aprovado ? "APROVADO" : "REPROVADO");
```

---

## 📍 Módulo 3: Funções e Escopo

### 🎯 Objetivos do Módulo
- Criar e usar funções
- Entender parâmetros e retorno
- Trabalhar com escopo de variáveis
- Organizar código com funções

### 3.1 Declaração e Uso de Funções

#### Funções Simples
```javascript
// Função sem parâmetros
build saudar() {
    show "Olá! Bem-vindo ao PetCareScript!";
}

// Chamando a função
saudar();  // Saída: "Olá! Bem-vindo ao PetCareScript!"
```

#### Funções com Parâmetros
```javascript
// Função com um parâmetro
build saudarPessoa(nome) {
    show "Olá, " + nome + "! Como você está?";
}

// Função com múltiplos parâmetros
build apresentar(nome, idade, profissao) {
    show "Meu nome é " + nome;
    show "Tenho " + idade + " anos";
    show "Trabalho como " + profissao;
}

// Chamando as funções
saudarPessoa("Maria");
apresentar("João", 28, "Programador");
```

#### Funções com Retorno
```javascript
// Função que retorna um valor
build somar(a, b) {
    store resultado = a + b;
    give resultado;  // 'give' é equivalente ao 'return'
}

// Função que calcula área de retângulo
build calcularArea(largura, altura) {
    give largura * altura;
}

// Usando funções que retornam valores
store soma = somar(10, 5);
store area = calcularArea(8, 12);

show "Soma: " + soma;      // 15
show "Área: " + area;      // 96
```

### 3.2 Funções Práticas

#### Validação e Verificação
```javascript
// Função para verificar se é maior de idade
build ehMaiorIdade(idade) {
    check (idade >= 18) {
        give yes;
    } otherwise {
        give no;
    }
}

// Função para validar email (versão simples)
build validarEmail(email) {
    // Verifica se contém @ e .
    store temArroba = no;  // Simulação
    store temPonto = no;   // Simulação
    
    // Em uma implementação real, você verificaria os caracteres
    check (length(email) > 5) {
        give yes;  // Validação simplificada
    } otherwise {
        give no;
    }
}

// Testando as funções
store idade = 20;
store email = "user@email.com";

check (ehMaiorIdade(idade)) {
    show "Usuário é maior de idade";
} otherwise {
    show "Usuário é menor de idade";
}

check (validarEmail(email)) {
    show "Email válido";
} otherwise {
    show "Email inválido";
}
```

#### Cálculos Matemáticos
```javascript
// Funções matemáticas úteis
build calcularCircunferencia(raio) {
    store pi = 3.14159;
    give 2 * pi * raio;
}

build calcularIMC(peso, altura) {
    give peso / (altura * altura);
}

build converterCelsiusParaFahrenheit(celsius) {
    give (celsius * 9 / 5) + 32;
}

// Usando as funções
store raio_circulo = 5;
store circunferencia = calcularCircunferencia(raio_circulo);

store peso = 70;
store altura = 1.75;
store imc = calcularIMC(peso, altura);

store temp_celsius = 25;
store temp_fahrenheit = converterCelsiusParaFahrenheit(temp_celsius);

show "Circunferência: " + circunferencia;
show "IMC: " + imc;
show temp_celsius + "°C = " + temp_fahrenheit + "°F";
```

### 3.3 Escopo de Variáveis

#### Escopo Local vs Global
```javascript
// Variável global
store contador_global = 0;

build incrementarContador() {
    // Variável local à função
    store incremento = 1;
    contador_global = contador_global + incremento;
    
    show "Contador agora é: " + contador_global;
}

build exemploEscopo() {
    // Esta variável só existe dentro desta função
    store variavel_local = "Só existe aqui";
    show variavel_local;
    
    // Pode acessar variáveis globais
    show "Contador global: " + contador_global;
}

incrementarContador();  // Contador: 1
incrementarContador();  // Contador: 2
exemploEscopo();

// show variavel_local;  // ❌ ERRO! Variável não existe aqui
```

#### Parâmetros e Escopo
```javascript
build calcularDesconto(preco_original, percentual_desconto) {
    // Os parâmetros são variáveis locais à função
    store valor_desconto = preco_original * (percentual_desconto / 100);
    store preco_final = preco_original - valor_desconto;
    
    // Variáveis locais
    store mensagem = "Desconto aplicado com sucesso!";
    
    show mensagem;
    give preco_final;
}

store preco = 100;
store desconto = 15;
store preco_com_desconto = calcularDesconto(preco, desconto);

show "Preço original: R$ " + preco;
show "Preço final: R$ " + preco_com_desconto;

// Os parâmetros da função não existem aqui
// show preco_original;  // ❌ ERRO!
```

### 3.4 Funções Avançadas

#### Funções que Chamam Outras Funções
```javascript
build calcularSalarioLiquido(salario_bruto, percentual_desconto) {
    store valor_desconto = calcularDesconto(salario_bruto, percentual_desconto);
    give salario_bruto - valor_desconto;
}

build calcularDesconto(valor, percentual) {
    give valor * (percentual / 100);
}

build exibirRelatorioSalario(nome, salario_bruto, desconto_ir) {
    store salario_liquido = calcularSalarioLiquido(salario_bruto, desconto_ir);
    store valor_ir = calcularDesconto(salario_bruto, desconto_ir);
    
    show "=== RELATÓRIO SALARIAL ===";
    show "Funcionário: " + nome;
    show "Salário Bruto: R$ " + salario_bruto;
    show "IR (" + desconto_ir + "%): R$ " + valor_ir;
    show "Salário Líquido: R$ " + salario_liquido;
}

// Usando o sistema
exibirRelatorioSalario("Ana Silva", 5000, 15);
```

#### Funções com Arrays
```javascript
build somarArray(numeros) {
    store soma = 0;
    store i = 0;
    
    // Simulando um loop (veremos loops no próximo módulo)
    soma = soma + numeros[0];
    soma = soma + numeros[1];
    soma = soma + numeros[2];
    soma = soma + numeros[3];
    
    give soma;
}

build encontrarMaior(numeros) {
    store maior = numeros[0];
    
    check (numeros[1] > maior) {
        maior = numeros[1];
    }
    check (numeros[2] > maior) {
        maior = numeros[2];
    }
    check (numeros[3] > maior) {
        maior = numeros[3];
    }
    
    give maior;
}

build calcularMediaArray(numeros) {
    store soma = somarArray(numeros);
    store total = length(numeros);
    give soma / total;
}

// Testando com notas de um aluno
store notas = [8.5, 7.2, 9.1, 6.8];

store soma_total = somarArray(notas);
store maior_nota = encontrarMaior(notas);
store media = calcularMediaArray(notas);

show "Soma das notas: " + soma_total;
show "Maior nota: " + maior_nota;
show "Média: " + media;
```

### 🏋️ Exercícios do Módulo 3

#### Exercício 3.1: Calculadora de Funções
```javascript
// Crie funções para operações matemáticas básicas
build somar(a, b) {
    give a + b;
}

build subtrair(a, b) {
    give a - b;
}

build multiplicar(a, b) {
    give a * b;
}

build dividir(a, b) {
    check (b == 0) {
        show "Erro: Divisão por zero!";
        give 0;
    } otherwise {
        give a / b;
    }
}

// Função principal que usa todas as outras
build calcular(operacao, num1, num2) {
    check (operacao == "soma") {
        give somar(num1, num2);
    } otherwise check (operacao == "subtracao") {
        give subtrair(num1, num2);
    } otherwise check (operacao == "multiplicacao") {
        give multiplicar(num1, num2);
    } otherwise check (operacao == "divisao") {
        give dividir(num1, num2);
    } otherwise {
        show "Operação inválida!";
        give 0;
    }
}

// Teste sua calculadora
store resultado1 = calcular("soma", 10, 5);
store resultado2 = calcular("divisao", 20, 4);
store resultado3 = calcular("multiplicacao", 7, 8);

show "10 + 5 = " + resultado1;
show "20 ÷ 4 = " + resultado2;
show "7 × 8 = " + resultado3;
```

#### Exercício 3.2: Sistema de Avaliação
```javascript
// Sistema para avaliar performance de funcionários
build calcularBonus(salario, performance) {
    check (performance >= 90) {
        give salario * 0.15;  // 15% de bônus
    } otherwise check (performance >= 80) {
        give salario * 0.10;  // 10% de bônus
    } otherwise check (performance >= 70) {
        give salario * 0.05;  // 5% de bônus
    } otherwise {
        give 0;  // Sem bônus
    }
}

build avaliarFuncionario(nome, salario, performance) {
    store bonus = calcularBonus(salario, performance);
    store salario_total = salario + bonus;
    
    show "=== AVALIAÇÃO DE PERFORMANCE ===";
    show "Funcionário: " + nome;
    show "Salário Base: R$ " + salario;
    show "Performance: " + performance + "%";
    show "Bônus: R$ " + bonus;
    show "Salário Total: R$ " + salario_total;
    
    check (performance >= 80) {
        show "Status: EXCELENTE PERFORMANCE! 🌟";
    } otherwise check (performance >= 70) {
        show "Status: BOA PERFORMANCE 👍";
    } otherwise {
        show "Status: PRECISA MELHORAR 📈";
    }
}

// Teste o sistema
avaliarFuncionario("Maria Santos", 4000, 92);
avaliarFuncionario("João Silva", 3500, 78);
avaliarFuncionario("Ana Costa", 4500, 65);
```

#### Exercício 3.3: Conversor de Unidades
```javascript
// Sistema de conversão de unidades
build metrosParaKilometros(metros) {
    give metros / 1000;
}

build kilometrosParaMetros(km) {
    give km * 1000;
}

build quilosParaGramas(quilos) {
    give quilos * 1000;
}

build gramasParaQuilos(gramas) {
    give gramas / 1000;
}

build segundosParaMinutos(segundos) {
    give segundos / 60;
}

build minutosParaSegundos(minutos) {
    give minutos * 60;
}

// Função universal de conversão
build converter(valor, tipo_conversao) {
    check (tipo_conversao == "m_para_km") {
        give metrosParaKilometros(valor);
    } otherwise check (tipo_conversao == "km_para_m") {
        give kilometrosParaMetros(valor);
    } otherwise check (tipo_conversao == "kg_para_g") {
        give quilosParaGramas(valor);
    } otherwise check (tipo_conversao == "g_para_kg") {
        give gramasParaQuilos(valor);
    } otherwise check (tipo_conversao == "s_para_min") {
        give segundosParaMinutos(valor);
    } otherwise check (tipo_conversao == "min_para_s") {
        give minutosParaSegundos(valor);
    } otherwise {
        show "Conversão não suportada!";
        give 0;
    }
}

// Teste o conversor
show "=== CONVERSOR DE UNIDADES ===";
show "5000 metros = " + converter(5000, "m_para_km") + " km";
show "2.5 kg = " + converter(2.5, "kg_para_g") + " gramas";
show "300 segundos = " + converter(300, "s_para_min") + " minutos";
```

---

## 📍 Módulo 4: Estruturas de Controle

### 🎯 Objetivos do Módulo
- Dominar condicionais (if/else)
- Trabalhar com loops (while/for)
- Entender controle de fluxo
- Aplicar em problemas reais

### 4.1 Condicionais (If/Else)

#### Estrutura Básica
```javascript
// Condicional simples
store idade = 20;

check (idade >= 18) {
    show "Você é maior de idade";
}

// If-else
store nota = 7.5;

check (nota >= 7.0) {
    show "Aprovado!";
} otherwise {
    show "Reprovado!";
}
```

#### Múltiplas Condições
```javascript
store pontuacao = 85;

check (pontuacao >= 90) {
    show "Classificação: A - Excelente!";
} otherwise check (pontuacao >= 80) {
    show "Classificação: B - Muito Bom!";
} otherwise check (pontuacao >= 70) {
    show "Classificação: C - Bom";
} otherwise check (pontuacao >= 60) {
    show "Classificação: D - Regular";
} otherwise {
    show "Classificação: F - Insuficiente";
}
```

#### Operadores Lógicos
```javascript
store idade = 25;
store tem_carteira = yes;
store tem_carro = no;

// Operador AND (also)
check (idade >= 18 also tem_carteira == yes) {
    show "Pode dirigir!";
} otherwise {
    show "Não pode dirigir";
}

// Operador OR (either)
check (tem_carro == yes either tem_carteira == yes) {
    show "Tem algum meio de transporte";
} otherwise {
    show "Precisa de transporte público";
}

// Operador NOT (!)
check (!tem_carro) {
    show "Não tem carro";
}

// Combinações complexas
store salario = 5000;
store idade_funcionario = 30;
store tem_experiencia = yes;

check ((salario > 4000 also idade_funcionario > 25) either tem_experiencia == yes) {
    show "Candidato qualificado para promoção";
} otherwise {
    show "Candidato precisa se qualificar mais";
}
```

### 4.2 Loops (Repetições)

#### Loop While (repeat)
```javascript
// Contador simples
store contador = 1;

repeat (contador <= 5) {
    show "Contagem: " + contador;
    contador = contador + 1;
}

// Acumulador
store numero = 1;
store soma = 0;

repeat (numero <= 10) {
    soma = soma + numero;
    numero = numero + 1;
}

show "Soma de 1 até 10: " + soma;  // 55
```

#### Loop For (again)
```javascript
// Loop for básico
again (store i = 0; i < 5; i = i + 1) {
    show "Iteração: " + i;
}

// Trabalhando com arrays
store frutas = ["maçã", "banana", "laranja", "uva"];

again (store i = 0; i < length(frutas); i = i + 1) {
    show "Fruta " + (i + 1) + ": " + frutas[i];
}

// Tabuada
store numero_tabuada = 7;

show "=== TABUADA DO " + numero_tabuada + " ===";
again (store i = 1; i <= 10; i = i + 1) {
    store resultado = numero_tabuada * i;
    show numero_tabuada + " x " + i + " = " + resultado;
}
```

#### Loops Aninhados
```javascript
// Matriz de números
show "=== TABELA DE MULTIPLICAÇÃO ===";

again (store i = 1; i <= 5; i = i + 1) {
    store linha = "";
    again (store j = 1; j <= 5; j = j + 1) {
        store produto = i * j;
        linha = linha + produto + "\t";
    }
    show linha;
}

// Padrão de estrelas
show "=== PADRÃO DE ESTRELAS ===";

again (store linha = 1; linha <= 5; linha = linha + 1) {
    store estrelas = "";
    again (store col = 1; col <= linha; col = col + 1) {
        estrelas = estrelas + "*";
    }
    show estrelas;
}
```

### 4.3 Aplicações Práticas

#### Sistema de Menu
```javascript
build exibirMenu() {
    show "=== MENU PRINCIPAL ===";
    show "1. Cadastrar usuário";
    show "2. Listar usuários";
    show "3. Buscar usuário";
    show "4. Remover usuário";
    show "5. Sair";
}

build processarOpcao(opcao) {
    check (opcao == 1) {
        show "Função: Cadastrar usuário selecionada";
    } otherwise check (opcao == 2) {
        show "Função: Listar usuários selecionada";
    } otherwise check (opcao == 3) {
        show "Função: Buscar usuário selecionada";
    } otherwise check (opcao == 4) {
        show "Função: Remover usuário selecionada";
    } otherwise check (opcao == 5) {
        show "Saindo do sistema...";
    } otherwise {
        show "Opção inválida! Tente novamente.";
    }
}

// Simulando sistema de menu
store opcao_usuario = 1;
store continuar = yes;

repeat (continuar == yes) {
    exibirMenu();
    processarOpcao(opcao_usuario);
    
    // Em um sistema real, você pediria nova entrada do usuário
    opcao_usuario = opcao_usuario + 1;
    
    check (opcao_usuario > 5) {
        continuar = no;
    }
}
```

#### Validação de Dados
```javascript
build validarIdade(idade) {
    check (idade < 0 either idade > 120) {
        give no;
    } otherwise {
        give yes;
    }
}

build validarEmail(email) {
    // Validação simples: deve ter mais de 5 caracteres
    // e conter @ (simulação)
    check (length(email) < 5) {
        give no;
    } otherwise {
        give yes;
    }
}

build validarSenha(senha) {
    // Senha deve ter pelo menos 6 caracteres
    check (length(senha) < 6) {
        give no;
    } otherwise {
        give yes;
    }
}

build cadastrarUsuario(nome, idade, email, senha) {
    store erros = [];
    store erro_count = 0;
    
    // Validar idade
    check (!validarIdade(idade)) {
        erros[erro_count] = "Idade inválida";
        erro_count = erro_count + 1;
    }
    
    // Validar email
    check (!validarEmail(email)) {
        erros[erro_count] = "Email inválido";
        erro_count = erro_count + 1;
    }
    
    // Validar senha
    check (!validarSenha(senha)) {
        erros[erro_count] = "Senha muito fraca";
        erro_count = erro_count + 1;
    }
    
    check (erro_count == 0) {
        show "✅ Usuário cadastrado com sucesso!";
        show "Nome: " + nome;
        show "Idade: " + idade;
        show "Email: " + email;
    } otherwise {
        show "❌ Erros encontrados:";
        again (store i = 0; i < erro_count; i = i + 1) {
            show "- " + erros[i];
        }
    }
}

// Testando cadastros
cadastrarUsuario("João Silva", 25, "joao@email.com", "123456");
cadastrarUsuario("", -5, "email", "123");
```

#### Busca em Array
```javascript
build buscarProduto(produtos, nome_busca) {
    store encontrado = no;
    store indice_encontrado = -1;
    
    again (store i = 0; i < length(produtos); i = i + 1) {
        check (produtos[i].nome == nome_busca) {
            encontrado = yes;
            indice_encontrado = i;
            // Em linguagens reais, usaríamos 'break' aqui
        }
    }
    
    check (encontrado) {
        store produto = produtos[indice_encontrado];
        show "✅ Produto encontrado:";
        show "Nome: " + produto.nome;
        show "Preço: R$ " + produto.preco;
        show "Categoria: " + produto.categoria;
    } otherwise {
        show "❌ Produto '" + nome_busca + "' não encontrado";
    }
}

// Base de dados de produtos
store produtos = [
    { nome: "Notebook", preco: 2500, categoria: "Eletrônicos" },
    { nome: "Mouse", preco: 50, categoria: "Acessórios" },
    { nome: "Teclado", preco: 150, categoria: "Acessórios" },
    { nome: "Monitor", preco: 800, categoria: "Eletrônicos" }
];

// Testando busca
buscarProduto(produtos, "Mouse");
buscarProduto(produtos, "Webcam");
```

### 🏋️ Exercícios do Módulo 4

#### Exercício 4.1: Classificador de Idade
```javascript
// Crie um sistema que classifica pessoas por faixa etária
build classificarIdade(idade) {
    check (idade < 0) {
        give "Idade inválida";
    } otherwise check (idade < 12) {
        give "Criança";
    } otherwise check (idade < 18) {
        give "Adolescente";
    } otherwise check (idade < 60) {
        give "Adulto";
    } otherwise {
        give "Idoso";
    }
}

// Teste com diferentes idades
store idades = [5, 15, 25, 45, 70];

again (store i = 0; i < length(idades); i = i + 1) {
    store idade_atual = idades[i];
    store classificacao = classificarIdade(idade_atual);
    show idade_atual + " anos: " + classificacao;
}
```

#### Exercício 4.2: Contador de Números Pares e Ímpares
```javascript
// Sistema que conta números pares e ímpares em um intervalo
build contarParesImpares(inicio, fim) {
    store pares = 0;
    store impares = 0;
    
    again (store numero = inicio; numero <= fim; numero = numero + 1) {
        store resto = numero - ((numero / 2) * 2);  // Simulação do módulo
        
        check (resto == 0) {
            pares = pares + 1;
        } otherwise {
            impares = impares + 1;
        }
    }
    
    show "=== CONTAGEM DE " + inicio + " ATÉ " + fim + " ===";
    show "Números pares: " + pares;
    show "Números ímpares: " + impares;
    show "Total: " + (pares + impares);
}

// Teste a função
contarParesImpares(1, 20);
contarParesImpares(10, 30);
```

#### Exercício 4.3: Sistema de Login
```javascript
// Sistema simples de autenticação
store usuarios_cadastrados = [
    { username: "admin", password: "admin123", tipo: "administrador" },
    { username: "user1", password: "senha123", tipo: "usuario" },
    { username: "manager", password: "manage456", tipo: "gerente" }
];

build autenticar(username, password) {
    again (store i = 0; i < length(usuarios_cadastrados); i = i + 1) {
        store usuario = usuarios_cadastrados[i];
        
        check (usuario.username == username also usuario.password == password) {
            show "✅ Login realizado com sucesso!";
            show "Bem-vindo, " + username + "!";
            show "Tipo de usuário: " + usuario.tipo;
            give yes;
        }
    }
    
    show "❌ Usuário ou senha incorretos!";
    give no;
}

build sistemaLogin() {
    store tentativas = 0;
    store max_tentativas = 3;
    store logado = no;
    
    repeat (tentativas < max_tentativas also logado == no) {
        show "=== SISTEMA DE LOGIN ===";
        show "Tentativa " + (tentativas + 1) + " de " + max_tentativas;
        
        // Simulando entrada do usuário
        store test_users = ["admin", "user1", "hacker"];
        store test_passes = ["admin123", "senha123", "123456"];
        
        store username = test_users[tentativas];
        store password = test_passes[tentativas];
        
        show "Tentando login com: " + username + " / " + password;
        
        logado = autenticar(username, password);
        tentativas = tentativas + 1;
        
        check (!logado also tentativas < max_tentativas) {
            show "Tente novamente.\n";
        }
    }
    
    check (!logado) {
        show "🔒 Muitas tentativas falharam. Acesso bloqueado!";
    }
}

// Execute o sistema
sistemaLogin();
```

---

## 📍 Módulo 5: Programação Orientada a Objetos

### 🎯 Objetivos do Módulo
- Entender conceitos de POO
- Criar blueprints (classes)
- Trabalhar com herança
- Aplicar encapsulamento

### 5.1 Conceitos Fundamentais

#### O que são Blueprints?
```javascript
// Blueprint é como um "molde" para criar objetos
blueprint Pessoa {
    // Construtor - executado quando criamos uma nova pessoa
    build init(nome, idade) {
        self.nome = nome;           // 'self' refere-se ao objeto atual
        self.idade = idade;
        self.energia = 100;
    }
    
    // Métodos - ações que a pessoa pode fazer
    build falar() {
        show self.nome + " está falando";
    }
    
    build andar() {
        check (self.energia > 0) {
            self.energia = self.energia - 10;
            show self.nome + " está andando. Energia: " + self.energia;
        } otherwise {
            show self.nome + " está muito cansado para andar";
        }
    }
    
    build descansar() {
        self.energia = 100;
        show self.nome + " descansou e recuperou a energia!";
    }
    
    build apresentar() {
        show "Olá! Meu nome é " + self.nome + " e tenho " + self.idade + " anos";
    }
}

// Criando objetos (instâncias) do blueprint
store pessoa1 = Pessoa("Maria", 25);
store pessoa2 = Pessoa("João", 30);

// Usando os métodos
pessoa1.apresentar();   // "Olá! Meu nome é Maria e tenho 25 anos"
pessoa2.falar();        // "João está falando"

pessoa1.andar();        // "Maria está andando. Energia: 90"
pessoa1.andar();        // "Maria está andando. Energia: 80"
pessoa1.descansar();    // "Maria descansou e recuperou a energia!"
```

### 5.2 Blueprints Complexos

#### Sistema de Conta Bancária
```javascript
blueprint ContaBancaria {
    build init(numero_conta, titular, saldo_inicial) {
        self.numero = numero_conta;
        self.titular = titular;
        self.saldo = saldo_inicial;
        self.historico = [];
        self.contador_transacoes = 0;
    }
    
    build depositar(valor) {
        check (valor > 0) {
            self.saldo = self.saldo + valor;
            self.adicionarHistorico("Depósito", valor);
            show "✅ Depósito realizado! Novo saldo: R$ " + self.saldo;
        } otherwise {
            show "❌ Valor inválido para depósito";
        }
    }
    
    build sacar(valor) {
        check (valor > 0 also valor <= self.saldo) {
            self.saldo = self.saldo - valor;
            self.adicionarHistorico("Saque", valor);
            show "✅ Saque realizado! Novo saldo: R$ " + self.saldo;
        } otherwise check (valor > self.saldo) {
            show "❌ Saldo insuficiente. Saldo atual: R$ " + self.saldo;
        } otherwise {
            show "❌ Valor inválido para saque";
        }
    }
    
    build transferir(valor, conta_destino) {
        check (valor > 0 also valor <= self.saldo) {
            self.saldo = self.saldo - valor;
            conta_destino.saldo = conta_destino.saldo + valor;
            
            self.adicionarHistorico("Transferência enviada", valor);
            conta_destino.adicionarHistorico("Transferência recebida", valor);
            
            show "✅ Transferência realizada!";
            show "Seu novo saldo: R$ " + self.saldo;
        } otherwise {
            show "❌ Transferência não autorizada";
        }
    }
    
    build consultarSaldo() {
        show "💰 Saldo atual de " + self.titular + ": R$ " + self.saldo;
    }
    
    build adicionarHistorico(tipo, valor) {
        store transacao = {
            tipo: tipo,
            valor: valor,
            saldo_apos: self.saldo
        };
        
        self.historico[self.contador_transacoes] = transacao;
        self.contador_transacoes = self.contador_transacoes + 1;
    }
    
    build extrato() {
        show "=== EXTRATO BANCÁRIO ===";
        show "Conta: " + self.numero + " - " + self.titular;
        
        again (store i = 0; i < self.contador_transacoes; i = i + 1) {
            store trans = self.historico[i];
            show (i + 1) + ". " + trans.tipo + ": R$ " + trans.valor;
        }
        
        show "Saldo atual: R$ " + self.saldo;
    }
}

// Testando o sistema bancário
store conta_maria = ContaBancaria("12345", "Maria Silva", 1000);
store conta_joao = ContaBancaria("67890", "João Santos", 500);

conta_maria.consultarSaldo();
conta_maria.depositar(200);
conta_maria.sacar(150);
conta_maria.transferir(100, conta_joao);

conta_joao.consultarSaldo();
conta_maria.extrato();
```

### 5.3 Herança

#### Blueprint Base e Especialização
```javascript
// Blueprint base para todos os animais
blueprint Animal {
    build init(nome, especie) {
        self.nome = nome;
        self.especie = especie;
        self.energia = 100;
        self.felicidade = 50;
    }
    
    build comer() {
        self.energia = self.energia + 20;
        self.felicidade = self.felicidade + 10;
        show self.nome + " está comendo. Energia: " + self.energia;
    }
    
    build dormir() {
        self.energia = 100;
        show self.nome + " dormiu e restaurou a energia!";
    }
    
    build brincar() {
        check (self.energia >= 20) {
            self.energia = self.energia - 20;
            self.felicidade = self.felicidade + 30;
            show self.nome + " está brincando! Felicidade: " + self.felicidade;
        } otherwise {
            show self.nome + " está muito cansado para brincar";
        }
    }
    
    build status() {
        show "=== STATUS DE " + self.nome + " ===";
        show "Espécie: " + self.especie;
        show "Energia: " + self.energia;
        show "Felicidade: " + self.felicidade;
    }
}

// Especialização para cães
blueprint Cachorro from Animal {
    build init(nome, raca) {
        parent.init(nome, "Cachorro");  // Chama o construtor do Animal
        self.raca = raca;
        self.latidos = 0;
    }
    
    build latir() {
        self.latidos = self.latidos + 1;
        self.energia = self.energia - 5;
        show self.nome + " faz: Au au! (" + self.latidos + "º latido)";
    }
    
    build buscarBola() {
        check (self.energia >= 30) {
            self.energia = self.energia - 30;
            self.felicidade = self.felicidade + 25;
            show self.nome + " correu atrás da bola! 🎾";
        } otherwise {
            show self.nome + " está muito cansado para buscar a bola";
        }
    }
    
    build status() {
        parent.status();  // Chama o método status do Animal
        show "Raça: " + self.raca;
        show "Latidos hoje: " + self.latidos;
    }
}

// Especialização para gatos
blueprint Gato from Animal {
    build init(nome, cor) {
        parent.init(nome, "Gato");
        self.cor = cor;
        self.ronronos = 0;
    }
    
    build miar() {
        show self.nome + " faz: Miau!";
    }
    
    build ronronar() {
        self.ronronos = self.ronronos + 1;
        self.felicidade = self.felicidade + 15;
        show self.nome + " está ronronando... ♪ (" + self.ronronos + "º ronrono)";
    }
    
    build escalarArvore() {
        check (self.energia >= 25) {
            self.energia = self.energia - 25;
            self.felicidade = self.felicidade + 20;
            show self.nome + " subiu na árvore! 🌳";
        } otherwise {
            show self.nome + " está muito cansado para escalar";
        }
    }
    
    build status() {
        parent.status();
        show "Cor: " + self.cor;
        show "Ronronos hoje: " + self.ronronos;
    }
}

// Testando herança
store rex = Cachorro("Rex", "Golden Retriever");
store mimi = Gato("Mimi", "Branco");

rex.latir();
rex.buscarBola();
rex.comer();
rex.status();

show "";

mimi.miar();
mimi.ronronar();
mimi.escalarArvore();
mimi.status();
```

### 5.4 Sistema Complexo com POO

#### Sistema de Gerenciamento de Escola
```javascript
// Blueprint base para pessoas na escola
blueprint Pessoa {
    build init(nome, idade, cpf) {
        self.nome = nome;
        self.idade = idade;
        self.cpf = cpf;
        self.ativo = yes;
    }
    
    build apresentar() {
        show "Nome: " + self.nome + ", Idade: " + self.idade;
    }
}

// Aluno herda de Pessoa
blueprint Aluno from Pessoa {
    build init(nome, idade, cpf, matricula) {
        parent.init(nome, idade, cpf);
        self.matricula = matricula;
        self.notas = [];
        self.faltas = 0;
        self.total_notas = 0;
    }
    
    build adicionarNota(nota) {
        check (nota >= 0 also nota <= 10) {
            self.notas[self.total_notas] = nota;
            self.total_notas = self.total_notas + 1;
            show "Nota " + nota + " adicionada para " + self.nome;
        } otherwise {
            show "Nota inválida! Deve estar entre 0 e 10";
        }
    }
    
    build adicionarFalta() {
        self.faltas = self.faltas + 1;
        show self.nome + " faltou. Total de faltas: " + self.faltas;
    }
    
    build calcularMedia() {
        check (self.total_notas == 0) {
            give 0;
        } otherwise {
            store soma = 0;
            again (store i = 0; i < self.total_notas; i = i + 1) {
                soma = soma + self.notas[i];
            }
            give soma / self.total_notas;
        }
    }
    
    build situacao() {
        store media = self.calcularMedia();
        
        check (media >= 7.0 also self.faltas <= 5) {
            give "APROVADO";
        } otherwise check (media >= 5.0 also self.faltas <= 10) {
            give "RECUPERAÇÃO";
        } otherwise {
            give "REPROVADO";
        }
    }
    
    build boletim() {
        show "=== BOLETIM DE " + self.nome + " ===";
        show "Matrícula: " + self.matricula;
        show "Notas: ";
        
        again (store i = 0; i < self.total_notas; i = i + 1) {
            show "  " + (i + 1) + "ª nota: " + self.notas[i];
        }
        
        show "Média: " + self.calcularMedia();
        show "Faltas: " + self.faltas;
        show "Situação: " + self.situacao();
    }
}

// Professor herda de Pessoa
blueprint Professor from Pessoa {
    build init(nome, idade, cpf, disciplina, salario) {
        parent.init(nome, idade, cpf);
        self.disciplina = disciplina;
        self.salario = salario;
        self.turmas = [];
        self.total_turmas = 0;
    }
    
    build adicionarTurma(turma) {
        self.turmas[self.total_turmas] = turma;
        self.total_turmas = self.total_turmas + 1;
        show "Professor " + self.nome + " adicionado à turma " + turma;
    }
    
    build darNota(aluno, nota) {
        aluno.adicionarNota(nota);
        show "Professor " + self.nome + " deu nota " + nota + " para " + aluno.nome;
    }
    
    build relatorio() {
        show "=== RELATÓRIO DO PROFESSOR ===";
        show "Nome: " + self.nome;
        show "Disciplina: " + self.disciplina;
        show "Salário: R$ " + self.salario;
        show "Turmas: " + self.total_turmas;
    }
}

// Escola - sistema principal
blueprint Escola {
    build init(nome) {
        self.nome = nome;
        self.alunos = [];
        self.professores = [];
        self.total_alunos = 0;
        self.total_professores = 0;
    }
    
    build matricularAluno(aluno) {
        self.alunos[self.total_alunos] = aluno;
        self.total_alunos = self.total_alunos + 1;
        show "✅ Aluno " + aluno.nome + " matriculado na " + self.nome;
    }
    
    build contratarProfessor(professor) {
        self.professores[self.total_professores] = professor;
        self.total_professores = self.total_professores + 1;
        show "✅ Professor " + professor.nome + " contratado pela " + self.nome;
    }
    
    build relatorioEscola() {
        show "=== RELATÓRIO DA " + self.nome + " ===";
        show "Total de alunos: " + self.total_alunos;
        show "Total de professores: " + self.total_professores;
        
        show "\n--- ALUNOS ---";
        again (store i = 0; i < self.total_alunos; i = i + 1) {
            store aluno = self.alunos[i];
            show (i + 1) + ". " + aluno.nome + " - " + aluno.situacao();
        }
        
        show "\n--- PROFESSORES ---";
        again (store i = 0; i < self.total_professores; i = i + 1) {
            store prof = self.professores[i];
            show (i + 1) + ". " + prof.nome + " - " + prof.disciplina;
        }
    }
}

// Testando o sistema escolar
store escola = Escola("Colégio PetCareScript");

// Criando alunos
store aluno1 = Aluno("Ana Silva", 16, "123.456.789-01", "2024001");
store aluno2 = Aluno("Bruno Santos", 17, "987.654.321-02", "2024002");

// Criando professores
store prof_mat = Professor("Carlos Oliveira", 35, "111.222.333-44", "Matemática", 4500);
store prof_port = Professor("Diana Costa", 28, "555.666.777-88", "Português", 4200);

// Matriculando e contratando
escola.matricularAluno(aluno1);
escola.matricularAluno(aluno2);
escola.contratarProfessor(prof_mat);
escola.contratarProfessor(prof_port);

// Professores dando notas
prof_mat.darNota(aluno1, 8.5);
prof_mat.darNota(aluno1, 7.2);
prof_mat.darNota(aluno1, 9.1);

prof_port.darNota(aluno2, 6.8);
prof_port.darNota(aluno2, 7.5);

// Adicionando faltas
aluno2.adicionarFalta();
aluno2.adicionarFalta();

// Relatórios
aluno1.boletim();
show "";
aluno2.boletim();
show "";
escola.relatorioEscola();
```

### 🏋️ Exercícios do Módulo 5

#### Exercício 5.1: Sistema de Veículos
```javascript
// Crie um sistema de veículos com herança
blueprint Veiculo {
    build init(marca, modelo, ano, preco) {
        self.marca = marca;
        self.modelo = modelo;
        self.ano = ano;
        self.preco = preco;
        self.ligado = no;
        self.velocidade = 0;
    }
    
    build ligar() {
        check (!self.ligado) {
            self.ligado = yes;
            show self.marca + " " + self.modelo + " foi ligado";
        } otherwise {
            show "Veículo já está ligado";
        }
    }
    
    build acelerar(incremento) {
        check (self.ligado) {
            self.velocidade = self.velocidade + incremento;
            show "Acelerando... Velocidade atual: " + self.velocidade + " km/h";
        } otherwise {
            show "Ligue o veículo primeiro!";
        }
    }
    
    build frear() {
        check (self.velocidade > 0) {
            self.velocidade = 0;
            show "Veículo parou";
        } otherwise {
            show "Veículo já está parado";
        }
    }
    
    build info() {
        show "=== INFORMAÇÕES DO VEÍCULO ===";
        show "Marca: " + self.marca;
        show "Modelo: " + self.modelo;
        show "Ano: " + self.ano;
        show "Preço: R$ " + self.preco;
        show "Status: " + (self.ligado ? "Ligado" : "Desligado");
        show "Velocidade: " + self.velocidade + " km/h";
    }
}

blueprint Carro from Veiculo {
    build init(marca, modelo, ano, preco, portas) {
        parent.init(marca, modelo, ano, preco);
        self.portas = portas;
        self.tanque = 50;  // litros
    }
    
    build abrirPorta() {
        show "Porta do " + self.modelo + " aberta";
    }
    
    build abastecer(litros) {
        self.tanque = self.tanque + litros;
        show "Abastecido com " + litros + "L. Tanque: " + self.tanque + "L";
    }
    
    build info() {
        parent.info();
        show "Portas: " + self.portas;
        show "Combustível: " + self.tanque + "L";
    }
}

blueprint Moto from Veiculo {
    build init(marca, modelo, ano, preco, cilindradas) {
        parent.init(marca, modelo, ano, preco);
        self.cilindradas = cilindradas;
    }
    
    build empinar() {
        check (self.ligado also self.velocidade > 20) {
            show self.modelo + " empinando! 🏍️";
        } otherwise {
            show "Precisa estar ligado e em movimento para empinar";
        }
    }
    
    build info() {
        parent.info();
        show "Cilindradas: " + self.cilindradas + "cc";
    }
}

// Teste seu sistema
store carro = Carro("Toyota", "Corolla", 2023, 85000, 4);
store moto = Moto("Honda", "CB600", 2022, 35000, 600);

carro.ligar();
carro.acelerar(50);
carro.abrirPorta();
carro.abastecer(30);
carro.info();

show "";

moto.ligar();
moto.acelerar(40);
moto.empinar();
moto.info();
```

#### Exercício 5.2: Sistema de E-commerce
```javascript
// Sistema de loja online com produtos e carrinho
blueprint Produto {
    build init(id, nome, preco, categoria, estoque) {
        self.id = id;
        self.nome = nome;
        self.preco = preco;
        self.categoria = categoria;
        self.estoque = estoque;
    }
    
    build reduzirEstoque(quantidade) {
        check (self.estoque >= quantidade) {
            self.estoque = self.estoque - quantidade;
            give yes;
        } otherwise {
            give no;
        }
    }
    
    build info() {
        show "ID: " + self.id + " | " + self.nome;
        show "Preço: R$ " + self.preco;
        show "Categoria: " + self.categoria;
        show "Estoque: " + self.estoque + " unidades";
    }
}

blueprint CarrinhoCompras {
    build init() {
        self.itens = [];
        self.total_itens = 0;
    }
    
    build adicionarItem(produto, quantidade) {
        check (produto.reduzirEstoque(quantidade)) {
            store item = {
                produto: produto,
                quantidade: quantidade,
                subtotal: produto.preco * quantidade
            };
            
            self.itens[self.total_itens] = item;
            self.total_itens = self.total_itens + 1;
            
            show "✅ " + quantidade + "x " + produto.nome + " adicionado ao carrinho";
        } otherwise {
            show "❌ Estoque insuficiente para " + produto.nome;
        }
    }
    
    build calcularTotal() {
        store total = 0;
        again (store i = 0; i < self.total_itens; i = i + 1) {
            total = total + self.itens[i].subtotal;
        }
        give total;
    }
    
    build exibirCarrinho() {
        show "=== CARRINHO DE COMPRAS ===";
        
        check (self.total_itens == 0) {
            show "Carrinho vazio";
            give;
        }
        
        again (store i = 0; i < self.total_itens; i = i + 1) {
            store item = self.itens[i];
            show (i + 1) + ". " + item.produto.nome;