Jeu Rust 24 heures: expérience de développement personnel

Dans cet article, je parlerai de mon expérience personnelle dans le développement d'un petit jeu à Rust. Il a fallu environ 24 heures pour créer une version de travail (j'ai principalement travaillé le soir ou le week-end). Le jeu est loin d'être terminé, mais je pense que l'expérience sera utile. Je vais vous dire ce que j'ai appris et certaines des observations faites lors de la construction du jeu à partir de zéro.

Skillbox recommande: Cours pratique de deux ans "Je suis un développeur Web PRO . "

Nous vous rappelons: pour tous les lecteurs de «Habr» - une remise de 10 000 roubles lors de l'inscription à un cours Skillbox en utilisant le code promo «Habr».

Pourquoi rouiller?

J'ai choisi ce langage parce que j'en ai beaucoup entendu parler et je vois qu'il devient de plus en plus populaire dans le domaine du développement de jeux. Avant d'écrire le jeu, j'avais peu d'expérience dans le développement d'applications simples dans Rust. C'était juste assez pour ressentir une certaine liberté lors de l'écriture du jeu.

Pourquoi exactement le jeu et quel genre de jeu?

Faire des jeux est amusant! Je voudrais pour plus de raisons, mais pour des projets «maison» je choisis des sujets qui ne sont pas trop étroitement liés à mon travail habituel. Quel genre de jeu? Je voulais faire quelque chose comme un simulateur de tennis, qui combine Cities Skylines, Zoo Tycoon, Prison Architect et tennis lui-même. En général, il s'est avéré un jeu sur une académie de tennis, où les gens viennent jouer.

Formation technique

Je voulais utiliser Rust, mais je ne savais pas exactement comment «à partir de zéro» je devrais commencer. Je ne voulais pas écrire de pixel shaders et utiliser le glisser-déposer, donc je cherchais les solutions les plus flexibles.

J'ai trouvé des ressources utiles que je partage avec vous:

• Sommes-nous encore en jeu - une liste des éléments Rust nécessaires au développement du jeu;
• Rust su dev subreddit;
• Pixel art gratuit.

