Refactorisation du code avec Tipragot

Cargo.lock

@@ -1024,6 +1024,7 @@ name = "border-wars"
 version = "0.1.0"
 dependencies = [
  "bevy",
+ "slotmap",
 ]
 
 [[package]]

Cargo.toml

@@ -5,3 +5,4 @@ edition = "2021"
 
 [dependencies]
 bevy = "0.10.1"
+slotmap = "1.0.6"

src/data_block.rs

@@ -1,154 +0,0 @@
-//! Stockage des données des blocks.
-
-#![deny(clippy::missing_docs_in_private_items)]
-#![deny(clippy::unwrap_in_result)]
-#![deny(clippy::unwrap_used)]
-#![deny(clippy::nursery)]
-#![deny(missing_docs)]
-#![deny(clippy::all)]
-#![deny(warnings)]
-
-use bevy::prelude::*;
-
-#[derive(Component, Debug, PartialEq, Clone, Copy, Eq, Hash)]
-/// Le type d'un block.
-pub enum BlockType {
-    /// Un avant post.
-    Outpost,
-
-    /// Un caserne.
-    Caserne,
-
-    /// un chateau.
-    Castle,
-
-    /// Une ferme.
-    Farm,
-
-    /// Une block d'herbe.
-    Grass,
-
-    /// Une forêt.
-    GrassForest,
-
-    /// une montagne.
-    GrassHill,
-
-    /// Une mine.
-    Mine,
-
-    /// Une tower.
-    Tower,
-
-    /// Un ameliorateur.
-    Upgradeur,
-
-    /// Un mur.
-    Wall,
-
-    /// Une ferme a animaux.
-    Sheep,
-}
-
-impl BlockType {
-    /// Permet de récupérer les images des blocks pour les afficher.
-    pub fn get_image(&self, asset_server: &AssetServer) -> Handle<Image> {
-        match self {
-            Self::Outpost => asset_server.load("map/Outpost.png"),
-            Self::Caserne => asset_server.load("map/Caserne.png"),
-            Self::Castle => asset_server.load("map/Castle.png"),
-            Self::Farm => asset_server.load("map/Farm.png"),
-            Self::Grass => asset_server.load("map/Grass.png"),
-            Self::GrassForest => asset_server.load("map/GrassForest.png"),
-            Self::GrassHill => asset_server.load("map/GrassHill.png"),
-            Self::Mine => asset_server.load("map/Mine.png"),
-            Self::Tower => asset_server.load("map/Tower.png"),
-            Self::Upgradeur => asset_server.load("map/Upgradeur.png"),
-            Self::Wall => asset_server.load("map/Wall.png"),
-            Self::Sheep => asset_server.load("map/Sheep.png"),
-        }
-    }
-
-    /// Permet de récupérer les textes des blocks.
-    pub const fn get_text(&self) -> &str {
-        match self {
-            Self::Caserne => "a barracks, it allows you to create troops",
-            Self::Castle => "a castle, it's a base",
-            Self::Grass => "a block of grass, it's useless",
-            Self::GrassForest => "a forest, if you break it you can collect resources",
-            Self::GrassHill => "a mountain, if you break it you can collect resources",
-            Self::Mine => "a mine, it allows you to collect resources",
-            Self::Farm => "a farm, it allows you to collect resources",
-            Self::Outpost => "an outpost, it allows you to teleport your troops",
-            Self::Tower => "a defense tower, it allows you to defend your troops",
-            Self::Upgradeur => "an upgrader",
-            Self::Wall => "a wall",
-            Self::Sheep => "a food reseve wich permit create an army",
-        }
-    }
-
-    /// Permet de récupérer les prix des blocks sous forme de texte.
-    pub fn get_text_price(&self) -> String {
-        format!(
-            "{:?}\n\n{} Wood,\n{} Stone",
-            self,
-            self.get_price()[1],
-            self.get_price()[0]
-        )
-    }
-
-    /// Permet de récupérer les prix des blocks.
-    pub fn get_price(&self) -> [u32; 2] {
-        match self {
-            Self::Outpost => [2300, 3000],
-            Self::Caserne => [600, 400],
-            Self::Castle => todo!(),
-            Self::Farm => [200, 300],
-            Self::Grass => todo!(),
-            Self::GrassForest => todo!(),
-            Self::GrassHill => todo!(),
-            Self::Mine => [300, 200],
-            Self::Tower => [1500, 1500],
-            Self::Upgradeur => [1000, 1000],
-            Self::Wall => [4000, 4000],
-            Self::Sheep => [400, 500],
-        }
-    }
-}
-
-#[derive(Component)]
-/// Position du block.
-pub struct BlockPosition {
-    /// La position en x.
-    pub x: u8,
-
-    /// La position en y.
-    pub y: u8,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Component)]
-/// Permet de donné un idée a un joueur ou un block pour lui donné une identité.
-pub struct Id {
-    /// L'Id du joueur ou du component
-    id: u32,
-}
-
-impl Id {
-    /// Permet de verifier l'Id du joueur avec une Id donné
-    pub const fn verifi_id(&self, id_a_verifie: &Self) -> bool {
-        self.id == id_a_verifie.id
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Component)]
-/// Permet de donné la posetion d'un block au joueur dans le jeu.
-pub enum BlockApartenance {
-    /// Represente le joueur 1.
-    Joueur1,
-
-    /// Represente le joueur 2.
-    Joueur2,
-
-    /// Represente les blocks neutres.
-    Neutre,
-}

