initial release

src/lib/game.rs

@@ -0,0 +1,221 @@
+use std::{error::Error, fmt::Display};
+
+use super::{
+    controller::{Controller, Move, PlayerController},
+    grid::Grid,
+};
+
+pub struct Rules {
+    size: usize,
+    spawn_per_turn: usize,
+    controller: Box<dyn Controller>,
+}
+
+impl Rules {
+    pub fn size(mut self, size: usize) -> Self {
+        self.size = size;
+        self
+    }
+
+    pub fn spawn_per_turn(mut self, spawn_per_turn: usize) -> Self {
+        self.spawn_per_turn = spawn_per_turn;
+        self
+    }
+}
+
+impl Default for Rules {
+    fn default() -> Self {
+        Self {
+            size: 4,
+            spawn_per_turn: 1,
+            controller: Box::new(PlayerController::new()),
+        }
+    }
+}
+
+#[derive(Debug)]
+pub enum Err2048 {
+    GridIsFull,
+}
+
+impl Display for Err2048 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let msg = match self {
+            &Self::GridIsFull => "grid is full",
+        };
+        f.write_str(msg)
+    }
+}
+
+impl Error for Err2048 {}
+
+pub struct Game {
+    board: Grid,
+    controller: Box<dyn Controller>,
+    spawn_per_turn: usize,
+}
+
+impl Game {
+    pub fn new(rules: Rules) -> Self {
+        let Rules {
+            controller,
+            size,
+            spawn_per_turn,
+        } = rules;
+
+        Self {
+            board: Grid::new(size),
+            controller,
+            spawn_per_turn,
+        }
+    }
+
+    pub fn turn(&mut self) -> Result<(), Box<dyn Error>> {
+        for _ in 0..self.spawn_per_turn {
+            self.spawn_random()?;
+        }
+        self.refresh_display();
+        let movement = self.controller.next_move(&self.board)?;
+        self.perform_move(movement);
+        Ok(())
+    }
+
+    pub fn spawn_random(&mut self) -> Result<(), Box<dyn Error>> {
+        let mut potentials = vec![];
+        for x in 0..self.board.size() {
+            for y in 0..self.board.size() {
+                if self.board.get((x, y)).unwrap().is_empty() {
+                    potentials.push((x, y));
+                }
+            }
+        }
+        let potential_count = potentials.len() as f32;
+        if potential_count == 0. {
+            return Err(Err2048::GridIsFull.into());
+        }
+        let random = rand::random::<f32>() * potential_count;
+        let index = random.floor() as usize;
+        let (x, y) = potentials[index];
+        self.board.set((x, y), Some(1));
+        Ok(())
+    }
+
+    pub fn refresh_display(&self) {
+        super::clear_term();
+        let text = self.board.display();
+        println!("{text}");
+    }
+
+    // TODO: macro peut être ?
+    pub fn perform_move(&mut self, movement: Move) {
+        match movement {
+            Move::LEFT => {
+                for y in 0..self.board.size() {
+                    for x in 0..self.board.size() {
+                        if !self.board.get((x, y)).unwrap().is_empty() {
+                            self.perform_linear_move((-1, 0), (x, y));
+                        }
+                    }
+                }
+            }
+            Move::RIGHT => {
+                for y in 0..self.board.size() {
+                    for x in (0..self.board.size()).rev() {
+                        if !self.board.get((x, y)).unwrap().is_empty() {
+                            self.perform_linear_move((1, 0), (x, y));
+                        }
+                    }
+                }
+            }
+            Move::UP => {
+                for x in 0..self.board.size() {
+                    for y in 0..self.board.size() {
+                        if !self.board.get((x, y)).unwrap().is_empty() {
+                            self.perform_linear_move((0, -1), (x, y));
+                        }
+                    }
+                }
+            }
+            Move::DOWN => {
+                for x in 0..self.board.size() {
+                    for y in (0..self.board.size()).rev() {
+                        if !self.board.get((x, y)).unwrap().is_empty() {
+                            self.perform_linear_move((0, 1), (x, y));
+                        }
+                    }
+                }
+            }
+        };
+    }
+
+    fn perform_linear_move(&mut self, direction: (isize, isize), tile_pos: (usize, usize)) {
+        let mut displacement = Displacement::new(&mut self.board, tile_pos, direction);
+        displacement.move_all();
+    }
+}
+
+pub struct Displacement<'g> {
+    grid: &'g mut Grid,
+    position: (usize, usize),
+    direction: (isize, isize),
+}
+
+impl<'g> Displacement<'g> {
+    pub fn new(grid: &'g mut Grid, position: (usize, usize), direction: (isize, isize)) -> Self {
+        Self {
+            grid,
+            position,
+            direction,
+        }
+    }
+
+    pub fn move_all(&mut self) {
+        while self.move_once() {}
+    }
+
+    fn move_once(&mut self) -> bool {
+        let current_pos = self.position.clone();
+        let current_value = self.grid.get_val(current_pos).unwrap();
+        if let Some(next_pos) = self.get_next_pos() {
+            match self.grid.get_val(next_pos) {
+                None => {
+                    self.grid.move_tile(current_pos, next_pos);
+                    self.set_pos(next_pos);
+                    true
+                }
+                Some(value) if value == current_value => {
+                    self.grid.move_tile(current_pos, next_pos);
+                    self.grid.set(next_pos, Some(value * 2));
+                    false
+                }
+                Some(_) => false,
+            }
+        } else {
+            false
+        }
+    }
+
+    fn get_next_pos(&self) -> Option<(usize, usize)> {
+        let (current_x, current_y) = self.position.clone();
+        let (dx, dy) = self.direction.clone();
+        if would_overflow(current_x, dx, self.grid.size() - 1)
+            || would_overflow(current_y, dy, self.grid.size() - 1)
+        {
+            None
+        } else {
+            let next_x = (current_x as isize) + dx;
+            let next_y = (current_y as isize) + dy;
+            Some((next_x as usize, next_y as usize))
+        }
+    }
+
+    fn set_pos(&mut self, (x, y): (usize, usize)) {
+        self.position = (x, y);
+    }
+}
+
+fn would_overflow(n: usize, d: isize, max: usize) -> bool {
+    let too_little = n == 0 && d == -1;
+    let too_big = n == max && d == 1;
+    too_little || too_big
+}