Criando e movendo entidades
Coloque elementos na tela.
Criando e movendo entidades é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.
Commands: criação adiada
Você não pode alterar o World diretamente enquanto os sistemas são executados em paralelo. Em vez disso, enfileire alterações estruturais por meio de Commands.
A criação, a remoção e a adição de componentes são registradas e aplicadas ao final da etapa da programação, mantendo o acesso seguro.
fn setup(mut commands: Commands) {
commands.spawn_empty();
}Criando com um Bundle
Um bundle é um grupo de componentes inseridos em conjunto. O bundle mais simples é apenas uma tupla de componentes.
O Bevy trata cada elemento da tupla como um componente a ser anexado, então uma única chamada de criação pode fornecer a uma entidade todos os seus dados iniciais.
fn setup(mut commands: Commands) {
commands.spawn((
Position { x: 0.0, y: 0.0 },
Velocity { x: 1.5, y: 0.0 },
Player,
));
}Uma câmera para enxergar
Nada é renderizado sem uma câmera. Em jogos 2D, você cria uma Camera2d no seu sistema de inicialização.
A câmera é uma entidade com componentes de câmera — outro exemplo da uniformidade do ECS. Tudo na cena é uma entidade.
fn setup(mut commands: Commands) {
commands.spawn(Camera2d::default());
}Criando um Sprite
Para desenhar algo, forneça a uma entidade um Sprite e um Transform. O transform contém a posição, a rotação e a escala no espaço do mundo.
Um sprite colorido não precisa de um recurso de imagem, o que é útil para prototipar o movimento antes de importar a arte.
commands.spawn((
Sprite::from_color(Color::srgb(0.2, 0.7, 1.0), Vec2::new(40.0, 40.0)),
Transform::from_xyz(0.0, 0.0, 0.0),
Velocity { x: 80.0, y: 0.0 },
));Transform vs. posição personalizada
Em jogos reais com Bevy, normalmente você move o Transform integrado em vez de um Position personalizado, porque a renderização lê o Transform diretamente.
A translação é um Vec3. Em 2D, você altera x e y e mantém z para ordenar o desenho.
#[derive(Component)]
struct Velocity { x: f32, y: f32 }
fn apply_velocity(mut q: Query<(&mut Transform, &Velocity)>) {
for (mut tf, vel) in &mut q {
tf.translation.x += vel.x;
tf.translation.y += vel.y;
}
}Iterando uma Query de forma mutável
Para alterar dados de componentes, solicite &mut T e itere sobre &mut query. Cada item fornece referências mutáveis.
O Bevy garante que nenhum sistema mantenha acesso mutável conflitante ao mesmo tempo, portanto esse laço é seguro mesmo enquanto outros sistemas são executados.
fn move_all(mut q: Query<&mut Transform, With<Player>>) {
for mut tf in &mut q {
tf.translation.x += 1.0;
}
}Criando muitas entidades
Laços permitem preencher um nível. Chame spawn dentro de um laço for do Rust para criar uma grade de obstáculos ou um enxame de inimigos.
Cada iteração enfileira seu próprio comando, e todos eles são aplicados juntos no limite da etapa.
fn spawn_row(mut commands: Commands) {
for i in 0..5 {
commands.spawn((
Sprite::from_color(Color::WHITE, Vec2::splat(20.0)),
Transform::from_xyz(i as f32 * 30.0, 0.0, 0.0),
));
}
}Removendo entidades
Remova uma entidade completamente com commands.entity(id).despawn(). Isso libera seus componentes e recicla o índice da entidade.
Normalmente, você remove a entidade em um sistema que consultou o identificador Entity dela, como no caso de um projétil que saiu da tela.
fn cleanup(mut commands: Commands, q: Query<(Entity, &Transform)>) {
for (e, tf) in &q {
if tf.translation.y > 600.0 {
commands.entity(e).despawn();
}
}
}Adicionando componentes depois
Você pode anexar novos componentes a uma entidade existente durante a execução usando insert. É assim que você fornece a um jogador fortalecido uma marcação Shield.
A remoção funciona da mesma forma com remove::<T>(). Ambas são alterações estruturais, portanto passam por Commands.
commands.entity(player).insert(Shield { hits: 3 });
// later
commands.entity(player).remove::<Shield>();Z para camadas
Em 2D, o valor de z da translação de um transform determina a ordem de desenho. Um z maior é renderizado por cima.
Dê ao plano de fundo um z baixo e ao jogador um valor mais alto, para que os sprites nunca desapareçam atrás do cenário.
// background behind, player in front
commands.spawn((bg_sprite, Transform::from_xyz(0.0, 0.0, 0.0)));
commands.spawn((player_sprite, Transform::from_xyz(0.0, 0.0, 10.0)));Conectando tudo
Crie em Startup e mova em Update. O sistema de inicialização cria a câmera e as entidades uma vez; o sistema de atualização avança cada uma delas a cada quadro.
Essa separação mantém a inicialização fora do caminho crítico executado a cada quadro.
App::new()
.add_plugins(DefaultPlugins)
.add_systems(Startup, setup)
.add_systems(Update, apply_velocity)
.run();Verificação rápida
Pense em como as alterações estruturais são aplicadas.
Recapitulação: criando e movendo
Você cria entidades com bundles por meio de Commands, renderiza-as com Sprite e Transform e move-as alterando o transform em um sistema Update.
A remoção e a inserção de componentes também são comandos. Em seguida, faremos o movimento reagir à entrada do teclado e ao tempo real decorrido.
Perguntas Frequentes
A aula “Criando e movendo entidades” é grátis?
Sim — o texto completo de “Criando e movendo entidades” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.
O que vou aprender em “Criando e movendo entidades”?
Coloque elementos na tela. Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Learn Rust Coding?
Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.
Quanto tempo leva a aula “Criando e movendo entidades”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Learn Rust Coding?
Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- A mentalidade ECS
- Criando e movendo entidades
- Lidando com entrada e tempo
- Colisões e estado do jogo