src/lib.rs

@@ -1,4 +1,4 @@
-//! Contient les fonctions utilisées dans le jeu.
+//! Contient les structures de données permettant le bon fonctionnement du jeu.
 
 #![deny(clippy::missing_docs_in_private_items)]
 #![deny(clippy::unwrap_in_result)]
@@ -8,5 +8,19 @@
 #![deny(clippy::all)]
 #![deny(warnings)]
 
-// TODO
+pub mod map;
-pub mod data_block;
+
+/// Position d'un object sur la carte du jeu.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Position {
+    /// La position en x.
+    pub x: u8,
+
+    /// La position en y.
+    pub y: u8,
+}
+
+slotmap::new_key_type! {
+    /// Peut être utiliser pour identifier n'importe quel objet appartenant a un joueur (le joueur compris).
+    pub struct PlayerId;
+}

src/main.rs

@@ -1,4 +1,4 @@
-//! Permet de lancer le jeu du client.
+//! Permet de lancer le jeu.
 
 #![deny(clippy::missing_docs_in_private_items)]
 #![deny(clippy::unwrap_in_result)]

src/map.rs

@@ -0,0 +1,72 @@
+//! Contiens tous ce qui est relatif à la carte du jeu.
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+/// Une case sur la carte du jeu.
+pub enum Tile {
+    /// Un chateau.
+    ///
+    /// C'est la base du joueur qui doit defendre. Le but des autres joueurs est de la détruire pour gagner la partie.
+    Castle,
+
+    /// De l'herbe.
+    ///
+    /// Un case "vide" ou on peux construire et y deplacer des troupes
+    Grass,
+
+    /// Une forêt.
+    ///
+    /// Une case permettant de récupérer rapidement du bois.
+    /// Elle permet aussi de cacher des troupes a l'interieur.
+    Forest,
+
+    /// Une montagne.
+    ///
+    /// Une case permettant de récupérer rapidement de la p
+    Hill,
+
+    /// Une ferme.
+    ///
+    /// Permet de produire du bois.
+    /// Le nombre de bois généré peut être amélioré à l'aide d'un [Tile::Upgrader].
+    Lumberjack,
+
+    /// Une mine.
+    ///
+    /// Permet de produire de la pierre.
+    /// Le nombre de pierre généré peut être amélioré à l'aide d'un [Tile::Upgrader].
+    Mine,
+
+    /// Une ferme.
+    ///
+    /// Permet de produire de la nourriture.
+    /// Le nombre de nourriture généré peut être amélioré à l'aide d'un [Tile::Upgrader].
+    Farm,
+
+    /// Un avant poste.
+    ///
+    /// Permet de déplacer les troupes plus rapidement en les faisant aller d'un avant poste a l'autre comme un portail de téléportation.
+    Outpost,
+
+    /// Un caserne.
+    ///
+    /// Permet de faire apparaitre de nouvelles troupes.
+    /// Le cout des troupes peut être réduis a l'aide d'un [Tile::Upgrader].
+    Barrack,
+
+    /// Une tower.
+    ///
+    /// Permet de deffendre le territoire des assauts enemie.
+    /// Elle ajoute des dégats au troupes dans un certain rayon.
+    /// Ce rayon peut être amélioré a l'aide d'un [Tile::Upgrader].
+    Tower,
+
+    /// Un ameliorateur.
+    ///
+    /// Permet d'améliorer les performances des batiments adjacents.
+    Upgrader,
+
+    /// Un mur.
+    ///
+    /// Permet de bloquer le passage des troupes.
+    Wall,
+}