Carreira em Desenvolvimento de Jogos com Rust

// O padrão ECS é idiomático em Rust
// Componentes são structs simples
struct Posicao { x: f32, y: f32 }
struct Velocidade { dx: f32, dy: f32 }
struct Vida { atual: i32, maxima: i32 }

// Sistemas são funções que operam sobre conjuntos de componentes
// O type system garante acesso seguro a dados entre sistemas paralelos

use bevy::prelude::*;

// === Componentes ===

#[derive(Component)]
struct Jogador {
    velocidade: f32,
    vida: i32,
}

#[derive(Component)]
struct Inimigo {
    velocidade: f32,
    direcao: Vec2,
}

#[derive(Component)]
struct Projetil {
    velocidade: f32,
    direcao: Vec2,
    dano: i32,
}

#[derive(Component)]
struct Pontuacao(u32);

// === Recursos ===

#[derive(Resource)]
struct ConfigJogo {
    velocidade_jogador: f32,
    velocidade_projetil: f32,
    intervalo_spawn: f32,
}

impl Default for ConfigJogo {
    fn default() -> Self {
        ConfigJogo {
            velocidade_jogador: 300.0,
            velocidade_projetil: 500.0,
            intervalo_spawn: 2.0,
        }
    }
}

#[derive(Resource)]
struct TimerSpawn(Timer);

// === Sistemas ===

/// Sistema de setup: cria entidades iniciais
fn setup(
    mut commands: Commands,
    asset_server: Res<AssetServer>,
) {
    // Câmera
    commands.spawn(Camera2d::default());

    // Jogador
    commands.spawn((
        Sprite {
            color: Color::srgb(0.2, 0.6, 1.0),
            custom_size: Some(Vec2::new(40.0, 40.0)),
            ..default()
        },
        Transform::from_xyz(0.0, -200.0, 0.0),
        Jogador {
            velocidade: 300.0,
            vida: 100,
        },
    ));

    // Recurso de pontuação
    commands.insert_resource(ConfigJogo::default());
    commands.insert_resource(TimerSpawn(Timer::from_seconds(
        2.0,
        TimerMode::Repeating,
    )));

    println!("Jogo inicializado!");
}

/// Sistema de movimento do jogador
fn mover_jogador(
    keyboard: Res<ButtonInput<KeyCode>>,
    time: Res<Time>,
    mut query: Query<(&Jogador, &mut Transform)>,
) {
    for (jogador, mut transform) in query.iter_mut() {
        let mut direcao = Vec3::ZERO;

        if keyboard.pressed(KeyCode::ArrowLeft) || keyboard.pressed(KeyCode::KeyA) {
            direcao.x -= 1.0;
        }
        if keyboard.pressed(KeyCode::ArrowRight) || keyboard.pressed(KeyCode::KeyD) {
            direcao.x += 1.0;
        }
        if keyboard.pressed(KeyCode::ArrowUp) || keyboard.pressed(KeyCode::KeyW) {
            direcao.y += 1.0;
        }
        if keyboard.pressed(KeyCode::ArrowDown) || keyboard.pressed(KeyCode::KeyS) {
            direcao.y -= 1.0;
        }

        if direcao.length() > 0.0 {
            direcao = direcao.normalize();
        }

        transform.translation +=
            direcao * jogador.velocidade * time.delta_secs();

        // Limitar posição à tela
        transform.translation.x = transform.translation.x.clamp(-400.0, 400.0);
        transform.translation.y = transform.translation.y.clamp(-300.0, 300.0);
    }
}

/// Sistema de disparo de projéteis
fn disparar_projetil(
    mut commands: Commands,
    keyboard: Res<ButtonInput<KeyCode>>,
    config: Res<ConfigJogo>,
    query: Query<&Transform, With<Jogador>>,
) {
    if keyboard.just_pressed(KeyCode::Space) {
        for transform in query.iter() {
            commands.spawn((
                Sprite {
                    color: Color::srgb(1.0, 1.0, 0.0),
                    custom_size: Some(Vec2::new(8.0, 16.0)),
                    ..default()
                },
                Transform::from_translation(transform.translation),
                Projetil {
                    velocidade: config.velocidade_projetil,
                    direcao: Vec2::new(0.0, 1.0),
                    dano: 25,
                },
            ));
        }
    }
}

/// Sistema de movimento dos projéteis
fn mover_projeteis(
    mut commands: Commands,
    time: Res<Time>,
    mut query: Query<(Entity, &Projetil, &mut Transform)>,
) {
    for (entity, projetil, mut transform) in query.iter_mut() {
        transform.translation.x +=
            projetil.direcao.x * projetil.velocidade * time.delta_secs();
        transform.translation.y +=
            projetil.direcao.y * projetil.velocidade * time.delta_secs();

        // Remover projéteis fora da tela
        if transform.translation.y > 400.0
            || transform.translation.y < -400.0
            || transform.translation.x > 500.0
            || transform.translation.x < -500.0
        {
            commands.entity(entity).despawn();
        }
    }
}

/// Sistema de spawn de inimigos
fn spawn_inimigos(
    mut commands: Commands,
    time: Res<Time>,
    mut timer: ResMut<TimerSpawn>,
) {
    timer.0.tick(time.delta());

    if timer.0.just_finished() {
        let x = (rand::random::<f32>() - 0.5) * 700.0;

        commands.spawn((
            Sprite {
                color: Color::srgb(1.0, 0.2, 0.2),
                custom_size: Some(Vec2::new(35.0, 35.0)),
                ..default()
            },
            Transform::from_xyz(x, 350.0, 0.0),
            Inimigo {
                velocidade: 100.0 + rand::random::<f32>() * 100.0,
                direcao: Vec2::new(0.0, -1.0),
            },
        ));
    }
}

