Add state machine for caching items into chests

jobs.py

@@ -310,7 +310,7 @@ class SleepWithBedStates:
             self.state = self.select_bed
 
     def select_bed(self):
-        if self.game.select_item(items.BED_IDS):
+        if self.g.game.select_item(items.BED_IDS):
             self.g.look_at = utils.padd(self.area, path.BLOCK_BELOW)
             self.state = self.place_bed
         else:
@@ -372,32 +372,148 @@ class SleepWithBedStates:
         self.state()
 
 
-class JobStates:
+class CacheItemsStates:
     def idle(self):
         return None
 
-    def sleep_with_bed(self):
-        s = self.sleep_with_bed_states
-        if s.state == s.idle:
-            s.state = s.init
-        elif s.state == s.done:
-            s.state = s.init
-            # check time, etc
+    def init(self):
+        #if len(self.g.inv) >= 27:
+        if len(self.g.inv) >= 2:
+            self.state = self.find_chest_spot
+        else:
+            print('Aborting caching, not full')
+            self.state = self.cleanup
 
-            if self.prev_state:
-                print('Reverting to prev state')
-                self.state = self.prev_state
-                return
+    def find_cache_spot(self):
+        print('Finding a chest spot...')
+        w = self.g.world
+        p = utils.pint(self.g.pos)
 
-        s.run()
+        areas = w.find_cache_areas(p, 100)
+        print('Found areas:', areas)
+
+        if len(areas):
+            while areas[0] in self.bad_areas:
+                areas.pop(0)
+            self.area = areas[0]
+        elif self.last_area:
+            self.area = self.last_area
+        else:
+            print('Unable to find area, and no last area')
+            self.state = self.cleanup
+            return
+
+        openings = w.find_bed_openings(self.area)
+
+        for o in openings:
+            navpath = w.path_to_place(p, o)
+            self.opening = o
+            if navpath: break
+        else: # for
+            print('Unable to get to cache area', self.area)
+            self.bad_areas.append(self.area)
+            self.state = self.cleanup
+            return
+
+        self.g.path = navpath
+        self.state = self.going_to_area
+        self.last_area = self.area
+
+    def going_to_area(self):
+        if utils.pint(self.g.pos) == self.opening:
+            self.g.look_at = self.area
+            self.state = self.select_chest
+
+    def select_chest(self):
+        if self.g.game.select_item(items.CHEST_ID):
+            self.g.look_at = utils.padd(self.area, path.BLOCK_BELOW)
+            self.state = self.place_chest
+        else:
+            self.g.chat.send('I need a chest')
+            self.state = self.cleanup
+
+    def place_chest(self):
+        self.g.game.place_block(self.area, BlockFace.TOP)
+        self.state = self.open_chest
+
+    def open_chest(self):
+        print('Opening chest')
+        self.g.game.open_container(self.area)
+        self.wait_time = 1
+        self.state = self.wait
+
+    def wait(self):
+        # wait for server to send us chest contents
+        if self.wait_time > 0:
+            self.wait_time -= utils.TICK
+        else:
+            self.state = self.move_items
+
+    def move_items(self):
+        if self.g.item_lock: return
+
+        w = self.g.window
+        w_data = data.WINDOWS[w.window_type]
+        w_inventory_slots = w_data.inventory
+
+        for slot_num in w_inventory_slots:
+            if slot_num not in w.contents:
+                continue
+
+            slot = w.contents[slot_num]
+
+            if slot.item_id in items.USEFUL_ITEMS:
+                continue
+
+            print('moving', slot)
+
+            inv_slot_num = slot_num - w_data.slot_diff
+            self.g.inv.pop(inv_slot_num, None)
+
+            self.g.item_lock = True
+            self.g.game.click_window(w.window_id, slot_num, 0, 1, slot)
+            return
+
+        print('nothing left to move')
+        self.state = close_chest
+
+    def close_chest(self):
+        print('closing chest')
+        self.g.game.close_window()
+        self.state = self.cleanup
+
+    def cleanup(self):
+        self.g.look_at = None
+        self.state = self.done
+
+    def done(self):
+        # never gets ran, placeholder
+        return None
+
+    def __init__(self, global_state):
+        self.g = global_state
+        self.state = self.idle
+
+        self.area = None
+        self.opening = None
+        self.bad_areas = []
+        self.last_area = None
+        self.wait_time = 0
+
+    def run(self):
+        self.state()
+
+
+class JobStates:
+    def idle(self):
+        return None
 
     def gather_sand(self):
         s = self.gather_sand_states
         if s.state == s.idle:
             s.state = s.init
         elif s.state == s.done:
-            s.state = s.init
-            # check time, etc
+            #s.state = s.init
 
             self.prev_state = self.gather_sand
             self.state = self.sleep_with_bed
@@ -406,23 +522,35 @@ class JobStates:
         s.run()
 
     def lumberjack(self):
-        s = self.lumberjack_states
-        if s.state == s.idle:
-            s.state = s.init
-        elif s.state == s.done:
-            s.state = s.init
-            # check time, etc
+        s1 = self.lumberjack_states
+        s2 = self.sleep_with_bed_states
+        s3 = self.cache_items_states
 
-            self.prev_state = self.lumberjack
-            self.state = self.sleep_with_bed
+        if s1.state == s1.idle:
+            s1.state = s1.init
+            s2.state = s2.init
+            s3.state = s3.init
+        elif s1.state == s1.done:
+            if s2.state != s2.done:
+                s2.run()
+                return
+
+            if s3.state != s3.done:
+                s3.run()
+                return
+
+            s1.state = s1.init
+            s2.state = s2.init
+            s3.state = s3.init
             return
 
-        s.run()
+        s1.run()
 
     def stop(self):
         self.lumberjack_states = LumberjackStates(self.g)
         self.gather_sand_states = GatherSandStates(self.g)
         self.sleep_with_bed_states = SleepWithBedStates(self.g)
+        self.cache_items_states = CacheItemsStates(self.g)
         self.state = self.idle
 
     def __init__(self, global_state):
@@ -433,6 +561,7 @@ class JobStates:
         self.lumberjack_states = LumberjackStates(self.g)
         self.gather_sand_states = GatherSandStates(self.g)
         self.sleep_with_bed_states = SleepWithBedStates(self.g)
+        self.cache_items_states = CacheItemsStates(self.g)
 
     def tick(self):
         self.state()