From 15202df4f441c2ac089da9bcc42a16e8a7c4aaf4 Mon Sep 17 00:00:00 2001
From: Pavel Lutskov <pavel.lutskov@gmail.com>
Date: Thu, 20 Feb 2025 21:24:59 +0100
Subject: [PATCH] Move some methods around

---
 rs/src/board.rs | 142 +++++++++++++++++++++++++-----------------------
 1 file changed, 73 insertions(+), 69 deletions(-)

diff --git a/rs/src/board.rs b/rs/src/board.rs
index 8c5be38..2cd0165 100644
--- a/rs/src/board.rs
+++ b/rs/src/board.rs
@@ -158,35 +158,76 @@ pub enum PieceType {
 }
 
 impl PieceType {
-    fn initial_setup(&self) -> Vec<(Piece, Position)> {
-        fn pawn(color: Color, file: File) -> (Piece, Position) {
-            let pos = Position::new(file, color.get_pawn_rank());
-            (
-                Piece {
-                    piece_type: PieceType::Pawn,
-                    color,
-                },
-                pos,
-            )
+    fn new_pawn(color: Color, file: File) -> (Piece, Position) {
+        let pos = Position::new(file, color.get_pawn_rank());
+        (
+            Piece {
+                piece_type: PieceType::Pawn,
+                color,
+            },
+            pos,
+        )
+    }
+    fn pawn_move_rays(position: &Position, color: &Color) -> Vec<Ray> {
+        let direction = match color {
+            Color::Black => Direction::Decr,
+            Color::White => Direction::Incr,
+        };
+        let go = |p: &Position| p.delta(&Direction::Stay, &direction);
+        if position.rank == color.get_pawn_rank() {
+            let one = go(position).unwrap();
+            let two = go(&one).unwrap();
+            vec![Ray {
+                positions: vec![one, two],
+            }]
+        } else {
+            if let Some(p) = go(position) {
+                vec![Ray {
+                    positions: vec![p],
+                }]
+            } else {
+                vec![]
+            }
         }
+    }
+
+    fn pawn_capture_rays(position: &Position, color: &Color) -> Vec<Ray> {
+        let direction = match color {
+            Color::Black => Direction::Decr,
+            Color::White => Direction::Incr,
+        };
+        let mut capture_rays = vec![];
+        if let Some(p) = position.delta(&Direction::Incr, &direction) {
+            capture_rays.push(Ray {
+                positions: vec![p],
+            });
+        }
+        if let Some(p) = position.delta(&Direction::Decr, &direction) {
+            capture_rays.push(Ray {
+                positions: vec![p],
+            });
+        }
+        capture_rays
+    }
+    fn initial_setup(&self) -> Vec<(Piece, Position)> {
         match &self {
             PieceType::Pawn => vec![
-                pawn(Color::White, File::A),
-                pawn(Color::White, File::B),
-                pawn(Color::White, File::C),
-                pawn(Color::White, File::D),
-                pawn(Color::White, File::E),
-                pawn(Color::White, File::F),
-                pawn(Color::White, File::G),
-                pawn(Color::White, File::H),
-                pawn(Color::Black, File::A),
-                pawn(Color::Black, File::B),
-                pawn(Color::Black, File::C),
-                pawn(Color::Black, File::D),
-                pawn(Color::Black, File::E),
-                pawn(Color::Black, File::F),
-                pawn(Color::Black, File::G),
-                pawn(Color::Black, File::H),
+                PieceType::new_pawn(Color::White, File::A),
+                PieceType::new_pawn(Color::White, File::B),
+                PieceType::new_pawn(Color::White, File::C),
+                PieceType::new_pawn(Color::White, File::D),
+                PieceType::new_pawn(Color::White, File::E),
+                PieceType::new_pawn(Color::White, File::F),
+                PieceType::new_pawn(Color::White, File::G),
+                PieceType::new_pawn(Color::White, File::H),
+                PieceType::new_pawn(Color::Black, File::A),
+                PieceType::new_pawn(Color::Black, File::B),
+                PieceType::new_pawn(Color::Black, File::C),
+                PieceType::new_pawn(Color::Black, File::D),
+                PieceType::new_pawn(Color::Black, File::E),
+                PieceType::new_pawn(Color::Black, File::F),
+                PieceType::new_pawn(Color::Black, File::G),
+                PieceType::new_pawn(Color::Black, File::H),
             ],
         }
     }
@@ -201,56 +242,19 @@ struct Ray {
     positions: Vec<Position>,
 }
 
-fn pawn_move_rays(position: &Position, color: &Color) -> Vec<Ray> {
-    let direction = match color {
-        Color::Black => Direction::Decr,
-        Color::White => Direction::Incr,
-    };
-    if position.rank == color.get_pawn_rank() {
-        let one = position.delta(&Direction::Stay, &direction).unwrap();
-        let two = one.delta(&Direction::Stay, &direction).unwrap();
-        vec![Ray {
-            positions: vec![one, two],
-        }]
-    } else {
-        if let Some(position) = position.delta(&Direction::Stay, &direction) {
-            vec![Ray {
-                positions: vec![position],
-            }]
-        } else {
-            vec![]
-        }
-    }
-}
-
-fn pawn_capture_rays(position: &Position, color: &Color) -> Vec<Ray> {
-    let direction = match color {
-        Color::Black => Direction::Decr,
-        Color::White => Direction::Incr,
-    };
-    let mut capture_rays = vec![];
-    if let Some(p) = position.delta(&Direction::Incr, &direction) {
-        capture_rays.push(Ray {
-            positions: vec![p],
-        });
-    }
-    if let Some(p) = position.delta(&Direction::Decr, &direction) {
-        capture_rays.push(Ray {
-            positions: vec![p],
-        });
-    }
-    capture_rays
-}
-
 impl Piece {
     fn get_move_rays(&self, position: &Position) -> Vec<Ray> {
         match self.piece_type {
-            PieceType::Pawn => pawn_move_rays(position, &self.color),
+            PieceType::Pawn => {
+                PieceType::pawn_move_rays(position, &self.color)
+            }
         }
     }
     fn get_capture_rays(&self, position: &Position) -> Vec<Ray> {
         match self.piece_type {
-            PieceType::Pawn => pawn_capture_rays(position, &self.color),
+            PieceType::Pawn => {
+                PieceType::pawn_capture_rays(position, &self.color)
+            }
         }
     }
 }