merged python module functions

Author: TheConverseEngineer

alpha_snake/python/player/controller.py

@@ -16,8 +16,7 @@ def __init__(self, time_left: Callable):
         self.search_tree = None
 
     def create_search_tree(self, board: player_board.PlayerBoard):
-        rustmap = rustmap_from_playerboard(board)
-        self.search_tree = alpha_snake.create_search_tree(rustmap)
+        self.search_tree = rustmap_from_playerboard(board)
 
     def bid(self, board: player_board.PlayerBoard, time_left: Callable):
         return 0

alpha_snake/src/lib.rs

@@ -42,7 +42,7 @@ fn mid_map(
     decay_countdown_value: usize,
     cached_decay_interval_value: isize,
     is_decaying_value: bool,
-) -> PyResult<Py<Board>> {
+) -> PyResult<Py<GameSearchTree>> {
     let a_direction = Action::new(a_direction);
     let b_direction = Action::new(b_direction);
 
@@ -69,7 +69,8 @@ fn mid_map(
         is_decaying_value,
     );
 
-    Python::with_gil(|py| Py::new(py, board))
+    let tree = GameSearchTree::new(&board);
+    Python::with_gil(|py| Py::new(py, tree))
 }
 
 #[pyfunction]
@@ -84,101 +85,11 @@ fn board_eq(a: Board, b: Board) -> bool {
     a == b
 }
 
-fn naive_minmax_search(
-    state: &mut Board,
-    depth: usize,
-    alpha: f32,
-    beta: f32,
-    rng: &mut impl Rng,
-) -> f32 {
-    if state.get_valid_moves().amount() == 0 {
-        // Terminal state
-        return if state.is_player_a { -1.0 } else { 1.0 };
-    } else if depth <= 0 {
-        // Calculate and return heuristic
-        return state.get_naive_heuristic();
-    }
-    if state.is_player_a {
-        let mut value = f32::MIN;
-        let mut my_alpha = alpha;
-
-        for action in state.get_valid_moves().actions_randomized(rng) {
-            state.step_in(action, |state| {
-                value = f32::max(
-                    value,
-                    naive_minmax_search(state, depth - 1, my_alpha, beta, rng),
-                );
-            });
-            if value > beta {
-                break;
-            }
-            my_alpha = f32::max(my_alpha, value);
-        }
-        value
-    } else {
-        let mut value = f32::MAX;
-        let mut my_beta = beta;
-
-        for action in state.get_valid_moves().actions_randomized(rng) {
-            state.step_in(action, |state| {
-                value = f32::min(
-                    value,
-                    naive_minmax_search(state, depth - 1, alpha, my_beta, rng),
-                );
-            });
-
-            if value < alpha {
-                break;
-            }
-            my_beta = f32::min(my_beta, value);
-        }
-        value
-    }
-}
-
-#[pyfunction]
-fn get_best_action(state: &mut Board) -> u8 {
-    let mut best_action = Action::FF;
-    let mut best_value = if state.is_player_a {
-        f32::MIN
-    } else {
-        f32::MAX
-    };
-    let mut rng = rand::rngs::SmallRng::from_os_rng();
-
-    for action in state.get_valid_moves().actions_randomized(&mut rng) {
-        let value = state.step_in(action, |state| {
-            naive_minmax_search(state, 12, f32::MIN, f32::MAX, &mut rng)
-        });
-
-        if state.is_player_a {
-            if value > best_value {
-                best_value = value;
-                best_action = action;
-            }
-        } else {
-            if value < best_value {
-                best_value = value;
-                best_action = action;
-            }
-        }
-    }
-    best_action as u8
-}
-
-#[pyfunction]
-fn create_search_tree(state: &mut Board) -> PyResult<Py<GameSearchTree>> {
-    let tree = GameSearchTree::new(state);
-    Python::with_gil(|py| Py::new(py, tree))
-}
-
 /// A Python module implemented in Rust.
 #[pymodule]
 fn alpha_snake(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(mid_map, m)?)?;
     m.add_function(wrap_pyfunction!(board_eq, m)?)?;
-    m.add_function(wrap_pyfunction!(get_best_action, m)?)?;
-    m.add_function(wrap_pyfunction!(create_search_tree, m)?).unwrap();
     Ok(())
 }