J'ai exploré plusieurs moteurs de jeux Rust, en choisissant finalement Piston et ggez. Je les ai rencontrés en travaillant sur un projet précédent. Au final, j'ai choisi ggez, car il me semblait plus adapté à l'implémentation d'un petit jeu 2D. La structure modulaire de Piston est trop complexe pour un développeur débutant (ou quelqu'un qui travaille avec Rust pour la première fois).

Structure du jeu

J'ai passé un peu de temps à réfléchir à l'architecture du projet. La première étape consiste à aménager le «terrain», les gens et les courts de tennis. Les gens doivent se déplacer dans les tribunaux et attendre. Les joueurs doivent avoir des compétences qui s'améliorent avec le temps. De plus, il devrait y avoir un éditeur qui vous permet d'ajouter de nouvelles personnes et de nouveaux tribunaux, mais ce n'est plus gratuit.

En réfléchissant à tout, je me mis au travail.

Création de jeux

Début: cercles et abstractions

J'ai pris un exemple de ggez et j'ai un cercle sur l'écran. Incroyable Maintenant quelques abstractions. Il m’a semblé agréable d’ignorer l’idée d’un objet de jeu. Chaque objet doit être rendu et mis à jour comme indiqué ici:

// the game object trait trait GameObject { fn update(&mut self, _ctx: &mut Context) -> GameResult<()>; fn draw(&mut self, ctx: &mut Context) -> GameResult<()>; } // a specific game object - Circle struct Circle { position: Point2, } impl Circle { fn new(position: Point2) -> Circle { Circle { position } } } impl GameObject for Circle { fn update(&mut self, _ctx: &mut Context) -> GameResult<()> { Ok(()) } fn draw(&mut self, ctx: &mut Context) -> GameResult<()> { let circle = graphics::Mesh::new_circle(ctx, graphics::DrawMode::Fill, self.position, 100.0, 2.0)?; graphics::draw(ctx, &circle, na::Point2::new(0.0, 0.0), 0.0)?; Ok(()) } } 

Ce morceau de code m'a permis d'obtenir une excellente liste d'objets que je peux mettre à jour et rendre dans une boucle tout aussi excellente.

 mpl event::EventHandler for MainState { fn update(&mut self, context: &mut Context) -> GameResult<()> { // Update all objects for object in self.objects.iter_mut() { object.update(context)?; } Ok(()) } fn draw(&mut self, context: &mut Context) -> GameResult<()> { graphics::clear(context); // Draw all objects for object in self.objects.iter_mut() { object.draw(context)?; } graphics::present(context); Ok(()) } } 

main.rs est nécessaire car il contient toutes les lignes de code. J'ai passé un peu de temps à séparer les fichiers et à optimiser la structure des répertoires. Voici comment tout a commencé à s'occuper de cela:

ressources -> c'est là que se trouvent tous les actifs (images)
src
- entités
- game_object.rs
- circle.rs
- main.rs -> boucle principale

Personnes, sols et images

L'étape suivante consiste à créer un objet de jeu Personne et à charger des images. Tout devrait être basé sur des carreaux de 32 * 32.



Courts de tennis

Après avoir étudié l'apparence des courts de tennis, j'ai décidé de les fabriquer avec des tuiles 4 * 2. Initialement, il était possible de faire une image de cette taille ou de faire ensemble 8 tuiles distinctes. Mais j'ai réalisé que seulement deux tuiles uniques sont nécessaires, et c'est pourquoi.

Au total, nous avons deux de ces tuiles: 1 et 2.

Chaque section du terrain se compose de la tuile 1 ou de la tuile 2. Elles peuvent être disposées comme d'habitude ou être retournées de 180 degrés.



Le principal mode de construction (assemblage)

Après avoir réussi à obtenir le rendu des sites, des personnes et des cartes, j'ai réalisé qu'un mode de construction de base était également nécessaire. Il a été implémenté comme ceci: lorsque le bouton est enfoncé, l'objet est sélectionné et le clic le place au bon endroit. Ainsi, le bouton 1 vous permet de sélectionner un terrain, et le bouton 2 vous permet de sélectionner un joueur.

Mais vous devez toujours vous souvenir de ce que nous voulons dire 1 et 2, j'ai donc ajouté un filaire pour qu'il soit clair quel objet est sélectionné. Voici à quoi ça ressemble.


Questions d'architecture et de refactoring

Maintenant, j'ai plusieurs objets de jeu: les gens, les courts et les sols. Mais pour que les wireframes fonctionnent, vous devez indiquer à chaque entité de l'objet si les objets eux-mêmes sont en mode démonstration ou si un cadre est simplement dessiné. Ce n'est pas très pratique.

Il m'a semblé que je devais repenser l'architecture afin de révéler certaines limites:

• la présence d'une entité qui s'affiche et se met à jour est un problème, car cette entité ne pourra pas «savoir» ce qu'elle doit rendre - une image et un filaire;
• absence d'outil pour l'échange de propriétés et de comportements entre des entités individuelles (par exemple, la propriété is_build_mode ou le comportement de rendu). L'héritage peut être utilisé, bien qu'il n'existe aucun moyen normal de l'implémenter dans Rust. Ce dont j'avais vraiment besoin, c'était de la mise en page;
• un outil pour l'interaction des entités entre elles était nécessaire pour assigner des personnes aux tribunaux;
• les entités elles-mêmes étaient un mélange de données et de logique, qui est rapidement devenu incontrôlable.

J'ai fait d'autres recherches et découvert l'architecture ECS - Entity Component System , qui est couramment utilisée dans les jeux. Voici les avantages d'ECS:

• les données sont séparées de la logique;
• mise en page au lieu de l'héritage;
• architecture orientée données.

ECS se caractérise par trois concepts de base:

• entités - le type d'objet auquel l'identifiant fait référence (il peut s'agir d'un joueur, d'une balle ou de quelque chose d'autre);
• composants - les entités en sont constituées. Un exemple est un composant de rendu, une disposition et autres. C'est un entrepôt de données;
• systèmes - ils utilisent à la fois des objets et des composants, et ils contiennent un comportement et une logique basés sur ces données. Un exemple est un système de rendu qui itère sur toutes les entités avec des composants pour le rendu et est engagé dans le rendu.

Après avoir étudié, il est devenu clair qu'ECS résout de tels problèmes:

• utiliser la disposition au lieu de l'héritage pour l'organisation système des entités;
• se débarrasser d'un hachage de code en raison des systèmes de contrôle;
• en utilisant des méthodes comme is_build_mode pour stocker la logique du filaire au même endroit - dans le système de rendu.

Voici ce qui s'est passé après la mise en œuvre d'ECS.

ressources -> c'est là que se trouvent tous les actifs (images)
src
- composants
- position.rs
- person.rs
- tennis_court.rs
- floor.rs
- wireframe.rs
- mouse_tracked.rs
- ressources
- mouse.rs
- systèmes
- rendu.rs
- constants.rs
- utils.rs
- world_factory.rs -> fonctions d'usine du monde
- main.rs -> boucle principale

Affecter des personnes aux tribunaux

ECS a rendu la vie plus facile. Maintenant, j'avais un moyen systématique d'ajouter des données aux entités et d'ajouter une logique basée sur ces données. Et cela, à son tour, a permis d'organiser la répartition des personnes par voie judiciaire.

Ce que j'ai fait:

• ajouté des données sur les tribunaux assignés à la personne;
• ajouté des données sur les personnes distribuées à TennisCourt;
• ajouté CourtChoosingSystem, qui vous permet d'analyser des personnes et des sites, de trouver des terrains disponibles et de leur distribuer des joueurs;
• a ajouté le système PersonMovementSystem, qui recherche les personnes affectées aux tribunaux, et si elles ne sont pas là, il envoie des personnes si nécessaire.

Pour résumer

J'ai vraiment aimé travailler sur ce jeu simple. De plus, je suis heureux d'avoir utilisé Rust pour l'écrire, car:

• La rouille vous donne ce dont vous avez besoin;
• il a une excellente documentation, Rust est très élégant;
• la constance est cool;
• Vous n'avez pas à recourir au clonage, à la copie ou à d'autres actions similaires, ce que j'ai souvent fait en C ++;
• Les options sont très pratiques pour le travail, elles gèrent également parfaitement les erreurs;
• si le projet pouvait être compilé, alors à 99% il fonctionne, et exactement comme il se doit. Il me semble que les messages d'erreur du compilateur sont les meilleurs que j'ai vus.

Le développement de jeux sur Rust ne fait que commencer. Mais il existe déjà une communauté stable et assez importante pour ouvrir Rust à tout le monde. Par conséquent, je regarde l'avenir de la langue avec optimisme, dans l'attente des résultats de notre travail commun.

Skillbox recommande:

• Cours en ligne "Profession frontend-developer" .
• Cours pratique "Mobile Developer PRO" .
• Cours pratique annuel "Développeur PHP de 0 à PRO" .