From f1d81ef05efdecf14f6acb0e9a1d156504aeaf12 Mon Sep 17 00:00:00 2001
From: Simon Gardling <titaniumtown@proton.me>
Date: Sun, 9 Feb 2025 01:11:02 -0500
Subject: [PATCH] code improvements

---
 src/complexagent.rs | 95 ++++++++++++++++++++++++++++++---------------
 1 file changed, 64 insertions(+), 31 deletions(-)

diff --git a/src/complexagent.rs b/src/complexagent.rs
index 0b99cff..539c1c5 100644
--- a/src/complexagent.rs
+++ b/src/complexagent.rs
@@ -7,13 +7,21 @@ pub struct ComplexAgent {
 
 #[derive(Clone)]
 struct Move {
+    /// `i` value of move
     i: usize,
+    /// `j` value of move
     j: usize,
+    /// how many pieces were captured
     captured: usize,
+    /// Turn
     color: Piece,
+    /// [`Board`] after move is made
     board: Board,
+    /// Winner of the match
     winner: Option<Piece>,
+    /// Move's parent index in [`FutureMoves`]
     parent_index: Option<usize>,
+    /// Value determined in [`Move::compute_self_value`]
     value: i64,
 }
 
@@ -37,21 +45,30 @@ impl Move {
     }
 }
 
-impl ComplexAgent {
-    #[allow(dead_code)]
-    pub const fn new(color: Piece) -> Self {
-        Self { color }
-    }
+struct FutureMoves {
+    /// Contains a Vector of Vectors, each top-level vector of index `i`
+    /// represents moves at depth `i` the contents of that vector are the
+    /// possible moves
+    inner: Vec<Vec<Move>>,
+    /// Color w.r.t
+    color: Piece,
+}
 
-    fn generate_layers(&self, board: &Board, depth: usize) -> Vec<Vec<Move>> {
-        let mut layers = Vec::with_capacity(depth);
-        let initial_moves: Vec<Move> = problem_space(board, self.color)
+impl FutureMoves {
+    fn from_problem_space(board: &Board, color: Piece, parent_index: Option<usize>) -> Vec<Move> {
+        problem_space(board, color)
             .map(|mut m| {
-                m.parent_index = None;
+                m.parent_index = parent_index;
                 m.value = 0;
                 m
             })
-            .collect();
+            .collect::<Vec<_>>()
+    }
+
+    pub fn generate(color: Piece, board: &Board, depth: usize) -> Self {
+        let mut layers = Vec::with_capacity(depth);
+        let initial_moves: Vec<Move> = Self::from_problem_space(board, color, None);
+
         layers.push(initial_moves);
 
         for current_depth in 0..depth {
@@ -61,42 +78,43 @@ impl ComplexAgent {
             }
 
             let next_moves: Vec<Move> = current_layer
-                .par_iter()
+                .into_iter()
                 .enumerate()
                 .flat_map(|(parent_idx, parent_move)| {
-                    let opponent_color = !parent_move.color;
-                    problem_space(&parent_move.board, opponent_color)
-                        .map(|mut m| {
-                            m.parent_index = Some(parent_idx);
-                            m.value = 0;
-                            m
-                        })
-                        .collect::<Vec<_>>()
+                    Self::from_problem_space(
+                        &parent_move.board,
+                        !parent_move.color,
+                        Some(parent_idx),
+                    )
                 })
                 .collect();
 
             layers.push(next_moves);
         }
 
-        self.compute_values(&mut layers);
-        layers
+        let mut tmp = Self {
+            inner: layers,
+            color,
+        };
+        tmp.compute_values();
+        tmp
     }
 
-    fn compute_values(&self, layers: &mut [Vec<Move>]) {
-        let agent_color = self.color;
-        let layers_len = layers.len();
-        for depth in (0..layers.len()).rev() {
+    fn compute_values(&mut self) {
+        let layers_len = self.inner.len();
+        for depth in (0..layers_len).rev() {
             let layer_depth_1: Vec<Move> = if depth + 1 < layers_len {
-                layers[depth + 1].clone()
+                self.inner[depth + 1].clone()
             } else {
                 Vec::new()
             };
 
-            let current_layer = &mut layers[depth];
+            let current_layer = &mut self.inner[depth];
 
             current_layer.par_iter_mut().for_each(|mv| {
-                let self_value = mv.compute_self_value(agent_color, depth + 1);
+                let self_value = mv.compute_self_value(self.color, depth + 1);
                 let children_value = if depth + 1 < layers_len {
+                    // calculate average value of each move
                     layer_depth_1
                         .iter()
                         .filter(|child| child.parent_index == Some(mv.parent_index.unwrap_or(0)))
@@ -110,14 +128,29 @@ impl ComplexAgent {
             });
         }
     }
+
+    pub fn inner(&self) -> &[Vec<Move>] {
+        &self.inner
+    }
+}
+
+impl ComplexAgent {
+    #[allow(dead_code)]
+    pub const fn new(color: Piece) -> Self {
+        Self { color }
+    }
 }
 
 impl Agent for ComplexAgent {
     fn next_move(&mut self, board: &Board) -> Option<(usize, usize)> {
         const LOOPS: usize = 5;
-        let layers = self.generate_layers(board, LOOPS);
-        println!("len: {}", layers.iter().map(Vec::len).sum::<usize>());
-        layers[0]
+        let layers = FutureMoves::generate(self.color, board, LOOPS);
+        println!(
+            "# of moves {} deep: {}",
+            LOOPS,
+            layers.inner().iter().map(Vec::len).sum::<usize>()
+        );
+        layers.inner()[0]
             .par_iter()
             .max_by_key(|m| m.value)
             .map(|m| (m.i, m.j))