La philosophie ECS
Entités, composants et systèmes.
La philosophie ECS est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 1 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.
Ce que résout ECS
Bevy repose sur le modèle Entity Component System (ECS). Au lieu de hiérarchies d’héritage profondes, vous composez le comportement à partir de petits éléments de données indépendants.
Cette conception orientée données conserve une organisation de la mémoire favorable au cache et permet au moteur de paralléliser le travail sur les cœurs du CPU presque gratuitement.
Les entités ne sont que des identifiants
Une entité n’est rien d’autre qu’un identifiant léger — un index générationnel. Elle ne possède aucune donnée et n’a aucun comportement propre.
Imaginez-la comme une clé dans une ligne de base de données. Les composants associés à cette clé donnent un sens à l’entité, comme « Joueur » ou « Projectile ».
// An Entity is a tiny handle
struct Entity {
index: u32,
generation: u32,
}Les composants sont de simples données
Les composants sont de simples structures Rust qui dérivent Component. Ils contiennent un état, mais aucune logique.
Gardez-les petits et ciblés. Une position, une vitesse et une valeur de santé sont trois composants distincts plutôt qu’une seule structure monolithique.
use bevy::prelude::*;
#[derive(Component)]
struct Position { x: f32, y: f32 }
#[derive(Component)]
struct Velocity { x: f32, y: f32 }Les systèmes contiennent la logique
Les systèmes sont des fonctions ordinaires qui opèrent sur les composants. C’est là que réside toute la logique de votre jeu.
Bevy examine les paramètres de chaque système pour déterminer les données auxquelles il accède, puis planifie en parallèle l’exécution des systèmes qui n’entrent pas en conflit.
fn move_system(mut query: Query<(&mut Position, &Velocity)>) {
for (mut pos, vel) in &mut query {
pos.x += vel.x;
pos.y += vel.y;
}
}Requêtes : demander des données
Une Query demande de manière déclarative les entités possédant un ensemble précis de composants. Bevy ne renvoie que les entités correspondantes.
Vous pouvez demander un accès partagé avec &T ou un accès exclusif avec &mut T. Ces informations d'emprunt alimentent l'ordonnanceur parallèle.
// Entities with BOTH Position and Velocity
fn report(query: Query<(&Position, &Velocity)>) {
for (pos, vel) in &query {
info!("at {},{} moving {},{}", pos.x, pos.y, vel.x, vel.y);
}
}Filtrer les requêtes
Le deuxième paramètre de type d'une Query est un filtre. Utilisez With et Without pour affiner les résultats sans emprunter les données de ce composant.
C'est idéal pour les composants marqueurs : des structures vides qui indiquent le rôle d'une entité.
#[derive(Component)]
struct Player;
fn player_only(query: Query<&Position, With<Player>>) {
for pos in &query {
info!("player at {},{}", pos.x, pos.y);
}
}Ressources : état global
Certaines données sont uniques à l'ensemble du jeu : un score, le temps écoulé ou les paramètres du jeu. Elles sont stockées comme des ressources plutôt que comme des composants.
Accédez-y dans les systèmes avec Res<T> pour la lecture ou ResMut<T> pour l'écriture.
#[derive(Resource)]
struct Score(u32);
fn show_score(score: Res<Score>) {
info!("Score: {}", score.0);
}Le générateur d'application
Tout est relié dans l'App. Vous ajoutez des extensions, insérez des ressources et enregistrez des systèmes dans un échéancier.
DefaultPlugins fournit la gestion des fenêtres, le rendu, les entrées et le temps, afin que vous puissiez vous concentrer sur le gameplay.
fn main() {
App::new()
.add_plugins(DefaultPlugins)
.insert_resource(Score(0))
.add_systems(Update, show_score)
.run();
}Échéanciers : démarrage ou mise à jour
Les systèmes s'exécutent dans des échéanciers. Startup s'exécute une seule fois au lancement de l'application : c'est idéal pour créer le monde.
Update s'exécute à chaque image et accueille les déplacements, les entrées et la logique. Bevy propose également FixedUpdate pour des étapes de physique déterministes.
App::new()
.add_plugins(DefaultPlugins)
.add_systems(Startup, setup)
.add_systems(Update, move_system)
.run();Pourquoi la composition l'emporte
Vous voulez un ennemi volant qui peut être empoisonné ? Il suffit de lui ajouter les composants Flying et Poisoned. Pas besoin d'une nouvelle classe ni d'une chaîne d'héritage.
Le comportement découle des systèmes qui correspondent aux différentes combinaisons de composants. Les fonctionnalités peuvent ainsi être ajoutées progressivement et les remaniements restent peu coûteux.
// Same systems, new combinations
commands.spawn((Position{x:0.0,y:0.0}, Velocity{x:1.0,y:0.0}, Flying, Poisoned));Le parallélisme sans effort
Comme chaque système déclare l'accès à ses données, l'ordonnanceur de Bevy sait quels systèmes sont en conflit. Les systèmes sans conflit s'exécutent automatiquement sur des fils d'exécution différents.
Vous écrivez du code qui semble monothread, et le moteur extrait le parallélisme de vos déclarations d'emprunt. Aucun verrou ni gestion manuelle des fils d'exécution.
Vérification rapide
Vérifiez votre compréhension des rôles de l'ECS.
Récapitulatif : l'état d'esprit ECS
Les entités sont des identifiants, les composants sont des données, les systèmes sont la logique et les ressources représentent l'état global. L'App relie le tout au moyen d'échéanciers.
En composant de petits composants et en laissant les systèmes les mettre en correspondance, vous obtenez des jeux flexibles, parallèles et adaptés aux caches. Ensuite, nous créerons des entités et les ferons se déplacer.
Questions Fréquemment Posées
La leçon « La philosophie ECS » est-elle gratuite ?
Oui — le texte complet de « La philosophie ECS » 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 « La philosophie ECS » ?
Entités, composants et systèmes. 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 1 sur 4.
Combien de temps prend la leçon « La philosophie ECS » ?
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