fix some cases where it gets stuck

1 files changed, 35 insertions, 21 deletions

diff --git a/server/bot/src/algos/simple.rs b/server/bot/src/algos/simple.rs
index af02f81e..ba5fd5ff 100644
--- a/server/bot/src/algos/simple.rs
+++ b/server/bot/src/algos/simple.rs
@@ -6,7 +6,7 @@ use hurrycurry_client_lib::Game;
 use hurrycurry_protocol::{
     glam::IVec2, ItemIndex, Message, PlayerID, Recipe, RecipeIndex, TileIndex,
 };
-use log::{info, warn};
+use log::{debug, warn};
 
 #[derive(Default)]
 pub struct Simple {
@@ -61,7 +61,7 @@ impl BotAlgo for Simple {
         }
         .update()
         .ok();
-        info!("target={:?}", self.path.as_ref().map(|a| a.1));
+        debug!("target={:?}", self.path.as_ref().map(|a| a.1));
 
         BotInput::default()
     }
@@ -125,20 +125,25 @@ impl SimpleContext<'_> {
             .find(|(_, t)| t.kind == tile)
             .map(|(p, _)| *p)
     }
-    fn find_empty_interactable_tile(&self) -> Option<IVec2> {
-        if let Some(t) = self
-            .game
+    fn find_empty_interactable_tile_by_name(&self, name: &str) -> Option<IVec2> {
+        self.game
             .tiles
             .iter()
             .find(|(_, t)| {
                 self.game.data.tile_interact[t.kind.0]
                     && t.item.is_none()
-                    && self.game.data.tile_names[t.kind.0] == "counter"
+                    && self.game.data.tile_names[t.kind.0] == name
             })
             .map(|(p, _)| *p)
-        {
+    }
+    fn find_empty_interactable_tile(&self) -> Option<IVec2> {
+        if let Some(t) = self.find_empty_interactable_tile_by_name("counter") {
+            return Some(t);
+        }
+        if let Some(t) = self.find_empty_interactable_tile_by_name("counter-window") {
             return Some(t);
         }
+        warn!("all counters filled up");
         self.game
             .tiles
             .iter()
@@ -153,7 +158,8 @@ impl SimpleContext<'_> {
             .unwrap_or(true)
     }
     fn clear_tile(&mut self, pos: IVec2) -> LogicRes {
-        self.dispose_hand()?;
+        debug!("clear tile {pos}");
+        self.assert_hand_is_clear()?;
         self.interact_with(pos, 0.)
     }
     fn assert_tile_is_clear(&mut self, pos: IVec2) -> LogicRes {
@@ -162,35 +168,40 @@ impl SimpleContext<'_> {
         }
         Ok(())
     }
+    fn assert_hand_is_clear(&mut self) -> LogicRes {
+        if self.is_hand_occupied() {
+            self.dispose_hand()?;
+        }
+        Ok(())
+    }
 
-    pub fn dispose_hand(&mut self) -> LogicRes<IVec2> {
+    pub fn dispose_hand(&mut self) -> LogicRes {
+        debug!("dispose hand");
         if let Some(pos) = self.find_empty_interactable_tile() {
-            if let Err(()) = self.interact_with(pos, 0.) {
-                return Ok(pos);
-            } else {
-                warn!("no path to empty space ");
-                Err(())
-            }
+            self.interact_with(pos, 0.)?;
+            warn!("no path to empty space ");
+            Err(())
         } else {
             warn!("no empty space left");
             Err(())
         }
     }
     pub fn aquire_placed_item(&mut self, item: ItemIndex) -> LogicRes<IVec2> {
+        debug!("aquire placed item {:?}", self.game.data.item_names[item.0]);
         if let Some(pos) = self.find_item_on_map(item) {
             return Ok(pos);
         }
         self.aquire_item(item)?;
-        self.dispose_hand()
+        self.dispose_hand()?;
+        Err(())
     }
     pub fn aquire_item(&mut self, item: ItemIndex) -> LogicRes {
+        debug!("aquire item {:?}", self.game.data.item_names[item.0]);
         if self.is_hand_item(item) {
             return Ok(());
         }
-        if self.is_hand_occupied() {
-            self.dispose_hand()?;
-        }
         if let Some(pos) = self.find_item_on_map(item) {
+            self.assert_hand_is_clear()?;
             self.interact_with(pos, 0.)?;
             return Ok(());
         }
@@ -204,6 +215,7 @@ impl SimpleContext<'_> {
                 } => {
                     if let Some(pos) = self.find_tile(*tile) {
                         self.assert_tile_is_clear(pos)?;
+                        self.assert_hand_is_clear()?;
                         self.interact_with(pos, 0.)?;
                     }
                 }
@@ -248,7 +260,8 @@ impl SimpleContext<'_> {
                     if let Some(pos) = self.find_tile(*tile) {
                         if let Some(item) = &self.game.tiles.get(&pos).unwrap().item {
                             if item.kind == *input {
-                                info!("waiting for passive to finish at {pos}");
+                                debug!("waiting for passive to finish at {pos}");
+                                self.state.cooldown = 0.5;
                                 return Err(()); // waiting for it to finish
                                                 // TODO check progress
                             }
@@ -261,7 +274,8 @@ impl SimpleContext<'_> {
                     tile: None, input, ..
                 } => {
                     self.aquire_placed_item(*input)?;
-                    info!("waiting for passive to finish");
+                    debug!("waiting for passive to finish");
+                    self.state.cooldown = 0.5;
                     return Err(());
                 }
                 _ => warn!("recipe too hard {r:?}"),