Bevy Engine

Entidades, componentes, sistemas e schedules - o motor de jogos Bevy ECS em Rust.

Receita

use bevy::prelude::*;
 
#[derive(Component)]
struct Velocity(Vec2);
 
fn move_system(mut query: Query<(&mut Transform, &Velocity)>, time: Res<Time>) {
    for (mut transform, velocity) in &mut query {
        transform.translation += velocity.0.extend(0.0) * time.delta_secs();
    }
}

Quando usar isto:

• Jogos 2D/3D que desejam um motor ECS orientado a dados em Rust
• Prototipagem com hot reload e fortes padrões ECS
• Ferramentas que simulam muitos agentes com sistemas paralelos
• Aprendendo ECS sem construir a infraestrutura do motor

Exemplo de Trabalho

use bevy::prelude::*;
 
#[derive(Component)]
struct Player;
 
#[derive(Component)]
struct Velocity(Vec2);
 
fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_systems(Startup, setup)
        .add_systems(Update, (player_input, move_system))
        .run();
}
 
fn setup(mut commands: Commands) {
    commands.spawn((Player, Velocity(Vec2::ZERO), Transform::default()));
    commands.spawn(Camera2d);
}
 
fn player_input(
    keys: Res<ButtonInput<KeyCode>>,
    mut q: Query<&mut Velocity, With<Player>>,
) {
    let mut v = Vec2::ZERO;
    if keys.pressed(KeyCode::KeyW) { v.y += 1.0; }
    if keys.pressed(KeyCode::KeyS) { v.y -= 1.0; }
    if keys.pressed(KeyCode::KeyA) { v.x -= 1.0; }
    if keys.pressed(KeyCode::KeyD) { v.x += 1.0; }
    for mut vel in &mut q {
        vel.0 = v.normalize_or_zero() * 300.0;
    }
}
 
fn move_system(mut query: Query<(&mut Transform, &Velocity)>, time: Res<Time>) {
    for (mut t, v) in &mut query {
        t.translation += v.0.extend(0.0) * time.delta_secs();
    }
}

O que isto demonstra:

• O sistema de input escreve Velocity; o sistema de movimento lê-o
• O filtro With<Player> visa a entidade do jogador
• Translação escalada pelo tempo delta em Update

Mergulho Profundo

Como Funciona

• World armazena entidades, componentes, recursos.
• Schedule ordena sistemas; o executor executa queries não conflitantes em paralelo.
• Commands são alterações estruturais adiadas (spawn/despawn/insert).
• Plugins registram sistemas, assets e nós de renderização modularmente.

Blocos de Construção do ECS

Armadilhas

• Conflitos de Query - dois sistemas acessando mutavelmente o mesmo componente sem ordenação falham o scheduler. Correção: encadeie com .before/.after ou mescle sistemas.
• Spawn após despawn no mesmo frame - confusão de reutilização de ID de entidade. Correção: use semântica de buffer de comandos; evite manter a Entidade entre frames sem validação.
• Sistemas monolíticos enormes - mata o paralelismo. Correção: divida por subconjuntos de componentes.
• Assumir que o asset foi carregado instantaneamente - placeholders cor-de-rosa. Correção: verifique LoadState ou use SceneBundle quando pronto.
• Derivação de versão do Bevy - incompatibilidades de API do tutorial. Correção: combine o livro com a versão exata do crate.

Alternativas

FAQs

Relacionados

• Básicos de Desenvolvimento de Jogos - orientação
• Assets e Cenas - carregamento
• Loops de Jogo e Timing - schedules
• Performance para Jogos - otimização

Versões da Stack: Esta página foi escrita para Rust 1.97.0 (edição 2024), Tokio 1.x, Axum 0.8, serde 1.0, sqlx 0.8, clap 4, e Polars 0.46+.