Don't sleep near monsters

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, force=True)
+    g.connection.write_packet(packet)
 
     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, 10):
+        for a in self.find_blocks_3d(center, [0], distance, 50):
             # check for air around the area
             if len(self.find_blocks(a, clear_distance, [0], bed_clearance)) < bed_clearance:
                 continue
@@ -163,6 +163,11 @@ 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):
@@ -343,6 +348,7 @@ class Game:
                 if solution:
                     solution = list(solution)
                     self.g.path = solution
+                    if self.g.job:
                         self.g.job.stop()
                     print(len(solution))
                     print(solution)

jobs.py

@@ -906,8 +906,9 @@ 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(p, blocks.BREAK_DISTANCE):
+        for l in w.find_leaves(pos, blocks.BREAK_DISTANCE):
             self.leaves.append(l)
 
         self.state = self.break_leaves
@@ -1121,7 +1122,7 @@ class FillBlocksStates:
             return
 
         if self.last_block:
-            self.state = self.select_block
+            self.state = self.select_item
         else:
             self.state = self.find_last_block
 
@@ -1131,14 +1132,15 @@ 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)
 
-        self.next_block = f.coord1
-
-        for offset in utils.search_3d(distance):
+        for y in range(y_start, y_end+1):
+            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
                 if check[0] < b1[0] or check[0] > b2[0]:
@@ -1147,12 +1149,12 @@ class FillBlocksStates:
                     continue
 
                 if w.block_at(*check) == blocks.AIR:
-                self.state = self.select_block
+                    self.state = self.select_item
                     return
 
                 self.last_block = check
 
-    def select_block(self):
+    def select_item(self):
         f = self.g.filling
         name = blocks.BLOCKS[f.block]
         item = items.ITEMS['minecraft:'+name]['protocol_id']
@@ -1175,21 +1177,14 @@ class FillBlocksStates:
         y_start = f.coord1[1]
         y_end = f.coord2[1]
 
-        print('distance', xz_distance)
-
         for y in range(y_start, y_end+1):
-            for i in count():
-                offset = utils.spiral(i)
-                check = utils.padd(self.last_block, offset)
+            if y not in self.iterators:
+                self.iterators[y] = utils.search_2d(xz_distance)
+
+            for offset in self.iterators[y]:
+                check = utils.padd(f.coord1, 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
@@ -1245,22 +1240,19 @@ 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
 
     def check_obstruction(self):
@@ -1303,6 +1295,7 @@ 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 packets here
+        # add any custom CLIENTBOUND 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.PickItemPacket)
-        mc_packets.add(packets.HeldItemChangePacket)
+        #mc_packets.add(packets.PlayerDiggingPacket)
+        #mc_packets.add(packets.PickItemPacket)
+        #mc_packets.add(packets.HeldItemChangePacket)
         mc_packets.add(packets.OpenWindowPacket)
-        mc_packets.add(packets.CloseWindowPacket)
-        mc_packets.add(packets.ClickWindowPacket)
+        #mc_packets.add(packets.CloseWindowPacket)
+        #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,6 +26,7 @@ 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,6 +107,33 @@ 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 [