battlesnake/src/main.rs

@@ -65,7 +65,6 @@ async fn start(request: Json<Request>) {
     info!("got start request: {board}");
 }
 
-#[allow(clippy::too_many_lines)]
 async fn get_move(request: Json<Request>) -> response::Json<Response> {
     let start = Instant::now();
     let board = Board::from(&*request);
@@ -89,68 +88,43 @@ async fn get_move(request: Json<Request>) -> response::Json<Response> {
 
     tokio::task::spawn_blocking(move || {
         let base_turns = board.turn();
-        let end_condition: &dyn Fn(&Board) -> Option<_> = match &*request.game.ruleset.name {
-            "solo" => &|board| {
+        let end_condition: &dyn Fn(&Board) -> Option<u32> = match &*request.game.ruleset.name {
+            "solo" => &|board: &Board| {
                 if board.num_snakes() == 0
                     || board.turn() > base_turns + (u32::from(request.you.length) * 3).min(32)
                 {
-                    Some(())
+                    Some(board.turn())
                 } else {
                     None
                 }
             },
-            _ => &|board| {
+            _ => &|board: &Board| {
                 if board.num_snakes() <= 1
                     || board.turn() > base_turns + (u32::from(request.you.length) * 3).min(32)
                 {
-                    Some(())
+                    Some(u32::from(board.alive(id)))
                 } else {
                     None
                 }
             },
         };
-        let start_snakes = u32::try_from(board.num_snakes()).unwrap_or(0);
-        let score_fn: &dyn Fn(&Board, u8) -> u32 = match &*request.game.ruleset.name {
-            "solo" => &|board, _| board.turn(),
-            _ => &|board, id| {
-                if board.alive(id) {
-                    1 + start_snakes - u32::try_from(board.num_snakes()).unwrap_or(start_snakes)
-                } else {
-                    0
-                }
-            },
-        };
 
-        let mut mcts_managers: Vec<_> = (0..request.board.snakes.len())
-            .map(|id| MctsManager::new(u8::try_from(id).unwrap()))
-            .collect();
+        let mut mcts_manager = MctsManager::new(id);
         let c = f32::sqrt(2.0);
-        while start.elapsed() < Duration::from_millis(250) {
+        'outer: while start.elapsed() < Duration::from_millis(250) {
             let mut board = board.clone();
-            while end_condition(&board).is_none() {
-                let actions: Vec<_> = mcts_managers
-                    .iter_mut()
-                    .filter_map(|mcts_manager| {
-                        mcts_manager
-                            .next_action(&board, c)
-                            .map(|action| (mcts_manager.snake, action))
-                    })
-                    .collect();
-                board.next_turn(&actions);
-                if actions.is_empty() {
-                    break;
+            while let Some(action) = mcts_manager.next_action(&board, c) {
+                board.next_turn(&[(id, action)]);
+                if let Some(score) = end_condition(&board) {
+                    mcts_manager.apply_score(score);
+                    continue 'outer;
                 }
             }
-            board.simulate_random(end_condition);
-            for mcts_manager in &mut mcts_managers {
-                let id = mcts_manager.snake;
-                let score = score_fn(&board, id);
+            let score = board.simulate_random(end_condition);
             mcts_manager.apply_score(score);
         }
-        }
-        let my_mcts_manager = &mcts_managers[usize::from(id)];
         for action in actions {
-            let score = my_mcts_manager.base.next[usize::from(action)]
+            let score = mcts_manager.base.next[usize::from(action)]
                 .as_ref()
                 .map(|info| info.score as f32 / info.played as f32);
             if let Some(score) = score {
@@ -160,7 +134,7 @@ async fn get_move(request: Json<Request>) -> response::Json<Response> {
             }
         }
 
-        let action = my_mcts_manager
+        let action = mcts_manager
             .base
             .next
             .iter()
@@ -185,7 +159,7 @@ async fn get_move(request: Json<Request>) -> response::Json<Response> {
         if let Some(action) = action {
             info!(
                 "found action {action:?} after {} simulations.",
-                my_mcts_manager.base.played
+                mcts_manager.base.played
             );
         } else {
             warn!("unable to find a valid action");

battlesnake/src/types/simulation.rs

@@ -233,6 +233,9 @@ impl Board {
 
     pub fn valid_actions(&self, id: u8) -> impl Iterator<Item = Direction> + use<'_> {
         let index = self.id_to_index(id);
+        if index.is_none() {
+            warn!("Asked for a snake that doesn't exist");
+        }
         index
             .into_iter()
             .flat_map(|index| self.valid_actions_index(index))

xtask/src/main.rs

@@ -366,7 +366,7 @@ fn run_local_docker(port: u16) -> Result<Child, DynError> {
             "--env",
             "RUST_LOG=error",
             "--env",
-            format!("PORT={}", port).as_str(),
+            format!("ROCKET_PORT={}", port).as_str(),
             "--network=host",
             "--rm",
             "local_snake",
@@ -396,7 +396,7 @@ fn run_production(port: u16) -> Result<Child, DynError> {
             "--env",
             "RUST_LOG=error",
             "--env",
-            format!("PORT={}", port).as_str(),
+            format!("ROCKET_PORT={}", port).as_str(),
             "--network=host",
             "--rm",
             "docker.mkaenner.de/snake:latest",