Créer et déplacer des entités
Affichez des éléments à l’écran.
Créer et déplacer des entités est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 4 leçons au total.
Commands : création différée
Vous ne pouvez pas modifier directement le World pendant l'exécution parallèle des systèmes. À la place, vous mettez en file les changements structurels au moyen de Commands.
La création, la suppression et l'ajout de composants sont enregistrés puis appliqués à la fin de l'étape de l'échéancier, ce qui garantit la sécurité des accès.
fn setup(mut commands: Commands) {
commands.spawn_empty();
}Créer une entité avec un bundle
Un bundle est un groupe de composants insérés ensemble. Le bundle le plus simple est simplement un tuple de composants.
Bevy traite chaque élément du tuple comme un composant à attacher : un seul appel de création peut donc fournir à une entité toutes ses données initiales.
fn setup(mut commands: Commands) {
commands.spawn((
Position { x: 0.0, y: 0.0 },
Velocity { x: 1.5, y: 0.0 },
Player,
));
}Une caméra pour voir
Rien ne s'affiche sans caméra. Pour les jeux en 2D, vous créez une Camera2d dans votre système de démarrage.
La caméra est elle-même une entité dotée de composants de caméra : c'est un autre exemple de l'uniformité de l'ECS. Tout ce qui se trouve dans la scène est une entité.
fn setup(mut commands: Commands) {
commands.spawn(Camera2d::default());
}Créer un sprite
Pour dessiner quelque chose, donnez à une entité un Sprite et un Transform. La transformation contient la position, la rotation et l'échelle dans l'espace du monde.
Un sprite coloré ne nécessite aucune image, ce qui est pratique pour prototyper les déplacements avant d'importer les éléments graphiques.
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 ou position personnalisée
Dans les jeux Bevy réels, vous déplacez généralement le Transform intégré plutôt qu'une Position personnalisée, car le rendu lit directement le Transform.
La translation est un Vec3. En 2D, vous modifiez x et y et conservez z pour l'ordre d'affichage.
#[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;
}
}Parcourir une Query de manière mutable
Pour modifier les données d'un composant, demandez &mut T et parcourez &mut query. Chaque élément fournit des références mutables.
Bevy garantit qu'aucun système ne détient simultanément un accès mutable en conflit, cette boucle est donc sûre même lorsque d'autres systèmes s'exécutent.
fn move_all(mut q: Query<&mut Transform, With<Player>>) {
for mut tf in &mut q {
tf.translation.x += 1.0;
}
}Créer de nombreuses entités
Les boucles vous permettent de remplir un niveau. Appelez spawn dans une boucle Rust for pour créer une grille d'obstacles ou un essaim d'ennemis.
Chaque itération met sa propre commande en file, puis toutes sont appliquées ensemble à la limite de l'étape.
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),
));
}
}Supprimer des entités
Supprimez entièrement une entité avec commands.entity(id).despawn(). Cela libère ses composants et recycle l'index de l'entité.
Vous supprimez généralement une entité depuis un système qui a obtenu son identifiant Entity par une requête, par exemple lorsqu'une balle quitte l'écran.
fn cleanup(mut commands: Commands, q: Query<(Entity, &Transform)>) {
for (e, tf) in &q {
if tf.translation.y > 600.0 {
commands.entity(e).despawn();
}
}
}Ajouter des composants ultérieurement
Vous pouvez attacher de nouveaux composants à une entité existante pendant l'exécution avec insert. C'est ainsi que vous donnez un marqueur Shield à un joueur bénéficiant d'une amélioration.
La suppression fonctionne de la même manière avec remove::<T>(). Ce sont dans les deux cas des changements structurels, qui passent donc par Commands.
commands.entity(player).insert(Shield { hits: 3 });
// later
commands.entity(player).remove::<Shield>();Z pour les couches
En 2D, la valeur z de la translation d'une transformation détermine l'ordre d'affichage. Une valeur z plus élevée s'affiche par-dessus.
Attribuez une faible valeur z à l'arrière-plan et une valeur plus élevée au joueur afin que les sprites ne disparaissent jamais derrière le décor.
// 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)));Relier les éléments
Créez les entités dans Startup et déplacez-les dans Update. Le système de démarrage crée une fois la caméra et les entités ; le système de mise à jour les fait avancer à chaque image.
Cette séparation évite de placer l'initialisation dans le chemin critique exécuté à chaque image.
App::new()
.add_plugins(DefaultPlugins)
.add_systems(Startup, setup)
.add_systems(Update, apply_velocity)
.run();Vérification rapide
Réfléchissez à la manière dont les changements structurels sont appliqués.
Récapitulatif : créer et déplacer
Vous créez des entités avec des bundles au moyen de Commands, vous les rendez avec Sprite et Transform, puis vous les déplacez en modifiant la transformation dans un système Update.
La suppression et l'insertion de composants sont également des commandes. Ensuite, nous ferons réagir les déplacements aux entrées du clavier et au temps réellement écoulé.
Questions Fréquemment Posées
La leçon « Créer et déplacer des entités » est-elle gratuite ?
Oui — le texte complet de « Créer et déplacer des entités » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Créer et déplacer des entités » ?
Affichez des éléments à l’écran. Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?
Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « Créer et déplacer des entités » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?
Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- La philosophie ECS
- Créer et déplacer des entités
- Gérer les entrées et le temps
- Collisions et état du jeu