bot.py

@@ -173,7 +173,7 @@ def tick(global_state):
         g.pitch += utils.cap(target_pitch_d, 10)
 
     packet = serverbound.play.PositionAndLookPacket(x=p.x, feet_y=p.y, z=p.z, pitch=g.pitch, yaw=g.yaw, on_ground=(not in_air))
-    g.connection.write_packet(packet)
+    g.connection.write_packet(packet, force=True)
 
     g.game.tick()
     g.job.tick()

game.py

@@ -150,7 +150,7 @@ class MCWorld:
         bed_clearance = 25  # 5x5 area
         clear_distance = 3
 
-        for a in self.find_blocks_3d(center, [0], distance, 50):
+        for a in self.find_blocks_3d(center, [0], distance, 10):
             # check for air around the area
             if len(self.find_blocks(a, clear_distance, [0], bed_clearance)) < bed_clearance:
                 continue
@@ -163,11 +163,6 @@ class MCWorld:
             if len(self.find_blocks(utils.padd(a, path.BLOCK_ABOVE), clear_distance, [0], bed_clearance)) < bed_clearance:
                 continue
 
-            # ensure there's no monsters within 20 blocks
-            # can't sleep if they are within 10, good to have a buffer
-            if self.find_monsters(a, 20):
-                continue
-
             yield a
 
     def find_cache_areas(self, center, distance):
@@ -348,8 +343,7 @@ class Game:
                 if solution:
                     solution = list(solution)
                     self.g.path = solution
-                    if self.g.job:
+                    self.g.job.stop()
-                        self.g.job.stop()
                     print(len(solution))
                     print(solution)
                     print(round(time.time() - start, 3), 'seconds')

jobs.py

@@ -906,9 +906,8 @@ class ClearLeavesStates:
     def find_leaves(self):
         w = self.g.world
         p = utils.pint(self.g.pos)
-        pos = utils.padd(p, path.BLOCK_ABOVE)
 
-        for l in w.find_leaves(pos, blocks.BREAK_DISTANCE):
+        for l in w.find_leaves(p, blocks.BREAK_DISTANCE):
             self.leaves.append(l)
 
         self.state = self.break_leaves
@@ -1122,7 +1121,7 @@ class FillBlocksStates:
             return
 
         if self.last_block:
-            self.state = self.select_item
+            self.state = self.select_block
         else:
             self.state = self.find_last_block
 
@@ -1132,29 +1131,28 @@ class FillBlocksStates:
         print('Finding last block')
 
         b1, b2 = utils.pboundingbox(f.coord1, f.coord2)
-        box = utils.psub(b2, b1)
-        xz_distance = hypot(box[0]+1, box[2]+1)
         y_start = f.coord1[1]
         y_end = f.coord2[1]
+        distance = utils.phyp(f.coord1, f.coord2)
 
-        for y in range(y_start, y_end+1):
+        self.next_block = f.coord1
-            for offset in utils.search_2d(xz_distance):
-                check = utils.padd(f.coord1, offset)
-                check = (check[0], y, check[2])
 
-                # ensure block is within fill area
+        for offset in utils.search_3d(distance):
-                if check[0] < b1[0] or check[0] > b2[0]:
+            check = utils.padd(f.coord1, offset)
-                    continue
-                if check[2] < b1[2] or check[2] > b2[2]:
-                    continue
 
-                if w.block_at(*check) == blocks.AIR:
+            # ensure block is within fill area
-                    self.state = self.select_item
+            if check[0] < b1[0] or check[0] > b2[0]:
-                    return
+                continue
+            if check[2] < b1[2] or check[2] > b2[2]:
+                continue
 
-                self.last_block = check
+            if w.block_at(*check) == blocks.AIR:
+                self.state = self.select_block
+                return
 
-    def select_item(self):
+            self.last_block = check
+
+    def select_block(self):
         f = self.g.filling
         name = blocks.BLOCKS[f.block]
         item = items.ITEMS['minecraft:'+name]['protocol_id']
@@ -1177,14 +1175,21 @@ class FillBlocksStates:
         y_start = f.coord1[1]
         y_end = f.coord2[1]
 
-        for y in range(y_start, y_end+1):
+        print('distance', xz_distance)
-            if y not in self.iterators:
-                self.iterators[y] = utils.search_2d(xz_distance)
 
-            for offset in self.iterators[y]:
+        for y in range(y_start, y_end+1):
-                check = utils.padd(f.coord1, offset)
+            for i in count():
+                offset = utils.spiral(i)
+                check = utils.padd(self.last_block, offset)
                 check = (check[0], y, check[2])
 
