Lição 6: Operações de Campo

Narrativa

O piloto realiza cálculos de campo o tempo todo — calcular distância até o alvo, energia consumida, estado dos escudos. Operadores são as ferramentas básicas para essas operações.

Na cabine de uma mecha, você não tem tempo para hesitar. Quando o sensor detecta um alvo, você precisa calcular a distância instantaneamente. Quando o sistema de armas está carregando, você precisa avaliar se seus escudos aguentarão o próximo ataque. Esses cálculos rápidos separam pilotos experientes de recrutas.

A Academia Æther treina seus pilotos para dominarem operações matemáticas como um reflexo. Aritmética para cálculos de trajetória, comparações para avaliação de ameaças, lógica booleana para decisões automáticas — todas essas operações acontecem em frações de segundo no campo de batalha.

Conceito

Rust fornece operadores familiares para manipular dados. Os operadores aritméticos (+, -, *, /, %) realizam cálculos matemáticos. Operadores de comparação (==, !=, <, >, <=, >=) avaliam relações entre valores, retornando bool. Operadores lógicos (&&, ||, !) combinam condições booleanas.

Para operações de baixo nível, Rust oferece operadores bitwise (&, |, ^, !, <<, >>). Estes manipulam bits individuais — úteis para máscaras de permissão, flags de sistema e otimizações. Todos os operadores seguem precedência matemática padrão, e parênteses podem alterar a ordem de avaliação.

Rust não possui coerção implícita entre tipos numéricos. Converter i32 para f64 requer conversão explícita com as. Isso previne erros sutis quando tipos incompatíveis se misturam em operações.

Requisitos

• Entrada: Coordenadas, valores de status, máscaras de bits, condições ambientais
• Processamento: Aplicar operadores aritméticos, comparativos, lógicos e bitwise
• Saída: Resultados calculados, avaliações de status, decisões booleanas

Design de Dados

Esta lição trabalha com tipos primitivos e operações diretas:

// Cálculo de distância euclidiana
pub fn calcular_distancia(x1: f64, y1: f64, x2: f64, y2: f64) -> f64;

// Avaliação de status usando comparações
pub fn avaliar_status_combate(energia: i32, escudos: i32, vida: i32) -> &'static str;

// Operações bitwise para máscaras
pub fn combinar_mascaras_bits(mascara1: u8, mascara2: u8) -> u8;

// Lógica booleana para decisões
pub fn eh_zona_segura(temperatura: i32, pressao: i32) -> bool;

// Cálculo de dano com conversão de tipos
pub fn calcular_dano(base: i32, multiplicador: f64, defesa: i32) -> i32;

Diagrama Conceitual

flowchart TD
    A[Dados de Entrada] --> B{Operadores}
    B -->|Aritméticos| C[Cálculos Numéricos]
    B -->|Comparação| D[Avaliações Booleanas]
    B -->|Lógicos| E[Decisões Complexas]
    B -->|Bitwise| F[Manipulação de Bits]
    C --> G[Resultado Final]
    D --> G
    E --> G
    F --> G

Funções e Módulos

//! Lição 6: Operações de Campo
//!
//! Operadores aritméticos, de comparação, lógicos e bitwise.

/// Calcula a distância euclidiana entre dois pontos (x1, y1) e (x2, y2)
pub fn calcular_distancia(x1: f64, y1: f64, x2: f64, y2: f64) -> f64;

/// Avalia o status de combate baseado em energia, escudos e vida
/// Retorna: "Critico", "Perigoso", "Cautela" ou "Operacional"
pub fn avaliar_status_combate(energia: i32, escudos: i32, vida: i32) -> &'static str;

/// Combina duas máscaras de bits usando operação OR
pub fn combinar_mascaras_bits(mascara1: u8, mascara2: u8) -> u8;

/// Verifica se condições de temperatura e pressão estão na zona segura
pub fn eh_zona_segura(temperatura: i32, pressao: i32) -> bool;

/// Calcula o dano final considerando base, multiplicador e defesa
pub fn calcular_dano(base: i32, multiplicador: f64, defesa: i32) -> i32;

Exemplo do Conceito

fn main() {
    // Operadores aritméticos
    let distancia = calcular_distancia(0.0, 0.0, 3.0, 4.0);
    println!("Distância: {}", distancia); // 5.0
    
    // Operadores de comparação e lógicos
    let status = avaliar_status_combate(75, 80, 90);
    println!("Status: {}", status);
    
    // Operadores bitwise
    let permissao_combinada = combinar_mascaras_bits(0b00001111, 0b11110000);
    println!("Máscara: {:08b}", permissao_combinada);
    
    // Conversão de tipos com 'as'
    let inteiro: i32 = 10;
    let flutuante: f64 = inteiro as f64 * 1.5;
    println!("Convertido: {}", flutuante);
}

fn calcular_distancia(x1: f64, y1: f64, x2: f64, y2: f64) -> f64 {
    let dx = x2 - x1;
    let dy = y2 - y1;
    (dx * dx + dy * dy).sqrt()
}

fn avaliar_status_combate(energia: i32, escudos: i32, vida: i32) -> &'static str {
    // Dica: comece pelo caso mais crítico e vá relaxando as condições.
    // Exemplo do primeiro ramo (complete os demais):
    if energia < 20 || escudos < 20 || vida < 20 {
        "Critico"
    } else {
        // ... complete com os níveis "Perigoso", "Cautela" e "Operacional"
        todo!()
    }
}

Explicação:

• Linha 3-4: Calcula distância euclidiana usando operadores aritméticos e método sqrt()
• Linha 7-8: Avalia status usando operadores de comparação (<) e lógicos (||)
• Linha 11-12: Combina máscaras de bits com operador OR (|)
• Linha 15-17: Converte tipos explicitamente com as antes de operações entre tipos diferentes
• Linha 22-25: Usa precedência de operadores — multiplicação antes de adição

Missão

1. Implementar calcular_distancia: Use a fórmula da distância euclidiana √((x2-x1)² + (y2-y1)²)
2. Implementar avaliar_status_combate: Use operadores de comparação e lógicos para determinar o status
3. Implementar combinar_mascaras_bits: Use operador bitwise OR (|) para combinar máscaras
4. Implementar eh_zona_segura: Use operadores lógicos (&&) para verificar múltiplas condições. A zona é segura quando a temperatura está entre -10 e 80 (inclusive) e a pressão está entre 0 e 1013 (inclusive)
5. Implementar calcular_dano: Converta tipos adequadamente para calcular (base * multiplicador) - defesa

Diagrama de Fluxo da Missão

flowchart LR
    A[Início] --> B[Implementar calcular_distancia]
    B --> C[Implementar avaliar_status_combate]
    C --> D[Implementar combinar_mascaras_bits]
    D --> E[Implementar eh_zona_segura]
    E --> F[Implementar calcular_dano]
    F --> G{Testes Passam?}
    G -->|Sim| H[Concluído]
    G -->|Não| I[Revisar Operadores] --> B

Como Executar

# Executar testes
cargo test

# Verificar lint
cargo clippy -- -D warnings

# Formatar código
cargo fmt --check

Dicas

• Rust não converte tipos implicitamente — use as para converter entre tipos numéricos
• Operadores lógicos && (AND) e || (OR) usam curto-circuito: param na primeira condição falsa/verdadeira
• Para distância euclidiana, eleve ao quadrado com *, não com ^ (que é XOR bitwise)
• Teste valores de borda: zeros, negativos, valores máximos para cada tipo
• Precedência de operadores segue matemática padrão: use parênteses para clareza