/// Sistema de movimento dos inimigos
fn mover_inimigos(
    mut commands: Commands,
    time: Res<Time>,
    mut query: Query<(Entity, &Inimigo, &mut Transform)>,
) {
    for (entity, inimigo, mut transform) in query.iter_mut() {
        transform.translation.y +=
            inimigo.direcao.y * inimigo.velocidade * time.delta_secs();

        // Remover inimigos que saíram da tela
        if transform.translation.y < -400.0 {
            commands.entity(entity).despawn();
        }
    }
}

/// Sistema de colisão simples
fn detectar_colisoes(
    mut commands: Commands,
    projeteis: Query<(Entity, &Transform, &Projetil)>,
    inimigos: Query<(Entity, &Transform), With<Inimigo>>,
) {
    for (proj_entity, proj_transform, _projetil) in projeteis.iter() {
        for (inimigo_entity, inimigo_transform) in inimigos.iter() {
            let distancia = proj_transform
                .translation
                .distance(inimigo_transform.translation);

            if distancia < 30.0 {
                commands.entity(proj_entity).despawn();
                commands.entity(inimigo_entity).despawn();
            }
        }
    }
}

/// Ponto de entrada do jogo
fn main() {
    App::new()
        .add_plugins(DefaultPlugins.set(WindowPlugin {
            primary_window: Some(Window {
                title: "Meu Jogo Rust - Bevy".to_string(),
                resolution: (800.0, 600.0).into(),
                ..default()
            }),
            ..default()
        }))
        .add_systems(Startup, setup)
        .add_systems(
            Update,
            (
                mover_jogador,
                disparar_projetil,
                mover_projeteis,
                spawn_inimigos,
                mover_inimigos,
                detectar_colisoes,
            ),
        )
        .run();
}

use macroquad::prelude::*;

#[macroquad::main("Pong Simples")]
async fn main() {
    let mut jogador_y: f32 = 300.0;
    let mut bola_x: f32 = 400.0;
    let mut bola_y: f32 = 300.0;
    let mut vel_x: f32 = 200.0;
    let mut vel_y: f32 = 150.0;
    let mut pontos: u32 = 0;

    let velocidade_paddle: f32 = 400.0;
    let tamanho_paddle: f32 = 80.0;
    let raio_bola: f32 = 8.0;

    loop {
        let dt = get_frame_time();

        // Input do jogador
        if is_key_down(KeyCode::Up) {
            jogador_y -= velocidade_paddle * dt;
        }
        if is_key_down(KeyCode::Down) {
            jogador_y += velocidade_paddle * dt;
        }
        jogador_y = jogador_y.clamp(0.0, 600.0 - tamanho_paddle);

        // Mover bola
        bola_x += vel_x * dt;
        bola_y += vel_y * dt;

        // Colisão com paredes
        if bola_y <= 0.0 || bola_y >= 600.0 {
            vel_y = -vel_y;
        }
        if bola_x >= 800.0 {
            vel_x = -vel_x;
        }

        // Colisão com paddle do jogador
        if bola_x <= 30.0
            && bola_y >= jogador_y
            && bola_y <= jogador_y + tamanho_paddle
        {
            vel_x = vel_x.abs();
            pontos += 1;
        }

        // Reset se a bola sair pela esquerda
        if bola_x < 0.0 {
            bola_x = 400.0;
            bola_y = 300.0;
            pontos = 0;
        }

        // Renderização
        clear_background(BLACK);

        // Paddle do jogador
        draw_rectangle(10.0, jogador_y, 15.0, tamanho_paddle, WHITE);

        // Bola
        draw_circle(bola_x, bola_y, raio_bola, YELLOW);

        // Linha central
        for i in 0..30 {
            draw_rectangle(
                398.0,
                i as f32 * 20.0,
                4.0,
                10.0,
                GRAY,
            );
        }

        // Pontuação
        draw_text(
            &format!("Pontos: {}", pontos),
            350.0,
            30.0,
            30.0,
            WHITE,
        );

        // FPS
        draw_text(
            &format!("FPS: {}", get_fps()),
            10.0,
            590.0,
            20.0,
            GREEN,
        );

        next_frame().await;
    }
}

use wgpu;

/// Inicialização básica de um contexto wgpu
async fn inicializar_gpu() -> (wgpu::Device, wgpu::Queue) {
    // Criar instância wgpu
    let instance = wgpu::Instance::new(&wgpu::InstanceDescriptor {
        backends: wgpu::Backends::all(),
        ..Default::default()
    });

    // Solicitar adaptador (GPU)
    let adapter = instance
        .request_adapter(&wgpu::RequestAdapterOptions {
            power_preference: wgpu::PowerPreference::HighPerformance,
            compatible_surface: None,
            force_fallback_adapter: false,
        })
        .await
        .expect("Falha ao encontrar GPU compatível");

    println!("GPU encontrada: {}", adapter.get_info().name);
    println!("Backend: {:?}", adapter.get_info().backend);

    // Criar device e queue
    let (device, queue) = adapter
        .request_device(
            &wgpu::DeviceDescriptor {
                label: Some("Meu Device"),
                required_features: wgpu::Features::empty(),
                required_limits: wgpu::Limits::default(),
                memory_hints: wgpu::MemoryHints::default(),
            },
            None,
        )
        .await
        .expect("Falha ao criar device GPU");

    (device, queue)
}