+                print('layer', y)
+                print('offset', offset)
+                print('hypot', hypot(offset[0], offset[2]))
+
+                if hypot(offset[0], offset[2]) > xz_distance:
+                    break
+
                 # ensure block is within fill area
                 if check[0] < b1[0] or check[0] > b2[0]:
                     continue
@@ -1240,20 +1245,23 @@ class FillBlocksStates:
 
         self.g.game.place_block(self.next_block, BlockFace.TOP)
         self.g.look_at = self.next_block
-
         self.wait_time = 0.25
         self.state = self.wait_for_block
 
     def wait_for_block(self):
+        if self.wait_time > 0:
+            self.wait_time -= utils.TICK
+        else:
+            self.state = self.check_block
+
+    def check_block(self):
         w = self.g.world
         if w.block_at(*self.next_block) != blocks.AIR:
             self.last_block = self.next_block
-            self.state = self.check_obstruction
-        elif self.wait_time > 0:
-            self.wait_time -= utils.TICK
         else:
             print('Block didnt appear')
-            self.state = self.check_obstruction
+
+        self.state = self.check_obstruction
 
     def check_obstruction(self):
         p = utils.pint(self.g.pos)
@@ -1295,7 +1303,6 @@ class FillBlocksStates:
         self.g = global_state
         self.state = self.idle
 
-        self.iterators = {}
         self.wait_time = 0
         self.last_block = None
         self.next_block = None

monkey_patch.py

@@ -6,19 +6,19 @@ def get_packets(old_get_packets):
         print('Monkey-patch worked.')
         mc_packets = func(context)
 
-        # add any custom CLIENTBOUND packets here
+        # add any custom packets here
         mc_packets.add(packets.ChunkDataPacket)
         mc_packets.add(packets.AcknowledgePlayerDiggingPacket)
         mc_packets.add(packets.BlockBreakAnimationPacket)
         mc_packets.add(packets.SetSlotPacket)
-        #mc_packets.add(packets.PlayerDiggingPacket)
+        mc_packets.add(packets.PlayerDiggingPacket)
-        #mc_packets.add(packets.PickItemPacket)
+        mc_packets.add(packets.PickItemPacket)
-        #mc_packets.add(packets.HeldItemChangePacket)
+        mc_packets.add(packets.HeldItemChangePacket)
         mc_packets.add(packets.OpenWindowPacket)
-        #mc_packets.add(packets.CloseWindowPacket)
+        mc_packets.add(packets.CloseWindowPacket)
-        #mc_packets.add(packets.ClickWindowPacket)
+        mc_packets.add(packets.ClickWindowPacket)
         mc_packets.add(packets.ClientWindowConfirmationPacket)
-        #mc_packets.add(packets.ServerWindowConfirmationPacket)
+        mc_packets.add(packets.ServerWindowConfirmationPacket)
         mc_packets.add(packets.EntityMetadataPacket)
         mc_packets.add(packets.SpawnLivingEntityPacket)
         mc_packets.add(packets.EntityPositionRotationPacket)
@@ -26,7 +26,6 @@ def get_packets(old_get_packets):
         #mc_packets.add(packets.EntityActionPacket)
         mc_packets.add(packets.SpawnPlayerPacket)
 
-
         return mc_packets
     return lambda x: wrapper(old_get_packets, x)
 

utils.py

@@ -107,33 +107,6 @@ def break_time(block_id, held_item=0, in_water=False, on_ground=True, enchantmen
 
     return time
 
-def search_2d(distance=0):
-    def get_neighbors(x,y,z):
-        return [
-            (x+1, y+0, z+0),
-            #(x+1, y+0, z+1),
-            (x+0, y+0, z-1),
-            #(x-1, y+0, z+1),
-            (x-1, y+0, z+0),
-            #(x-1, y+0, z-1),
-            (x+0, y+0, z+1),
-            #(x+1, y+0, z-1),
-        ]
-
-    to_visit = collections.deque([(0, 0, 0)])
-    visited = set()
-
-    while to_visit:
-        cur = to_visit.pop()
-        if cur in visited:
-            continue
-        if distance and hypot(*cur) > distance:
-            continue
-        for neighbor in get_neighbors(*cur):
-            to_visit.appendleft(neighbor)
-        visited.add(cur)
-        yield cur
-
 def search_3d(distance=0, y_limit=0):
     def get_neighbors(x,y,z):
         return [