bot.py

@@ -20,7 +20,7 @@ from minecraft.networking.connection import Connection
 from minecraft.networking.packets import Packet, clientbound, serverbound
 
 from protocol.managers import DataManager, ChunksManager, ChatManager, ChunkNotLoadedException
-from protocol.packets import TimeUpdatePacket, SetSlotPacket
+from protocol.packets import BlockChangePacket
 
 from bunch import Bunch
 from panda3d.core import LPoint3f, LVector3f
@@ -185,27 +185,18 @@ def bot(global_state):
 
     g.chunks.register(g.connection)
 
-    def x(p):
-        print(p)
+    h1 = packet_wrapper(packet_handlers.handle_join_game)
+    g.connection.register_packet_listener(h1, clientbound.play.JoinGamePacket)
 
-    h = packet_wrapper(packet_handlers.handle_block_change)
-    g.connection.register_packet_listener(h, clientbound.play.BlockChangePacket)
+    h2 = packet_wrapper(packet_handlers.handle_position_and_look)
+    g.connection.register_packet_listener(h2, clientbound.play.PlayerPositionAndLookPacket)
 
-    h = packet_wrapper(packet_handlers.handle_join_game)
-    g.connection.register_packet_listener(h, clientbound.play.JoinGamePacket)
-
-    h = packet_wrapper(packet_handlers.handle_position_and_look)
-    g.connection.register_packet_listener(h, clientbound.play.PlayerPositionAndLookPacket)
+    h3 = packet_wrapper(packet_handlers.handle_block_change)
+    g.connection.register_packet_listener(h3, BlockChangePacket)
 
     g.chat = ChatManager(g)
-    h = packet_wrapper(packet_handlers.handle_chat)
-    g.chat.set_handler(h)
-
-    h = packet_wrapper(packet_handlers.handle_time_update)
-    g.connection.register_packet_listener(h, TimeUpdatePacket)
-
-    h = packet_wrapper(packet_handlers.handle_set_slot)
-    g.connection.register_packet_listener(h, SetSlotPacket)
+    h4 = packet_wrapper(packet_handlers.handle_chat)
+    g.chat.set_handler(h4)
 
     try:
         while not g.pos:

main.py

@@ -18,7 +18,6 @@ g.local_state = False
 g.connection = False
 g.mcdata = False
 g.pos = False
-g.inv = {}
 
 @app.route('/')
 def hello_world():
@@ -55,7 +54,6 @@ def main():
                 print('Locking...')
                 while g.running:
                     time.sleep(1)
-                importlib.reload(bot)
     except KeyboardInterrupt:
         observer.stop()
     observer.join()

monkey_patch.py

@@ -8,13 +8,8 @@ def get_packets(old_get_packets):
 
         # 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.TimeUpdatePacket)
-        mc_packets.add(packets.PlayerDiggingPacket)
-        mc_packets.add(packets.PickItemPacket)
-        mc_packets.add(packets.HeldItemChangePacket)
+        mc_packets.add(packets.BlockChangePacket)
+        mc_packets.add(packets.MultiBlockChangePacket)
 
         return mc_packets
     return lambda x: wrapper(old_get_packets, x)

packet_handlers.py

@@ -97,15 +97,3 @@ def handle_chat(message, g):
     if reply:
         print(reply)
         g.chat.send(reply)
-
-def handle_time_update(packet, g):
-    l = g.local_state
-    l.time = packet.time_of_day % 24000
-
-def handle_set_slot(packet, g):
-    print(packet)
-    if packet.window_id == 0:
-        g.inv[packet.slot] = packet.slot_data
-
-
-

protocol/managers.py

@@ -43,13 +43,12 @@ class ChunksManager:
 
     def handle_block(self, block_packet):
         self.set_block_at(block_packet.location.x, block_packet.location.y, block_packet.location.z, block_packet.block_state_id)
+        #self.print_chunk(self.get_chunk(floor(block_packet.location.x/16), floor(block_packet.location.y/16), floor(block_packet.location.z/16)), block_packet.location.y%16)
+        #print('Block %s at %s'%(blocks_states[block_packet.block_state_id], block_packet.location))
 
     def handle_multiblock(self, multiblock_packet):
-        dx = 16 * multiblock_packet.chunk_section_pos.x
-        dy = 16 * multiblock_packet.chunk_section_pos.y
-        dz = 16 * multiblock_packet.chunk_section_pos.z
         for b in multiblock_packet.records:
-            self.set_block_at(dx+b.x, dy+b.y, dz+b.z, b.block_state_id)
+            self.handle_block(b)
 
     def handle_chunk(self, chunk_packet):
         for i in chunk_packet.chunks:
@@ -57,8 +56,8 @@ class ChunksManager:
         self.biomes[(chunk_packet.x, None, chunk_packet.z)] = chunk_packet.biomes # FIXME
 
     def register(self, connection):
