From e8f9c491784bd3420c628689695a41f2c1b3ad95 Mon Sep 17 00:00:00 2001 From: _Corentin_ Date: Tue, 23 May 2023 10:33:03 +0200 Subject: [PATCH 1/9] creation de la fonction --- Cargo.lock | 37 ++++++++++++++++++++++++++++++++++++ Cargo.toml | 1 + src/lib.rs | 4 +++- src/map.rs | 56 +++++++++++++++++++++++++++++++++++++++++++++++++++++- 4 files changed, 96 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index a3b016e..ae70fac 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1024,6 +1024,7 @@ name = "border-wars" version = "0.1.0" dependencies = [ "bevy", + "rand", "slotmap", ] @@ -2428,6 +2429,12 @@ dependencies = [ "unicode-xid", ] +[[package]] +name = "ppv-lite86" +version = "0.2.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" + [[package]] name = "proc-macro-crate" version = "1.3.1" @@ -2468,6 +2475,36 @@ version = "0.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "17fd96390ed3feda12e1dfe2645ed587e0bea749e319333f104a33ff62f77a0b" +[[package]] +name = "rand" +version = "0.8.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" +dependencies = [ + "libc", + "rand_chacha", + "rand_core", +] + +[[package]] +name = "rand_chacha" +version = "0.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" +dependencies = [ + "ppv-lite86", + "rand_core", +] + +[[package]] +name = "rand_core" +version = "0.6.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" +dependencies = [ + "getrandom", +] + [[package]] name = "range-alloc" version = "0.1.3" diff --git a/Cargo.toml b/Cargo.toml index f6994e7..921aaa7 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -5,4 +5,5 @@ edition = "2021" [dependencies] bevy = "0.10.1" +rand = "0.8.5" slotmap = "1.0.6" diff --git a/src/lib.rs b/src/lib.rs index dfde36f..461cfb3 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -8,10 +8,11 @@ #![deny(clippy::all)] #![deny(warnings)] +use bevy::prelude::Component; pub mod map; /// Position d'un object sur la carte du jeu. -#[derive(Debug, Clone, Copy, PartialEq, Eq)] +#[derive(Debug, Clone, Copy, PartialEq, Eq, Component)] pub struct Position { /// La position en x. pub x: u8, @@ -22,5 +23,6 @@ pub struct Position { slotmap::new_key_type! { /// Peut être utiliser pour identifier n'importe quel objet appartenant a un joueur (le joueur compris). + #[derive(Component)] pub struct PlayerId; } diff --git a/src/map.rs b/src/map.rs index 7073893..bb4c5b7 100644 --- a/src/map.rs +++ b/src/map.rs @@ -1,6 +1,10 @@ //! Contiens tous ce qui est relatif à la carte du jeu. -#[derive(Debug, Clone, Copy, PartialEq, Eq)] +use bevy::prelude::{Commands, Component}; + +use crate::{PlayerId, Position}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Component)] /// Une case sur la carte du jeu. pub enum Tile { /// Un chateau. @@ -70,3 +74,53 @@ pub enum Tile { /// Permet de bloquer le passage des troupes. Wall, } + +/// Permet de crée des entité representant les cases d'une map, sur une longueur et langueur donné +pub fn init_map( + longueur: u8, + largeur: u8, + mut commands: Commands, + id_joueur1: PlayerId, + id_joueur2: PlayerId, +) { + for y in 0..longueur { + for x in 0..largeur { + let mut curent_type = Tile::Grass; + let mut curent_id = None; + if x == 1 && y == 4 { + curent_type = Tile::Castle; + curent_id = Some(id_joueur1); + } else if x == longueur && y == 4 { + curent_type = Tile::Castle; + curent_id = Some(id_joueur2); + } else { + match (x, y) { + (0, 5) | (1, 5) | (2, 4) | (1, 3) | (0, 3) => { + curent_type = Tile::Grass; + curent_id = Some(id_joueur1) + } + + (9, 5) | (8, 5) | (8, 4) | (9, 3) | (8, 3) => { + curent_type = Tile::Grass; + curent_id = Some(id_joueur2) + } + + _ => { + if rand::random() { + if rand::random() { + curent_type = Tile::Forest + } else { + curent_type = Tile::Hill + } + } + } + } + } + if let Some(id) = curent_id { + commands.spawn((curent_type, id, Position { x, y })); + } else { + commands.spawn((curent_type, Position { x, y })); + } + } + } +} From b84cf4b47124a52ab032cdff3009dce0205639ed Mon Sep 17 00:00:00 2001 From: _Corentin_ Date: Tue, 23 May 2023 12:22:59 +0200 Subject: [PATCH 2/9] decalage de la map --- src/map.rs | 60 +++++++++++++++++++++++++++++------------------------- 1 file changed, 32 insertions(+), 28 deletions(-) diff --git a/src/map.rs b/src/map.rs index bb4c5b7..1f28804 100644 --- a/src/map.rs +++ b/src/map.rs @@ -75,7 +75,8 @@ pub enum Tile { Wall, } -/// Permet de crée des entité representant les cases d'une map, sur une longueur et langueur donné +/// Permet de crée des entité representant les cases d'une map, sur une longueur et langueur donné. +/// Donner une longueur impaire. pub fn init_map( longueur: u8, largeur: u8, @@ -85,41 +86,44 @@ pub fn init_map( ) { for y in 0..longueur { for x in 0..largeur { - let mut curent_type = Tile::Grass; - let mut curent_id = None; - if x == 1 && y == 4 { - curent_type = Tile::Castle; - curent_id = Some(id_joueur1); - } else if x == longueur && y == 4 { - curent_type = Tile::Castle; - curent_id = Some(id_joueur2); + if y % 2 != 0 && x == longueur { } else { - match (x, y) { - (0, 5) | (1, 5) | (2, 4) | (1, 3) | (0, 3) => { - curent_type = Tile::Grass; - curent_id = Some(id_joueur1) - } + let mut curent_type = Tile::Grass; + let mut curent_id = None; + if x == 1 && y == 4 { + curent_type = Tile::Castle; + curent_id = Some(id_joueur1); + } else if x == longueur && y == 4 { + curent_type = Tile::Castle; + curent_id = Some(id_joueur2); + } else { + match (x, y) { + (0, 5) | (1, 5) | (2, 4) | (1, 3) | (0, 3) => { + curent_type = Tile::Grass; + curent_id = Some(id_joueur1) + } - (9, 5) | (8, 5) | (8, 4) | (9, 3) | (8, 3) => { - curent_type = Tile::Grass; - curent_id = Some(id_joueur2) - } + (9, 5) | (8, 5) | (8, 4) | (9, 3) | (8, 3) => { + curent_type = Tile::Grass; + curent_id = Some(id_joueur2) + } - _ => { - if rand::random() { + _ => { if rand::random() { - curent_type = Tile::Forest - } else { - curent_type = Tile::Hill + if rand::random() { + curent_type = Tile::Forest + } else { + curent_type = Tile::Hill + } } } } } - } - if let Some(id) = curent_id { - commands.spawn((curent_type, id, Position { x, y })); - } else { - commands.spawn((curent_type, Position { x, y })); + if let Some(id) = curent_id { + commands.spawn((curent_type, id, Position { x, y })); + } else { + commands.spawn((curent_type, Position { x, y })); + } } } } From 6cee20df8d1286887d4f90fcd5bb1b8c7a8eb674 Mon Sep 17 00:00:00 2001 From: Tipragot Date: Wed, 24 May 2023 07:08:17 +0200 Subject: [PATCH 3/9] Fix use format --- src/lib.rs | 1 + src/map.rs | 3 +-- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 461cfb3..e30e5d4 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -9,6 +9,7 @@ #![deny(warnings)] use bevy::prelude::Component; + pub mod map; /// Position d'un object sur la carte du jeu. diff --git a/src/map.rs b/src/map.rs index 1f28804..b83a410 100644 --- a/src/map.rs +++ b/src/map.rs @@ -1,8 +1,7 @@ //! Contiens tous ce qui est relatif à la carte du jeu. -use bevy::prelude::{Commands, Component}; - use crate::{PlayerId, Position}; +use bevy::prelude::{Commands, Component}; #[derive(Debug, Clone, Copy, PartialEq, Eq, Component)] /// Une case sur la carte du jeu. From 54aab50c3b78623c25c446325622cb1053809e30 Mon Sep 17 00:00:00 2001 From: CoCo_Sol Date: Thu, 25 May 2023 18:55:52 +0200 Subject: [PATCH 4/9] map generique --- src/map.rs | 50 +++++++++----------------------------------------- 1 file changed, 9 insertions(+), 41 deletions(-) diff --git a/src/map.rs b/src/map.rs index b83a410..92c0671 100644 --- a/src/map.rs +++ b/src/map.rs @@ -1,6 +1,6 @@ //! Contiens tous ce qui est relatif à la carte du jeu. -use crate::{PlayerId, Position}; +use crate::Position; use bevy::prelude::{Commands, Component}; #[derive(Debug, Clone, Copy, PartialEq, Eq, Component)] @@ -76,53 +76,21 @@ pub enum Tile { /// Permet de crée des entité representant les cases d'une map, sur une longueur et langueur donné. /// Donner une longueur impaire. -pub fn init_map( - longueur: u8, - largeur: u8, - mut commands: Commands, - id_joueur1: PlayerId, - id_joueur2: PlayerId, -) { +pub fn init_map(longueur: u8, largeur: u8, mut commands: Commands) { for y in 0..longueur { for x in 0..largeur { if y % 2 != 0 && x == longueur { } else { let mut curent_type = Tile::Grass; - let mut curent_id = None; - if x == 1 && y == 4 { - curent_type = Tile::Castle; - curent_id = Some(id_joueur1); - } else if x == longueur && y == 4 { - curent_type = Tile::Castle; - curent_id = Some(id_joueur2); - } else { - match (x, y) { - (0, 5) | (1, 5) | (2, 4) | (1, 3) | (0, 3) => { - curent_type = Tile::Grass; - curent_id = Some(id_joueur1) - } - - (9, 5) | (8, 5) | (8, 4) | (9, 3) | (8, 3) => { - curent_type = Tile::Grass; - curent_id = Some(id_joueur2) - } - - _ => { - if rand::random() { - if rand::random() { - curent_type = Tile::Forest - } else { - curent_type = Tile::Hill - } - } - } + if rand::random() { + if rand::random() { + curent_type = Tile::Forest + } else { + curent_type = Tile::Hill } } - if let Some(id) = curent_id { - commands.spawn((curent_type, id, Position { x, y })); - } else { - commands.spawn((curent_type, Position { x, y })); - } + + commands.spawn((curent_type, Position { x, y })); } } } From fd19c77a6ae474d8a4212a7055a7032016fe01ca Mon Sep 17 00:00:00 2001 From: CoCo_Sol Date: Thu, 25 May 2023 21:46:28 +0200 Subject: [PATCH 5/9] fix fmt --- src/map.rs | 33 +++++++++++++++++++-------------- 1 file changed, 19 insertions(+), 14 deletions(-) diff --git a/src/map.rs b/src/map.rs index 92c0671..0a19ffe 100644 --- a/src/map.rs +++ b/src/map.rs @@ -77,21 +77,26 @@ pub enum Tile { /// Permet de crée des entité representant les cases d'une map, sur une longueur et langueur donné. /// Donner une longueur impaire. pub fn init_map(longueur: u8, largeur: u8, mut commands: Commands) { - for y in 0..longueur { - for x in 0..largeur { - if y % 2 != 0 && x == longueur { - } else { - let mut curent_type = Tile::Grass; - if rand::random() { - if rand::random() { - curent_type = Tile::Forest - } else { - curent_type = Tile::Hill - } - } + (0..longueur) + .flat_map(|y| { + (0..largeur) + .filter(move |&x| !(y % 2 == 0 && x == largeur - 1)) + .map(move |x| (x, y)) + }) + .for_each(|(x, y)| { + commands.spawn((generate_random_tile_for_map(), Position { x, y })); + }); +} - commands.spawn((curent_type, Position { x, y })); - } +/// Cette fonction return un ellement aleatoir entre de la Grass Hill et Forest +fn generate_random_tile_for_map() -> Tile { + if rand::random() { + if rand::random() { + Tile::Forest + } else { + Tile::Hill } + } else { + Tile::Grass } } From 789a7ab22339a16f12a3081165451ce61a7e75dc Mon Sep 17 00:00:00 2001 From: _Corentin_ Date: Fri, 26 May 2023 08:33:52 +0200 Subject: [PATCH 6/9] nouvelle fonction --- src/map.rs | 31 +++++++++++++------------------ 1 file changed, 13 insertions(+), 18 deletions(-) diff --git a/src/map.rs b/src/map.rs index 0a19ffe..8c1fe32 100644 --- a/src/map.rs +++ b/src/map.rs @@ -2,6 +2,7 @@ use crate::Position; use bevy::prelude::{Commands, Component}; +use rand::Rng; #[derive(Debug, Clone, Copy, PartialEq, Eq, Component)] /// Une case sur la carte du jeu. @@ -75,28 +76,22 @@ pub enum Tile { } /// Permet de crée des entité representant les cases d'une map, sur une longueur et langueur donné. -/// Donner une longueur impaire. pub fn init_map(longueur: u8, largeur: u8, mut commands: Commands) { - (0..longueur) - .flat_map(|y| { - (0..largeur) - .filter(move |&x| !(y % 2 == 0 && x == largeur - 1)) - .map(move |x| (x, y)) - }) - .for_each(|(x, y)| { - commands.spawn((generate_random_tile_for_map(), Position { x, y })); - }); + for x in 0..longueur { + for y in 0..largeur { + if !(x % 2 == 0 && y == longueur - 1) { + commands.spawn((generate_random_tile_for_map(), Position { x, y })); + } + } + } } /// Cette fonction return un ellement aleatoir entre de la Grass Hill et Forest fn generate_random_tile_for_map() -> Tile { - if rand::random() { - if rand::random() { - Tile::Forest - } else { - Tile::Hill - } - } else { - Tile::Grass + let mut rng = rand::thread_rng(); + match rng.gen_range(1..=4) { + 1 => Tile::Forest, + 2 => Tile::Hill, + _ => Tile::Grass, } } From 562b965c8b5847e89a9b9381a4b5ba209eee0861 Mon Sep 17 00:00:00 2001 From: _Corentin_ Date: Fri, 26 May 2023 08:37:21 +0200 Subject: [PATCH 7/9] nom de variable + doc --- src/map.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/src/map.rs b/src/map.rs index 8c1fe32..07b2a4c 100644 --- a/src/map.rs +++ b/src/map.rs @@ -75,18 +75,18 @@ pub enum Tile { Wall, } -/// Permet de crée des entité representant les cases d'une map, sur une longueur et langueur donné. -pub fn init_map(longueur: u8, largeur: u8, mut commands: Commands) { - for x in 0..longueur { - for y in 0..largeur { - if !(x % 2 == 0 && y == longueur - 1) { +/// Initialisation d'une map aleatoire. +pub fn init_map(width: u8, height: u8, mut commands: Commands) { + for x in 0..width { + for y in 0..height { + if !(x % 2 == 0 && y == width - 1) { commands.spawn((generate_random_tile_for_map(), Position { x, y })); } } } } -/// Cette fonction return un ellement aleatoir entre de la Grass Hill et Forest +/// Cette fonction return un ellement aleatoire entre de la Grass Hill et Forest fn generate_random_tile_for_map() -> Tile { let mut rng = rand::thread_rng(); match rng.gen_range(1..=4) { From 7cc077e4f4c76c540961e6364b26bce90e177bc5 Mon Sep 17 00:00:00 2001 From: CoCo_Sol Date: Fri, 26 May 2023 19:15:14 +0200 Subject: [PATCH 8/9] renomage de la fonction --- src/map.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/map.rs b/src/map.rs index 07b2a4c..d8c7716 100644 --- a/src/map.rs +++ b/src/map.rs @@ -87,7 +87,7 @@ pub fn init_map(width: u8, height: u8, mut commands: Commands) { } /// Cette fonction return un ellement aleatoire entre de la Grass Hill et Forest -fn generate_random_tile_for_map() -> Tile { +fn get_random_tile() -> Tile { let mut rng = rand::thread_rng(); match rng.gen_range(1..=4) { 1 => Tile::Forest, From 4cee5d5cd5a9aa3c98efe1ef0670939c666ded3e Mon Sep 17 00:00:00 2001 From: CoCo_Sol Date: Fri, 26 May 2023 19:20:52 +0200 Subject: [PATCH 9/9] fix error --- src/map.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/map.rs b/src/map.rs index d8c7716..e9ec6b5 100644 --- a/src/map.rs +++ b/src/map.rs @@ -80,7 +80,7 @@ pub fn init_map(width: u8, height: u8, mut commands: Commands) { for x in 0..width { for y in 0..height { if !(x % 2 == 0 && y == width - 1) { - commands.spawn((generate_random_tile_for_map(), Position { x, y })); + commands.spawn((get_random_tile(), Position { x, y })); } } }