From fb8996a72ded8154c881c8f33fef019c741de770 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?U=C4=9Fur=20K=C3=BCpeli?= Date: Wed, 4 May 2022 03:21:28 +0300 Subject: [PATCH 1/6] init temp commit -- does not compile --- 62_Mugwump/rust/Cargo.toml | 9 ++ 62_Mugwump/rust/src/main.rs | 173 ++++++++++++++++++++++++++++++++++++ 2 files changed, 182 insertions(+) create mode 100644 62_Mugwump/rust/Cargo.toml create mode 100644 62_Mugwump/rust/src/main.rs diff --git a/62_Mugwump/rust/Cargo.toml b/62_Mugwump/rust/Cargo.toml new file mode 100644 index 00000000..3b1d02f5 --- /dev/null +++ b/62_Mugwump/rust/Cargo.toml @@ -0,0 +1,9 @@ +[package] +name = "rust" +version = "0.1.0" +edition = "2021" + +# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html + +[dependencies] +rand = "0.8.5" diff --git a/62_Mugwump/rust/src/main.rs b/62_Mugwump/rust/src/main.rs new file mode 100644 index 00000000..fadea906 --- /dev/null +++ b/62_Mugwump/rust/src/main.rs @@ -0,0 +1,173 @@ +#![allow(dead_code)] + +struct Game { + coords: Vec, + tries: u8, + mugwumps: Vec, + pub state: GameState, +} + +impl Game { + fn new() -> Self { + let mut coords = Vec::new(); + + let mut x = 0; + let mut y: i8 = 9; + + while y >= 0 { + for _ in 0..10 { + println!("current pos: {:?}", (x, y)); + coords.push(Coordinate::new((x, y as usize), false)); + + x += 1; + + if (x % 10) == 0 { + break; + } + } + + x = 0; + y -= 1; + } + + let mut mugwumps = Vec::new(); + let mut coords_clone = coords.clone(); + + use rand::prelude::IteratorRandom; + + for _ in 0..4 { + let (i, &mut mut out) = coords_clone + .iter_mut() + .enumerate() + .choose(&mut rand::thread_rng()) + .unwrap(); + + coords_clone.remove(i); + out.state = CoordState::HasMugwump; + mugwumps.push(out); + } + + println!("{:#?}", mugwumps); + + Game { + coords, + tries: 0, + mugwumps, + state: GameState::Playing, + } + } + + fn draw_board(&self) { + let draw_top_bottom = |is_top: bool| { + let (mut left, mut right) = ("╔", "╗"); + + if !is_top { + (left, right) = ("╚", "╝"); + } + + for i in 0..11 { + if i == 0 { + print!("{}══", left); + } else if i == 10 { + print!("═══{}", right) + } else { + print!("══"); + } + } + println!(""); + }; + + println!("coords length: {}", self.coords.len()); + + draw_top_bottom(true); + + // Draw points + let mut y: i8 = 9; + + print!("║ {} ", y); + + for (i, c) in self.coords.iter().enumerate() { + let mut char = '-'; + + match c.state { + CoordState::Normal => (), + CoordState::HasMugwump => char = '𑗌', + CoordState::Checked => char = '*', + } + + print!("{} ", char); + + if (i % 10) == 0 { + print!("║"); + println!(""); + print!("║ {} ", y); + y -= 1; + } + } + + print!("║ 𑗌 "); + for i in 0..10 { + print!("{} ", i); + + if i == 9 { + print!("║"); + } + } + println!(""); + + draw_top_bottom(false); + } +} + +enum GameState { + Playing, + Win, + Lose, +} + +#[derive(Clone, Copy, Debug)] +struct Coordinate { + x: usize, + y: usize, + state: CoordState, +} + +impl Coordinate { + fn new(pos: (usize, usize), has_mugwump: bool) -> Self { + let state = if has_mugwump { + CoordState::HasMugwump + } else { + CoordState::Normal + }; + + Coordinate { + x: pos.0, + y: pos.1, + state, + } + } +} + +#[derive(Clone, Copy, Debug)] +enum CoordState { + Normal, + HasMugwump, + Checked, +} + +fn main() { + println!("\n\nMUGWUMP"); + println!("CREATIVE COMPUTING MORRISTOWN, NEW JERSEY\n"); + + println!("THE OBJECT OF THIS GAME IS TO FIND FOUR MUGWUMPS"); + println!("HIDDEN ON A 10 BY 10 GRID. HOMEBASE IS POSITION 0,0."); + println!("ANY GUESS YOU MAKE MUST BE TWO NUMBERS WITH EACH"); + println!("NUMBER BETWEEN 0 AND 9, INCLUSIVE. FIRST NUMBER"); + println!("IS DISTANCE TO RIGHT OF HOMEBASE AND SECOND NUMBER"); + println!("IS DISTANCE ABOVE HOMEBASE!"); + println!("YOU GET 10 TRIES. AFTER EACH TRY, I WILL TELL"); + println!("YOU HOW FAR YOU ARE FROM EACH MUGWUMP.\n"); + + let game = Game::new(); + game.draw_board(); +} From 1fcda277e2f10be2d673af5c1384e3dc85b4d720 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?U=C4=9Fur=20K=C3=BCpeli?= Date: Wed, 4 May 2022 12:04:43 +0300 Subject: [PATCH 2/6] fixed coords generation --- 62_Mugwump/rust/src/main.rs | 61 ++++++++++++++++--------------------- 1 file changed, 27 insertions(+), 34 deletions(-) diff --git a/62_Mugwump/rust/src/main.rs b/62_Mugwump/rust/src/main.rs index fadea906..470b9411 100644 --- a/62_Mugwump/rust/src/main.rs +++ b/62_Mugwump/rust/src/main.rs @@ -1,58 +1,51 @@ #![allow(dead_code)] +use rand::Rng; + struct Game { coords: Vec, tries: u8, - mugwumps: Vec, pub state: GameState, } impl Game { fn new() -> Self { let mut coords = Vec::new(); + let mut random_indexes = Vec::new(); + let get_random_index = || -> i32 { rand::thread_rng().gen_range(0..100) }; + + for _ in 0..4 { + let mut i = get_random_index(); + while random_indexes.contains(&i) { + i = get_random_index(); + } + random_indexes.push(i); + } let mut x = 0; let mut y: i8 = 9; - while y >= 0 { - for _ in 0..10 { - println!("current pos: {:?}", (x, y)); - coords.push(Coordinate::new((x, y as usize), false)); + for i in 0..100 { + println!("current pos: {:?}", (x, y)); - x += 1; - - if (x % 10) == 0 { - break; - } + let mut has_mugwump = false; + if random_indexes.contains(&i) { + has_mugwump = true; } - x = 0; - y -= 1; + coords.push(Coordinate::new((x, y as usize), has_mugwump)); + + x += 1; + + if ((i + 1) % 10) == 0 { + x = 0; + y -= 1; + } } - let mut mugwumps = Vec::new(); - let mut coords_clone = coords.clone(); - - use rand::prelude::IteratorRandom; - - for _ in 0..4 { - let (i, &mut mut out) = coords_clone - .iter_mut() - .enumerate() - .choose(&mut rand::thread_rng()) - .unwrap(); - - coords_clone.remove(i); - out.state = CoordState::HasMugwump; - mugwumps.push(out); - } - - println!("{:#?}", mugwumps); - Game { coords, tries: 0, - mugwumps, state: GameState::Playing, } } @@ -125,7 +118,7 @@ enum GameState { Lose, } -#[derive(Clone, Copy, Debug)] +#[derive(Debug)] struct Coordinate { x: usize, y: usize, @@ -148,7 +141,7 @@ impl Coordinate { } } -#[derive(Clone, Copy, Debug)] +#[derive(Debug, PartialEq)] enum CoordState { Normal, HasMugwump, From f9c4bd620b4f2bb176beeb5eca35685453cedbbd Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?U=C4=9Fur=20K=C3=BCpeli?= Date: Wed, 4 May 2022 12:32:14 +0300 Subject: [PATCH 3/6] fixed draw_board --- 62_Mugwump/rust/src/draw.rs | 64 ++++++++++++++++++++++++++++++++ 62_Mugwump/rust/src/main.rs | 73 ++++--------------------------------- 2 files changed, 72 insertions(+), 65 deletions(-) create mode 100644 62_Mugwump/rust/src/draw.rs diff --git a/62_Mugwump/rust/src/draw.rs b/62_Mugwump/rust/src/draw.rs new file mode 100644 index 00000000..c5fd975b --- /dev/null +++ b/62_Mugwump/rust/src/draw.rs @@ -0,0 +1,64 @@ +use crate::{CoordState, Coordinate}; + +pub fn draw_board(coords: Vec) { + let draw_top_bottom = |is_top: bool| { + let (mut left, mut right) = ("╔", "╗"); + + if !is_top { + (left, right) = ("╚", "╝"); + } + + for i in 0..11 { + if i == 0 { + print!("{}══", left); + } else if i == 10 { + print!("═══{}", right) + } else { + print!("══"); + } + } + println!(""); + }; + + //println!("coords length: {}", coords.len()); + + draw_top_bottom(true); + + let mut y: i8 = 9; + + print!("║ {} ", y); + for (i, c) in coords.iter().enumerate() { + let mut _char = ' '; + + match c.state { + CoordState::Normal => _char = '-', + CoordState::HasMugwump => _char = '𑗌', + CoordState::Checked => _char = '*', + } + + print!("{} ", _char); + + if ((i + 1) % 10) == 0 { + y -= 1; + + print!("║"); + println!(""); + + if i != 99 { + print!("║ {} ", y); + } + } + } + + print!("║ 𑗌 "); + for i in 0..10 { + print!("{} ", i); + + if i == 9 { + print!("║"); + } + } + println!(""); + + draw_top_bottom(false); +} diff --git a/62_Mugwump/rust/src/main.rs b/62_Mugwump/rust/src/main.rs index 470b9411..5c52ca06 100644 --- a/62_Mugwump/rust/src/main.rs +++ b/62_Mugwump/rust/src/main.rs @@ -1,7 +1,11 @@ #![allow(dead_code)] +mod draw; + use rand::Rng; +use crate::draw::draw_board; + struct Game { coords: Vec, tries: u8, @@ -26,7 +30,7 @@ impl Game { let mut y: i8 = 9; for i in 0..100 { - println!("current pos: {:?}", (x, y)); + //println!("current pos: {:?}", (x, y)); let mut has_mugwump = false; if random_indexes.contains(&i) { @@ -49,67 +53,6 @@ impl Game { state: GameState::Playing, } } - - fn draw_board(&self) { - let draw_top_bottom = |is_top: bool| { - let (mut left, mut right) = ("╔", "╗"); - - if !is_top { - (left, right) = ("╚", "╝"); - } - - for i in 0..11 { - if i == 0 { - print!("{}══", left); - } else if i == 10 { - print!("═══{}", right) - } else { - print!("══"); - } - } - println!(""); - }; - - println!("coords length: {}", self.coords.len()); - - draw_top_bottom(true); - - // Draw points - let mut y: i8 = 9; - - print!("║ {} ", y); - - for (i, c) in self.coords.iter().enumerate() { - let mut char = '-'; - - match c.state { - CoordState::Normal => (), - CoordState::HasMugwump => char = '𑗌', - CoordState::Checked => char = '*', - } - - print!("{} ", char); - - if (i % 10) == 0 { - print!("║"); - println!(""); - print!("║ {} ", y); - y -= 1; - } - } - - print!("║ 𑗌 "); - for i in 0..10 { - print!("{} ", i); - - if i == 9 { - print!("║"); - } - } - println!(""); - - draw_top_bottom(false); - } } enum GameState { @@ -119,7 +62,7 @@ enum GameState { } #[derive(Debug)] -struct Coordinate { +pub struct Coordinate { x: usize, y: usize, state: CoordState, @@ -142,7 +85,7 @@ impl Coordinate { } #[derive(Debug, PartialEq)] -enum CoordState { +pub enum CoordState { Normal, HasMugwump, Checked, @@ -162,5 +105,5 @@ fn main() { println!("YOU HOW FAR YOU ARE FROM EACH MUGWUMP.\n"); let game = Game::new(); - game.draw_board(); + draw_board(game.coords); } From b1106d3112c8a140d240a19b652124d54eb39d93 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?U=C4=9Fur=20K=C3=BCpeli?= Date: Wed, 4 May 2022 12:36:38 +0300 Subject: [PATCH 4/6] separated files --- 62_Mugwump/rust/src/coordinate.rs | 29 ++++++++++ 62_Mugwump/rust/src/draw.rs | 4 +- 62_Mugwump/rust/src/game.rs | 56 +++++++++++++++++++ 62_Mugwump/rust/src/main.rs | 91 +------------------------------ 4 files changed, 89 insertions(+), 91 deletions(-) create mode 100644 62_Mugwump/rust/src/coordinate.rs create mode 100644 62_Mugwump/rust/src/game.rs diff --git a/62_Mugwump/rust/src/coordinate.rs b/62_Mugwump/rust/src/coordinate.rs new file mode 100644 index 00000000..f44a289f --- /dev/null +++ b/62_Mugwump/rust/src/coordinate.rs @@ -0,0 +1,29 @@ +#[derive(Debug)] +pub struct Coordinate { + x: usize, + y: usize, + pub state: CoordState, +} + +impl Coordinate { + pub fn new(pos: (usize, usize), has_mugwump: bool) -> Self { + let state = if has_mugwump { + CoordState::HasMugwump + } else { + CoordState::Normal + }; + + Coordinate { + x: pos.0, + y: pos.1, + state, + } + } +} + +#[derive(Debug, PartialEq)] +pub enum CoordState { + Normal, + HasMugwump, + Checked, +} diff --git a/62_Mugwump/rust/src/draw.rs b/62_Mugwump/rust/src/draw.rs index c5fd975b..5b0e7af0 100644 --- a/62_Mugwump/rust/src/draw.rs +++ b/62_Mugwump/rust/src/draw.rs @@ -1,4 +1,4 @@ -use crate::{CoordState, Coordinate}; +use crate::coordinate::{CoordState, Coordinate}; pub fn draw_board(coords: Vec) { let draw_top_bottom = |is_top: bool| { @@ -20,8 +20,6 @@ pub fn draw_board(coords: Vec) { println!(""); }; - //println!("coords length: {}", coords.len()); - draw_top_bottom(true); let mut y: i8 = 9; diff --git a/62_Mugwump/rust/src/game.rs b/62_Mugwump/rust/src/game.rs new file mode 100644 index 00000000..1b45bab8 --- /dev/null +++ b/62_Mugwump/rust/src/game.rs @@ -0,0 +1,56 @@ +use rand::Rng; + +use crate::coordinate::Coordinate; + +pub struct Game { + pub coords: Vec, + tries: u8, + pub state: GameState, +} + +impl Game { + pub fn new() -> Self { + let mut coords = Vec::new(); + let mut random_indexes = Vec::new(); + let get_random_index = || -> i32 { rand::thread_rng().gen_range(0..100) }; + + for _ in 0..4 { + let mut i = get_random_index(); + while random_indexes.contains(&i) { + i = get_random_index(); + } + random_indexes.push(i); + } + + let mut x = 0; + let mut y: i8 = 9; + + for i in 0..100 { + let mut has_mugwump = false; + if random_indexes.contains(&i) { + has_mugwump = true; + } + + coords.push(Coordinate::new((x, y as usize), has_mugwump)); + + x += 1; + + if ((i + 1) % 10) == 0 { + x = 0; + y -= 1; + } + } + + Game { + coords, + tries: 0, + state: GameState::Playing, + } + } +} + +pub enum GameState { + Playing, + Win, + Lose, +} diff --git a/62_Mugwump/rust/src/main.rs b/62_Mugwump/rust/src/main.rs index 5c52ca06..8ed8d292 100644 --- a/62_Mugwump/rust/src/main.rs +++ b/62_Mugwump/rust/src/main.rs @@ -1,95 +1,10 @@ #![allow(dead_code)] +mod coordinate; mod draw; +mod game; -use rand::Rng; - -use crate::draw::draw_board; - -struct Game { - coords: Vec, - tries: u8, - pub state: GameState, -} - -impl Game { - fn new() -> Self { - let mut coords = Vec::new(); - let mut random_indexes = Vec::new(); - let get_random_index = || -> i32 { rand::thread_rng().gen_range(0..100) }; - - for _ in 0..4 { - let mut i = get_random_index(); - while random_indexes.contains(&i) { - i = get_random_index(); - } - random_indexes.push(i); - } - - let mut x = 0; - let mut y: i8 = 9; - - for i in 0..100 { - //println!("current pos: {:?}", (x, y)); - - let mut has_mugwump = false; - if random_indexes.contains(&i) { - has_mugwump = true; - } - - coords.push(Coordinate::new((x, y as usize), has_mugwump)); - - x += 1; - - if ((i + 1) % 10) == 0 { - x = 0; - y -= 1; - } - } - - Game { - coords, - tries: 0, - state: GameState::Playing, - } - } -} - -enum GameState { - Playing, - Win, - Lose, -} - -#[derive(Debug)] -pub struct Coordinate { - x: usize, - y: usize, - state: CoordState, -} - -impl Coordinate { - fn new(pos: (usize, usize), has_mugwump: bool) -> Self { - let state = if has_mugwump { - CoordState::HasMugwump - } else { - CoordState::Normal - }; - - Coordinate { - x: pos.0, - y: pos.1, - state, - } - } -} - -#[derive(Debug, PartialEq)] -pub enum CoordState { - Normal, - HasMugwump, - Checked, -} +use crate::{draw::draw_board, game::Game}; fn main() { println!("\n\nMUGWUMP"); From 844e190ca9e63aef691d73f00fd845fbb7e2beba Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?U=C4=9Fur=20K=C3=BCpeli?= Date: Wed, 4 May 2022 13:57:37 +0300 Subject: [PATCH 5/6] game loop almost done todo: play again prompts and exit --- 62_Mugwump/rust/src/coordinate.rs | 18 ++++- 62_Mugwump/rust/src/draw.rs | 23 ++++--- 62_Mugwump/rust/src/game.rs | 106 ++++++++++++++++++++++++++---- 62_Mugwump/rust/src/main.rs | 22 +++++-- 62_Mugwump/rust/src/util.rs | 13 ++++ 5 files changed, 152 insertions(+), 30 deletions(-) create mode 100644 62_Mugwump/rust/src/util.rs diff --git a/62_Mugwump/rust/src/coordinate.rs b/62_Mugwump/rust/src/coordinate.rs index f44a289f..f13eb240 100644 --- a/62_Mugwump/rust/src/coordinate.rs +++ b/62_Mugwump/rust/src/coordinate.rs @@ -1,13 +1,19 @@ +#![allow(dead_code)] + #[derive(Debug)] pub struct Coordinate { - x: usize, - y: usize, + x: u8, + y: u8, pub state: CoordState, + pub mugwump_number: u8, } impl Coordinate { - pub fn new(pos: (usize, usize), has_mugwump: bool) -> Self { + pub fn new(pos: (u8, u8), has_mugwump: bool, mugwump_number: i32) -> Self { + let mut mug_no = 0; + let state = if has_mugwump { + mug_no = mugwump_number; CoordState::HasMugwump } else { CoordState::Normal @@ -17,8 +23,13 @@ impl Coordinate { x: pos.0, y: pos.1, state, + mugwump_number: mug_no as u8, } } + + pub fn get_pos(&self) -> (u8, u8) { + (self.x, self.y) + } } #[derive(Debug, PartialEq)] @@ -26,4 +37,5 @@ pub enum CoordState { Normal, HasMugwump, Checked, + FoundMugwump, } diff --git a/62_Mugwump/rust/src/draw.rs b/62_Mugwump/rust/src/draw.rs index 5b0e7af0..66de993a 100644 --- a/62_Mugwump/rust/src/draw.rs +++ b/62_Mugwump/rust/src/draw.rs @@ -1,6 +1,6 @@ use crate::coordinate::{CoordState, Coordinate}; -pub fn draw_board(coords: Vec) { +pub fn draw_board(coords: &Vec) { let draw_top_bottom = |is_top: bool| { let (mut left, mut right) = ("╔", "╗"); @@ -26,16 +26,21 @@ pub fn draw_board(coords: Vec) { print!("║ {} ", y); for (i, c) in coords.iter().enumerate() { - let mut _char = ' '; + { + use CoordState::*; - match c.state { - CoordState::Normal => _char = '-', - CoordState::HasMugwump => _char = '𑗌', - CoordState::Checked => _char = '*', + let mut _char = ' '; + + match c.state { + Normal => _char = '-', + HasMugwump => _char = 'ü', + Checked => _char = '*', + FoundMugwump => _char = '𑗌', + } + + print!("{} ", _char); } - print!("{} ", _char); - if ((i + 1) % 10) == 0 { y -= 1; @@ -48,7 +53,7 @@ pub fn draw_board(coords: Vec) { } } - print!("║ 𑗌 "); + print!("║ ♥︎ "); for i in 0..10 { print!("{} ", i); diff --git a/62_Mugwump/rust/src/game.rs b/62_Mugwump/rust/src/game.rs index 1b45bab8..f47848c0 100644 --- a/62_Mugwump/rust/src/game.rs +++ b/62_Mugwump/rust/src/game.rs @@ -1,11 +1,14 @@ use rand::Rng; -use crate::coordinate::Coordinate; +use crate::{ + coordinate::{CoordState, Coordinate}, + draw::draw_board, + util, +}; pub struct Game { pub coords: Vec, tries: u8, - pub state: GameState, } impl Game { @@ -25,13 +28,17 @@ impl Game { let mut x = 0; let mut y: i8 = 9; + let mut mugwump_number = 0; + for i in 0..100 { let mut has_mugwump = false; + if random_indexes.contains(&i) { has_mugwump = true; + mugwump_number += 1; } - coords.push(Coordinate::new((x, y as usize), has_mugwump)); + coords.push(Coordinate::new((x, y as u8), has_mugwump, mugwump_number)); x += 1; @@ -41,16 +48,91 @@ impl Game { } } - Game { - coords, - tries: 0, - state: GameState::Playing, + Game { coords, tries: 0 } + } + + pub fn tick(&mut self) -> bool { + if self.tries >= 10 { + return false; + } + + if self.get_mugwumps().len() == 0 { + return false; + } + + // ASK FOR PLAY AGAIN! + + self.tries += 1; + + draw_board(&self.coords); + + let entered_position = self.input_coordinate(); + self.check_position(entered_position); + + true + } + + fn check_position(&mut self, pos: (u8, u8)) { + if let Some(coord) = self.coords.iter_mut().find(|c| c.get_pos() == pos) { + use CoordState::*; + + match coord.state { + Normal => self.print_distances(pos), + HasMugwump => { + coord.state = FoundMugwump; + println!("YOU FOUND MUGWUMP {}", coord.mugwump_number); + self.print_distances(pos); + } + Checked | FoundMugwump => println!("YOU ALREADY LOOKED HERE!"), + } } } -} -pub enum GameState { - Playing, - Win, - Lose, + fn print_distances(&self, (x, y): (u8, u8)) { + println!("\n"); + + let print = |m: &Coordinate| { + let (mx, my) = m.get_pos(); + let (x, y, mx, my) = (x as i32, y as i32, mx as i32, my as i32); + let distance = (((x - mx).pow(2) + (y - my).pow(2)) as f32).sqrt(); + + println!( + "YOU ARE {} UNITS FROM MUGWUMP {}", + distance, m.mugwump_number + ); + }; + + for m in self.get_mugwumps() { + print(m); + } + } + + fn input_coordinate(&self) -> (u8, u8) { + let msg = format!("TURN NO. {} WHAT IS YOUR GUESS?", self.tries); + let input = util::prompt(msg.as_str()); + + if !input.contains(",") { + println!("YOU MUST ENTER A COORDINATE: #,#"); + return (0, 0); + } + + let axes: Vec<&str> = input.split(",").collect(); + let mut pos = [0; 2]; + + for (i, a) in axes.iter().enumerate() { + match a.parse::() { + Ok(p) => pos[i] = p as u8, + Err(_) => println!("YOU MUST ENTER A COORDINATE: #,#"), + } + } + + (pos[0], pos[1]) + } + + fn get_mugwumps(&self) -> Vec<&Coordinate> { + self.coords + .iter() + .filter(|c| c.state == CoordState::HasMugwump) + .collect() + } } diff --git a/62_Mugwump/rust/src/main.rs b/62_Mugwump/rust/src/main.rs index 8ed8d292..b0a03829 100644 --- a/62_Mugwump/rust/src/main.rs +++ b/62_Mugwump/rust/src/main.rs @@ -1,10 +1,9 @@ -#![allow(dead_code)] - mod coordinate; mod draw; mod game; +pub mod util; -use crate::{draw::draw_board, game::Game}; +use crate::game::Game; fn main() { println!("\n\nMUGWUMP"); @@ -15,10 +14,21 @@ fn main() { println!("ANY GUESS YOU MAKE MUST BE TWO NUMBERS WITH EACH"); println!("NUMBER BETWEEN 0 AND 9, INCLUSIVE. FIRST NUMBER"); println!("IS DISTANCE TO RIGHT OF HOMEBASE AND SECOND NUMBER"); - println!("IS DISTANCE ABOVE HOMEBASE!"); + println!("IS DISTANCE ABOVE HOMEBASE!\n"); + println!("YOU GET 10 TRIES. AFTER EACH TRY, I WILL TELL"); println!("YOU HOW FAR YOU ARE FROM EACH MUGWUMP.\n"); - let game = Game::new(); - draw_board(game.coords); + let mut _quit = false; + + while !_quit { + let mut game = Game::new(); + + loop { + if !game.tick() { + _quit = true; + break; + } + } + } } diff --git a/62_Mugwump/rust/src/util.rs b/62_Mugwump/rust/src/util.rs new file mode 100644 index 00000000..1ce2e1d5 --- /dev/null +++ b/62_Mugwump/rust/src/util.rs @@ -0,0 +1,13 @@ +use std::io; + +pub fn prompt(msg: &str) -> String { + println!("\n{}", msg); + + let mut input = String::new(); + + io::stdin() + .read_line(&mut input) + .expect("Failed to read line."); + + input.trim().to_string() +} From 6f39db56bff1627b77ecb206e6b12a399f207637 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?U=C4=9Fur=20K=C3=BCpeli?= Date: Wed, 4 May 2022 16:20:46 +0300 Subject: [PATCH 6/6] hopefully done --- 62_Mugwump/rust/src/draw.rs | 4 ++-- 62_Mugwump/rust/src/game.rs | 46 ++++++++++++++++++++++++++++--------- 62_Mugwump/rust/src/main.rs | 16 ++++++++++--- 62_Mugwump/rust/src/util.rs | 12 ++++++++++ 4 files changed, 62 insertions(+), 16 deletions(-) diff --git a/62_Mugwump/rust/src/draw.rs b/62_Mugwump/rust/src/draw.rs index 66de993a..d7fac325 100644 --- a/62_Mugwump/rust/src/draw.rs +++ b/62_Mugwump/rust/src/draw.rs @@ -1,6 +1,6 @@ use crate::coordinate::{CoordState, Coordinate}; -pub fn draw_board(coords: &Vec) { +pub fn draw_board(coords: &Vec, show_mugwumps: bool) { let draw_top_bottom = |is_top: bool| { let (mut left, mut right) = ("╔", "╗"); @@ -33,7 +33,7 @@ pub fn draw_board(coords: &Vec) { match c.state { Normal => _char = '-', - HasMugwump => _char = 'ü', + HasMugwump => _char = if show_mugwumps { 'M' } else { '-' }, Checked => _char = '*', FoundMugwump => _char = '𑗌', } diff --git a/62_Mugwump/rust/src/game.rs b/62_Mugwump/rust/src/game.rs index f47848c0..f556dfac 100644 --- a/62_Mugwump/rust/src/game.rs +++ b/62_Mugwump/rust/src/game.rs @@ -9,10 +9,11 @@ use crate::{ pub struct Game { pub coords: Vec, tries: u8, + show_board: bool, } impl Game { - pub fn new() -> Self { + pub fn new(show_board: bool) -> Self { let mut coords = Vec::new(); let mut random_indexes = Vec::new(); let get_random_index = || -> i32 { rand::thread_rng().gen_range(0..100) }; @@ -48,28 +49,50 @@ impl Game { } } - Game { coords, tries: 0 } + Game { + coords, + tries: 0, + show_board, + } } - pub fn tick(&mut self) -> bool { + pub fn tick(&mut self) -> Option { + let mut game_over = false; + if self.tries >= 10 { - return false; + println!("SORRY THAT'S 10 TRIES. HERE IS WHERE THEY ARE HIDING"); + + for m in self.get_mugwumps() { + println!("MUGWUMP {} IS AT {:?}", m.mugwump_number, m.get_pos()); + } + + if self.show_board { + draw_board(&self.coords, true); + } + + game_over = true; } if self.get_mugwumps().len() == 0 { - return false; + println!("YOU HAVE FOUND ALL MUGWUMPS!"); + + game_over = true; } - // ASK FOR PLAY AGAIN! + if game_over { + return util::prompt_bool("THAT WAS FUN! PLAY AGAIN (Y/n)?"); + } self.tries += 1; - draw_board(&self.coords); + if self.show_board { + draw_board(&self.coords, true); + } let entered_position = self.input_coordinate(); self.check_position(entered_position); - true + None } fn check_position(&mut self, pos: (u8, u8)) { @@ -77,7 +100,10 @@ impl Game { use CoordState::*; match coord.state { - Normal => self.print_distances(pos), + Normal => { + coord.state = Checked; + self.print_distances(pos); + } HasMugwump => { coord.state = FoundMugwump; println!("YOU FOUND MUGWUMP {}", coord.mugwump_number); @@ -89,8 +115,6 @@ impl Game { } fn print_distances(&self, (x, y): (u8, u8)) { - println!("\n"); - let print = |m: &Coordinate| { let (mx, my) = m.get_pos(); let (x, y, mx, my) = (x as i32, y as i32, mx as i32, my as i32); diff --git a/62_Mugwump/rust/src/main.rs b/62_Mugwump/rust/src/main.rs index b0a03829..fbd4479d 100644 --- a/62_Mugwump/rust/src/main.rs +++ b/62_Mugwump/rust/src/main.rs @@ -22,11 +22,21 @@ fn main() { let mut _quit = false; while !_quit { - let mut game = Game::new(); + let mut show_board = true; + + if let Some(r) = util::prompt_bool("WOULD YOU LIKE TO SEE THE BOARD?") { + show_board = r; + } + + let mut game = Game::new(show_board); loop { - if !game.tick() { - _quit = true; + if let Some(again) = game.tick() { + if !again { + _quit = true; + } else { + println!("FOUR MORE MUGWUMPS ARE NOW IN HIDING") + } break; } } diff --git a/62_Mugwump/rust/src/util.rs b/62_Mugwump/rust/src/util.rs index 1ce2e1d5..ff4e9ecb 100644 --- a/62_Mugwump/rust/src/util.rs +++ b/62_Mugwump/rust/src/util.rs @@ -11,3 +11,15 @@ pub fn prompt(msg: &str) -> String { input.trim().to_string() } + +pub fn prompt_bool(msg: &str) -> Option { + loop { + let response = prompt(msg); + + match response.to_uppercase().as_str() { + "Y" | "YES" => return Some(true), + "N" | "NO" => return Some(false), + _ => println!("PLEASE ENTER (Y)ES or (N)O."), + } + } +}