-        connection.register_packet_listener(self.handle_block, clientbound.play.BlockChangePacket)
-        connection.register_packet_listener(self.handle_multiblock, clientbound.play.MultiBlockChangePacket)
+        connection.register_packet_listener(self.handle_block, packets.BlockChangePacket)
+        connection.register_packet_listener(self.handle_multiblock, packets.MultiBlockChangePacket)
         connection.register_packet_listener(self.handle_chunk, packets.ChunkDataPacket)
 
     def get_chunk(self, x, y, z):

protocol/packets.py

@@ -2,12 +2,123 @@ from math import floor
 
 from minecraft.networking.packets import Packet, PacketBuffer
 from minecraft.networking.types import (
-    VarInt, Integer, UnsignedByte, Position, Vector, MutableRecord,
-    attribute_alias, multi_attribute_alias, Long, Boolean, VarLong,
-    Short, UnsignedLong, Byte, BlockFace,
+    VarInt, Integer, Boolean, UnsignedByte, Long, Short,
+    multi_attribute_alias, Vector, UnsignedLong
 )
 
-from protocol.types import Nbt, Slot
+from protocol.types import Nbt
+from minecraft.networking.packets import Packet
+from minecraft.networking.types import (
+    VarInt, Integer, UnsignedByte, Position, Vector, MutableRecord,
+    attribute_alias, multi_attribute_alias, Long, Boolean, VarLong,
+)
+
+
+class BlockChangePacket(Packet):
+    id = 0x0B
+    packet_name = 'block change'
+    definition = [
+        {'location': Position},
+        {'block_state_id': VarInt}]
+    block_state_id = 0
+
+    # For protocols < 347: an accessor for (block_state_id >> 4).
+    @property
+    def blockId(self):
+        return self.block_state_id >> 4
+
+    @blockId.setter
+    def blockId(self, block_id):
+        self.block_state_id = (self.block_state_id & 0xF) | (block_id << 4)
+
+    # For protocols < 347: an accessor for (block_state_id & 0xF).
+    @property
+    def blockMeta(self):
+        return self.block_state_id & 0xF
+
+    @blockMeta.setter
+    def blockMeta(self, meta):
+        self.block_state_id = (self.block_state_id & ~0xF) | (meta & 0xF)
+
+    # This alias is retained for backward compatibility.
+    blockStateId = attribute_alias('block_state_id')
+
+
+class MultiBlockChangePacket(Packet):
+    id = 0x3B
+    packet_name = 'multi block change'
+
+    fields = 'chunk_x', 'chunk_z', 'records'
+
+    # Access the 'chunk_x' and 'chunk_z' fields as a tuple.
+    chunk_pos = multi_attribute_alias(tuple, 'chunk_x', 'chunk_z')
+
+    class Record(MutableRecord):
+        __slots__ = 'x', 'y', 'z', 'block_state_id', 'location'
+
+        def __init__(self, **kwds):
+            self.block_state_id = 0
+            super(MultiBlockChangePacket.Record, self).__init__(**kwds)
+
+        # Access the 'x', 'y', 'z' fields as a Vector of ints.
+        position = multi_attribute_alias(Vector, 'x', 'y', 'z')
+
+        # For protocols < 347: an accessor for (block_state_id >> 4).
+        @property
+        def blockId(self):
+            return self.block_state_id >> 4
+
+        @blockId.setter
+        def blockId(self, block_id):
+            self.block_state_id = self.block_state_id & 0xF | block_id << 4
+
+        # For protocols < 347: an accessor for (block_state_id & 0xF).
+        @property
+        def blockMeta(self):
+            return self.block_state_id & 0xF
+
+        @blockMeta.setter
+        def blockMeta(self, meta):
+            self.block_state_id = self.block_state_id & ~0xF | meta & 0xF
+
+        # This alias is retained for backward compatibility.
+        blockStateId = attribute_alias('block_state_id')
+
+        def read(self, file_object, parent):
+            data = VarLong.read(file_object)
+            self.block_state_id = int(data >> 12)
+            self.x = int(data >> 8 & 0xf)
+            self.z = int(data >> 4 & 0xf)
+            self.y = int(data & 0xf)
+            # Absolute position in world to be compatible with BlockChangePacket
+            self.location = Vector(self.position.x + parent.chunk_x*16, self.position.y, self.position.z + parent.chunk_z*16)
+
+        def write(self, packet_buffer):
+            raise
+            UnsignedByte.send(self.x << 4 | self.z & 0xF, packet_buffer)
+            UnsignedByte.send(self.y, packet_buffer)
+            VarInt.send(self.block_state_id, packet_buffer)
+
+    def read(self, file_object):
+        coords = Long.read(file_object)
+        self.chunk_x = int(coords >> 42 & 0x3fffff)
+        self.chunk_z = int(coords >> 20 & 0x3fffff)
+        self.chunk_y = int(coords & 0xfffff)
+        self.unknown = Boolean.read(file_object)
+        array_size = VarInt.read(file_object)
+        self.records = []
+        for i in range(array_size):
+            record = self.Record()
+            record.read(file_object, self)
+            self.records.append(record)
+
+    def write_fields(self, packet_buffer):
+        raise
+        Integer.send(self.chunk_x, packet_buffer)
+        Integer.send(self.chunk_z, packet_buffer)
+        VarInt.send(len(self.records), packet_buffer)
+        for record in self.records:
+            record.write(packet_buffer)
 
 
 class ChunkDataPacket(Packet):
@@ -65,7 +176,9 @@ class ChunkDataPacket(Packet):
             y = e['y']
             self.chunks[floor(y/16)].entities.append(e)
 
+
 class Chunk:
+
     position = multi_attribute_alias(Vector, 'x', 'y', 'z')
 
     def __init__(self, x, y, z, empty=True):
@@ -133,87 +246,3 @@ class Chunk:
     def origin(self):
         return self.position*16
 
-
-class AcknowledgePlayerDiggingPacket(Packet):
-    id = 0x07
-    packet_name = 'acknowledge player digging'
-    definition = [
-        {'location': Position},
-        {'block': VarInt},
-        {'status': VarInt},
-        {'successful': Boolean},
-    ]
-
-
-class BlockBreakAnimationPacket(Packet):
-    id = 0x08
-    packet_name = 'block break animation'
-    definition = [
-        {'entity_id': VarInt},
-        {'location': Position},
-        {'destroy_stage': Byte},
-    ]
-
-
-class SetSlotPacket(Packet):
-    id = 0x15
-    packet_name = 'set slot'
-    definition = [
-        {'window_id': Byte},
-        {'slot': Short},
-        {'slot_data': Slot},
-    ]
-
-
-class TimeUpdatePacket(Packet):
-    id = 0x4E
-    packet_name = 'time update'
-    definition = [
-        {'world_age': Long},
-        {'time_of_day': Long},
-    ]
-
-
-class PlayerDiggingPacket(Packet):
-    # used when player mines / breaks blocks
-    # https://wiki.vg/Protocol#Player_Digging
-
-    id = 0x1B
-    packet_name = 'player digging'
-
-    definition = [
-        {'status': VarInt},
-        {'location': Position},
-        {'face': VarInt},
-    ]
-
-    STARTED = 0
-    CANCELLED = 1
-    FINISHED = 2
-
-    # PlayerBlockPlacementPacket.Face is an alias for BlockFace.
-    Face = BlockFace
-
-
-class PickItemPacket(Packet):
-    # used when player picks item (middle click)
-    # https://wiki.vg/Protocol#Pick_Item
-
-    id = 0x18
-    packet_name = 'pick item'
-
-    definition = [
-        {'slot_to_use': VarInt},
-    ]
-
-
-class HeldItemChangePacket(Packet):
-    # Sent when the player changes the slot selection
-    # https://wiki.vg/Protocol#Held_Item_Change_.28serverbound.29
-
-    id = 0x25
-    packet_name = 'held item change'
-
-    definition = [
-        {'slot': Short},
-    ]

protocol/types.py

@@ -1,12 +1,11 @@
 from __future__ import division
 
+from minecraft.networking.types.basic import Type, Byte, Short, Integer, Long, Float, Double, ShortPrefixedByteArray
+
 import struct
 
-from minecraft.networking.types.basic import (
-    Type, Byte, Short, Integer, Long, Float, Double,
-    ShortPrefixedByteArray, Boolean, VarInt, TrailingByteArray
-)
 from minecraft.networking.types.utility import Vector
+from minecraft.networking.types.basic import Type, Byte, Short, Integer, Long, Float, Double, ShortPrefixedByteArray
 
 
 class IntegerPrefixedByteArray(Type):
@@ -20,7 +19,6 @@ class IntegerPrefixedByteArray(Type):
         Integer.send(len(value), socket)
         socket.send(value)
 
-
 TAG_End = 0
 TAG_Byte = 1
 TAG_Short = 2
@@ -98,36 +96,3 @@ class Nbt(Type):
     def send(value, socket):
         # TODO
         pass
-
-
-class Slot(Type):
-    def __init__(self, present, item_id, item_count, nbt):
-        self.present = present
-        self.item_id = item_id
-        self.item_count = item_count
-        self.nbt = nbt
-
-    def __str__(self):
-        return str(self.__dict__)
-    def __repr__(self):
-        return 'Slot(present={}, item_id={}, item_count={}, nbt={}'.format(
-            self.present, self.item_id, self.item_count, self.nbt)
-
-    @staticmethod
-    def read(file_object):
-        present = Boolean.read(file_object)
-        item_id = VarInt.read(file_object) if present else None
-        item_count = Byte.read(file_object) if present else None
-        nbt = TrailingByteArray.read(file_object) if present else None
-        return Slot(present, item_id, item_count, nbt)
-        #a = {}
-        #a['present'] = Boolean.read(file_object)
-        #a['item_id'] = VarInt.read(file_object) if a['present'] else None
-        #a['item_count'] = Byte.read(file_object) if a['present'] else None
-        #a['nbt'] = TrailingByteArray.read(file_object) if a['present'] else None
-        #return a
-
-    @staticmethod
-    def send(value, socket):
-        # TODO
-        pass