.gitignore

@@ -101,5 +101,3 @@ ENV/
 # Editor
 *.swp
 *.swo
-
-mcdata/

custom/managers/__init__.py

@@ -1,2 +0,0 @@
-from .data import DataManager
-from .chunks import ChunksManager

custom/managers/chunks.py

@@ -1,97 +0,0 @@
-from math import floor
-
-from ..networking.packets.clientbound.play import block_change_packet, chunk_data
-
-class ChunksManager:
-
-    def __init__(self, data_manager):
-        self.data = data_manager
-        self.chunks = {}
-        self.biomes = {}
-        
-    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):
-        for b in multiblock_packet.records:
-            self.handle_block(b)
-
-    def handle_chunk(self, chunk_packet):
-        for i in chunk_packet.chunks:
-            self.chunks[(chunk_packet.x, i, chunk_packet.z)] = chunk_packet.chunks[i]        
-        self.biomes[(chunk_packet.x, None, chunk_packet.z)] = chunk_packet.biomes # FIXME
-
-    def register(self, connection):
-        connection.register_packet_listener(self.handle_block, block_change_packet.BlockChangePacket)
-        connection.register_packet_listener(self.handle_multiblock, block_change_packet.MultiBlockChangePacket)
-        connection.register_packet_listener(self.handle_chunk, chunk_data.ChunkDataPacket)
-
-    def get_chunk(self, x, y, z):
-        index = (x, y, z)
-        if not index in self.chunks:
-            raise ChunkNotLoadedException(index)
-        return self.chunks[index]
-
-    def get_loaded_area(self, ignore_empty=False):
-        first = next(iter(self.chunks.keys()))
-        x0 = x1 = first[0]
-        y0 = y1 = first[1]
-        z0 = z1 = first[2]
-        for k in self.chunks.keys():
-            if ignore_empty and self.chunks[k].empty:
-                continue
-            x0 = min(x0, k[0])
-            x1 = max(x1, k[0])
-            y0 = min(y0, k[1])
-            y1 = max(y1, k[1])
-            z0 = min(z0, k[2])
-            z1 = max(z1, k[2])
-        return ((x0,y0,z0),(x1,y1,z1))
-
-    def get_block_at(self, x, y, z):
-        c = self.get_chunk(floor(x/16), floor(y/16), floor(z/16))
-        return c.get_block_at(x%16, y%16, z%16)
-
-    def set_block_at(self, x, y, z, block):
-        c = self.get_chunk(floor(x/16), floor(y/16), floor(z/16))
-        c.set_block_at(x%16, y%16, z%16, block)
-
-    def print_chunk(self, chunk, y_slice):
-        print("This is chunk %d %d %d at slice %d:"%(chunk.x, chunk.y, chunk.z, y_slice))
-        print("+%s+"%("-"*16))
-        for z in range(16):
-            missing = []
-            print("|", end="")
-            for x in range(16):
-                sid = chunk.get_block_at(x, y_slice, z)
-                bloc = self.data.blocks_states[sid]
-                if bloc == "minecraft:air" or bloc == "minecraft:cave_air":
-                    c = " "
-                elif bloc == "minecraft:grass_block" or bloc == "minecraft:dirt":
-                    c = "-"
-                elif bloc == "minecraft:water":
-                    c = "~"
-                elif bloc == "minecraft:lava":
-                    c = "!"
-                elif bloc == "minecraft:bedrock":
-                    c = "_"
-                elif bloc == "minecraft:stone":
-                    c = "X"
-                else:
-                    missing.append(bloc)
-                    c = "?"
-
-                print(c, end="")
-            print("|  %s"%(",".join(missing)))
-        print("+%s+"%("-"*16))
-        if chunk.entities:
-            print("Entities in slice: %s"%(", ".join([x['id'].decode() for x in chunk.entities])))
-
-
-class ChunkNotLoadedException(Exception):
-    def __str__(self):
-        pos = self.args[0]
-        return "Chunk at %d %d %d not loaded (yet?)"%(pos[0], pos[1], pos[2])
-

custom/managers/data.py

@@ -1,32 +0,0 @@
-import os
-import json
-
-class DataManager:
-
-    def __init__(self, directory):
-        self.blocks = {}
-        self.blocks_states = {}
-        self.blocks_properties = {}
-        self.registries = {}
-        self.biomes = {}
-        self.entity_type = {}
-        
-        if not os.path.isdir(directory):
-            raise FileNotFoundError("%s is not a valid directory")
-
-        if not os.path.isfile("%s/registries.json"%(directory)):
-            raise FileNotFoundError("%s is not a valid minecraft data directory")
-        
-        with open("%s/blocks.json"%(directory)) as f:
-            blocks = json.loads(f.read())
-        for x in blocks:
-            for s in blocks[x]['states']:
-                self.blocks_states[s['id']] = x
-                self.blocks_properties[s['id']] = s.get('properties', {})
-
-        with open("%s/registries.json"%(directory)) as f:
-            registries = json.loads(f.read())
-        #for x in registries["minecraft:biome"]["entries"]:
-        #    self.biomes[registries["minecraft:biome"]["entries"][x]["protocol_id"]] = x
-        for x in registries["minecraft:entity_type"]["entries"]:
-            self.entity_type[registries["minecraft:entity_type"]["entries"][x]["protocol_id"]] = x

custom/networking/packets/clientbound/play/block_change_packet.py

@@ -1,122 +0,0 @@
-from minecraft.networking.packets import Packet
-from minecraft.networking.types import (
-    VarInt, Integer, UnsignedByte, Position, Vector, MutableRecord,
-    attribute_alias, multi_attribute_alias,
-)
-
-
-class BlockChangePacket(Packet):
-    @staticmethod
-    def get_id(context):
-        return 0x0C if context.protocol_version >= 550 else \
-               0x0B if context.protocol_version >= 332 else \
-               0x0C if context.protocol_version >= 318 else \
-               0x0B if context.protocol_version >= 67 else \
-               0x24 if context.protocol_version >= 62 else \
-               0x23
-
-    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):
-    @staticmethod
-    def get_id(context):
-        return 0x10 if context.protocol_version >= 550 else \
-               0x0F if context.protocol_version >= 343 else \
-               0x10 if context.protocol_version >= 332 else \
-               0x11 if context.protocol_version >= 318 else \
-               0x10 if context.protocol_version >= 67 else \
-               0x22
-
-    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):
-            h_position = UnsignedByte.read(file_object)
-            self.x, self.z = h_position >> 4, h_position & 0xF
-            self.y = UnsignedByte.read(file_object)
-            self.block_state_id = VarInt.read(file_object)
-            # 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):
-            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):
-        self.chunk_x = Integer.read(file_object)
-        self.chunk_z = Integer.read(file_object)
-        records_count = VarInt.read(file_object)
-        self.records = []
-        for i in range(records_count):
-            record = self.Record()
-            record.read(file_object, self)
-            self.records.append(record)
-
-    def write_fields(self, packet_buffer):
-        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)

custom/networking/packets/clientbound/play/chunk_data.py

@@ -1,139 +0,0 @@
-from math import floor
-
-from minecraft.networking.packets import Packet, PacketBuffer
-from minecraft.networking.types import (
-    VarInt, Integer, Boolean, UnsignedByte, Long, Short,
-    multi_attribute_alias, Vector, UnsignedLong
-)
-
-from ....types import nbt
-
-class ChunkDataPacket(Packet):
-    @staticmethod
-    def get_id(context):
-        return 0x22 # FIXME
-
-    packet_name = 'chunk data'
-    fields = 'x', 'bit_mask_y', 'z', 'full_chunk'
-
-    def read(self, file_object):
-        self.x = Integer.read(file_object)
-        self.z = Integer.read(file_object)
-        self.full_chunk = Boolean.read(file_object)
-        self.bit_mask_y = VarInt.read(file_object)
-        self.heightmaps = Nbt.read(file_object)
-        self.biomes = []
-        if self.full_chunk:
-            for i in range(1024):
-                self.biomes.append(Integer.read(file_object))
-        size = VarInt.read(file_object)
-        self.data = file_object.read(size)
-        size_entities = VarInt.read(file_object)
-        self.entities = []
-        for i in range(size_entities):
-            self.entities.append(Nbt.read(file_object))
-
-        self.decode_chunk_data()
-
-    def write_fields(self, packet_buffer):
-        Integer.send(self.x, packet_buffer)
-        Integer.send(self.z, packet_buffer)
-        Boolean.send(self.full_chunk, packet_buffer)
-        VarInt.send(self.bit_mask_y, packet_buffer)
-        Nbt.send(self.heightmaps, packet_buffer)
-        if self.full_chunk:
-            for i in range(1024):
-                Integer.send(self.biomes[i], packet_buffer)
-        VarInt.send(len(self.data), packet_buffer)
-        packet_buffer.send(self.data)
-        VarInt.send(len(self.entities), packet_buffer)
-        for e in self.entities:
-            Nbt.send(e, packet_buffer)
-
-    def decode_chunk_data(self):
-        packet_data = PacketBuffer()
-        packet_data.send(self.data)
-        packet_data.reset_cursor()
-
-        self.chunks = {}
-        for i in range(16): #0-15
-            self.chunks[i] = Chunk(self.x, i, self.z)
-            if self.bit_mask_y & (1 << i):
-                self.chunks[i].read(packet_data)
-        
-        for e in self.entities:
-            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):
-        self.x = x
-        self.y = y
-        self.z = z
-        self.empty = empty
-        self.entities = []
-
-    def __repr__(self):
-        return 'Chunk(%r, %r, %r)' % (self.x, self.y, self.z)
-
-    def read(self, file_object):
-        self.empty = False
-        self.block_count = Short.read(file_object)
-        self.bpb = UnsignedByte.read(file_object)
-        if self.bpb <= 4:
-            self.bpb = 4
-
-        if self.bpb <= 8: # Indirect palette
-            self.palette = []
-            size = VarInt.read(file_object)
-            for i in range(size):
-                self.palette.append(VarInt.read(file_object))
-        else: # Direct palette
-            self.palette = None
-
-        size = VarInt.read(file_object)
-        longs = []
-        for i in range(size):
-            longs.append(UnsignedLong.read(file_object))
-
-        self.blocks = []
-        mask = (1 << self.bpb)-1
-        for i in range(4096):
-            l1 = int((i*self.bpb)/64)
-            offset = (i*self.bpb)%64
-            l2 = int(((i+1)*self.bpb-1)/64)
-            n = longs[l1] >> offset
-            if l2>l1:
-                n |= longs[l2] << (64-offset)
-            n &= mask
-            if self.palette:
-                n = self.palette[n]
-            self.blocks.append(n)
-
-    def write_fields(self, packet_buffer):
-        pass # TODO
-
-    def get_block_at(self, x, y, z):
-        if self.empty:
-            return 0
-        return self.blocks[x+y*256+z*16]
-
-    def set_block_at(self, x, y, z, block):
-        if self.empty:
-            self.init_empty()
-        self.blocks[x+y*256+z*16] = block
-
-    def init_empty(self):
-        self.blocks = []
-        for i in range(4096):
-            self.blocks.append(0)
-        self.empty = False
-
-    @property
-    def origin(self):
-        return self.position*16
-

custom/networking/types/basic.py

@@ -1,12 +0,0 @@
-from minecraft.networking.types.basic import Type, Byte, Short, Integer, Long, Float, Double, ShortPrefixedByteArray
-
-class IntegerPrefixedByteArray(Type):
-    @staticmethod
-    def read(file_object):
-        length = Integer.read(file_object)
-        return struct.unpack(str(length) + "s", file_object.read(length))[0]
-
-    @staticmethod
-    def send(value, socket):
-        Integer.send(len(value), socket)
-        socket.send(value)

custom/networking/types/nbt.py

@@ -1,95 +0,0 @@
-"""Contains definition for minecraft's NBT format.
-"""
-from __future__ import division
-import struct
-
-from minecraft.networking.types.utility import Vector
-from minecraft.networking.types.basic import Type, Byte, Short, Integer, Long, Float, Double, ShortPrefixedByteArray
-
-from .basic import IntegerPrefixedByteArray
-
-__all__ = (
-    'Nbt',
-)
-
-TAG_End = 0
-TAG_Byte = 1
-TAG_Short = 2
-TAG_Int = 3
-TAG_Long = 4
-TAG_Float = 5
-TAG_Double = 6
-TAG_Byte_Array = 7
-TAG_String = 8
-TAG_List = 9
-TAG_Compound = 10
-TAG_Int_Array = 11
-TAG_Long_Array = 12
-
-
-class Nbt(Type):
-
-    @staticmethod
-    def read(file_object):
-        type_id = Byte.read(file_object)
-        if type_id != TAG_Compound:
-            raise Exception("Invalid NBT header")
-        name = ShortPrefixedByteArray.read(file_object).decode('utf-8')
-        a = Nbt.decode_tag(file_object, TAG_Compound)
-        a['_name'] = name
-        return a
-
-    @staticmethod
-    def decode_tag(file_object, type_id):
-        if type_id == TAG_Byte:
-            return Byte.read(file_object)
-        elif type_id == TAG_Short:
-            return Short.read(file_object)
-        elif type_id == TAG_Int:
-            return Integer.read(file_object)
-        elif type_id == TAG_Long:
-            return Long.read(file_object)
-        elif type_id == TAG_Float:
-            return Float.read(file_object)
-        elif type_id == TAG_Double:
-            return Double.read(file_object)
-        elif type_id == TAG_Byte_Array:
-            return IntegerPrefixedByteArray.read(file_object).decode('utf-8')
-        elif type_id == TAG_String:
-            return ShortPrefixedByteArray.read(file_object)
-        elif type_id == TAG_List:
-            list_type_id = Byte.read(file_object)
-            size = Integer.read(file_object)
-            a = []
-            for i in range(size):
-                a.append(Nbt.decode_tag(file_object, list_type_id))
-            return a
-        elif type_id == TAG_Compound:
-            c = { }
-            child_type_id = Byte.read(file_object)
-            while child_type_id != TAG_End:
-                child_name = ShortPrefixedByteArray.read(file_object).decode('utf-8')
-                c[child_name] = Nbt.decode_tag(file_object, child_type_id)
-                child_type_id = Byte.read(file_object)
-            return c
-        elif type_id == TAG_Int_Array:
-            size = Integer.read(file_object)
-            a = []
-            for i in range(size):
-                a.append(Integer.read(file_object))
-            return a
-        elif type_id == TAG_Long_Array:
-            size = Integer.read(file_object)
-            a = []
-            for i in range(size):
-                a.append(Long.read(file_object))
-            return a
-        else:
-            raise Exception("Invalid NBT tag type")
-
-    @staticmethod
-    def send(value, socket):
-        # TODO
-        pass
-
-

download_mcdata.sh

@@ -1,10 +0,0 @@
-#!/bin/sh
-
-VERSION="1.16.2"
-
-wget -O/tmp/mcdata.zip https://apimon.de/mcdata/$VERSION/$VERSION.zip
-rm -rf mcdata
-mkdir mcdata
-unzip /tmp/mcdata.zip -d mcdata
-rm /tmp/mcdata.zip
-

old/requirements.txt

@@ -1,3 +0,0 @@
-cryptography>=1.5
-requests
-future

old/start.py

@@ -1,140 +0,0 @@
-#!/usr/bin/env python
-
-from __future__ import print_function
-
-import threading
-import importlib
-
-import getpass
-import sys
-import os
-import re
-import time
-from optparse import OptionParser
-
-import bot
-
-from minecraft import authentication
-from minecraft.exceptions import YggdrasilError
-from minecraft.networking.connection import Connection
-from minecraft.networking.packets import Packet, clientbound, serverbound
-from minecraft.compat import input
-
-
-get_mod_time = lambda: os.path.getmtime('bot.py')
-
-class PlayerInfo:
-    eid = None
-    pos = None
-    inv = {}
-    mcdata = None
-    chunks = None
-
-
-player_info = PlayerInfo()
-
-
-def get_options():
-    parser = OptionParser()
-
-    parser.add_option("-u", "--username", dest="username", default=None,
-                      help="username to log in with")
-
-    parser.add_option("-p", "--password", dest="password", default=None,
-                      help="password to log in with")
-
-    parser.add_option("-s", "--server", dest="server", default=None,
-                      help="server host or host:port "
-                           "(enclose IPv6 addresses in square brackets)")
-
-    parser.add_option("-o", "--offline", dest="offline", action="store_true",
-                      help="connect to a server in offline mode "
-                           "(no password required)")
-
-    parser.add_option("-d", "--dump-packets", dest="dump_packets",
-                      action="store_true",
-                      help="print sent and received packets to standard error")
-
-    (options, args) = parser.parse_args()
-
-    if not options.username:
-        options.username = input("Enter your username: ")
-
-    if not options.password and not options.offline:
-        options.password = getpass.getpass("Enter your password (leave "
-                                           "blank for offline mode): ")
-        options.offline = options.offline or (options.password == "")
-
-    if not options.server:
-        options.server = input("Enter server host or host:port "
-                               "(enclose IPv6 addresses in square brackets): ")
-    # Try to split out port and address
-    match = re.match(r"((?P<host>[^\[\]:]+)|\[(?P<addr>[^\[\]]+)\])"
-                     r"(:(?P<port>\d+))?$", options.server)
-    if match is None:
-        raise ValueError("Invalid server address: '%s'." % options.server)
-    options.address = match.group("host") or match.group("addr")
-    options.port = int(match.group("port") or 25565)
-
-    return options
-
-
-def main():
-    global last_mod_time
-
-    options = get_options()
-
-    if options.offline:
-        print("Connecting in offline mode...")
-        connection = Connection(
-            options.address, options.port, username=options.username)
-    else:
-        auth_token = authentication.AuthenticationToken()
-        try:
-            auth_token.authenticate(options.username, options.password)
-        except YggdrasilError as e:
-            print(e)
-            sys.exit()
-        print("Logged in as %s..." % auth_token.username)
-        connection = Connection(
-            options.address, options.port, auth_token=auth_token)
-
-    if options.dump_packets:
-        def print_incoming(packet):
-            if type(packet) is Packet:
-                # This is a direct instance of the base Packet type, meaning
-                # that it is a packet of unknown type, so we do not print it.
-                return
-            print('--> %s' % packet, file=sys.stderr)
-
-        def print_outgoing(packet):
-            print('<-- %s' % packet, file=sys.stderr)
-
-        connection.register_packet_listener(
-            print_incoming, Packet, early=True)
-        connection.register_packet_listener(
-            print_outgoing, Packet, outgoing=True)
-
-
-    connection.connect()
-
-    while True:
-        try:
-            importlib.reload(bot)
-            bot.main(connection, player_info)
-
-        except KeyboardInterrupt:
-            print("Bye!")
-            sys.exit()
-        except BaseException as e:
-            import traceback
-            print(traceback.format_exc())
-
-            last_mod_time = get_mod_time()
-            print('locking')
-            while get_mod_time() == last_mod_time:
-                time.sleep(0.1)
-
-
-if __name__ == "__main__":
-    main()

requirements.txt

@@ -1,11 +1,3 @@
-certifi==2020.6.20
-cffi==1.14.2
-chardet==3.0.4
-cryptography==3.1
-idna==2.10
-pycparser==2.20
-pyCraft @ git+https://github.com/ammaraskar/pyCraft.git@cf93923acc2dcfbc076379b43842228d77aea188
-PyNBT==3.0.0
-requests==2.24.0
-six==1.15.0
-urllib3==1.25.10
+cryptography>=1.5
+requests
+future

start.py

@@ -1,16 +1,37 @@
 #!/usr/bin/env python
 
+from __future__ import print_function
+
+import threading
+import importlib
+
 import getpass
 import sys
+import os
 import re
+import time
 from optparse import OptionParser
 
+import bot
+
 from minecraft import authentication
 from minecraft.exceptions import YggdrasilError
 from minecraft.networking.connection import Connection
 from minecraft.networking.packets import Packet, clientbound, serverbound
+from minecraft.compat import input
 
-from custom.managers import DataManager, ChunksManager
+
+get_mod_time = lambda: os.path.getmtime('bot.py')
+
+class PlayerInfo:
+    eid = None
+    pos = None
+    inv = {}
+    mcdata = None
+    chunks = None
+
+
+player_info = PlayerInfo()
 
 
 def get_options():
@@ -34,10 +55,6 @@ def get_options():
                       action="store_true",
                       help="print sent and received packets to standard error")
 
-    parser.add_option("-v", "--dump-unknown-packets", dest="dump_unknown",
-                      action="store_true",
-                      help="include unknown packets in --dump-packets output")
-
     (options, args) = parser.parse_args()
 
     if not options.username:
@@ -63,9 +80,9 @@ def get_options():
 
 
 def main():
-    options = get_options()
+    global last_mod_time
 
-    mcdata = DataManager('./mcdata')
+    options = get_options()
 
     if options.offline:
         print("Connecting in offline mode...")
@@ -86,12 +103,9 @@ def main():
         def print_incoming(packet):
             if type(packet) is Packet:
                 # This is a direct instance of the base Packet type, meaning
-                # that it is a packet of unknown type, so we do not print it
-                # unless explicitly requested by the user.
-                if options.dump_unknown:
-                    print('--> [unknown packet] %s' % packet, file=sys.stderr)
-            else:
-                print('--> %s' % packet, file=sys.stderr)
+                # that it is a packet of unknown type, so we do not print it.
+                return
+            print('--> %s' % packet, file=sys.stderr)
 
         def print_outgoing(packet):
             print('<-- %s' % packet, file=sys.stderr)
@@ -101,39 +115,25 @@ def main():
         connection.register_packet_listener(
             print_outgoing, Packet, outgoing=True)
 
-    def handle_join_game(join_game_packet):
-        print('Connected.')
-
-    connection.register_packet_listener(
-        handle_join_game, clientbound.play.JoinGamePacket)
-
-    def print_chat(chat_packet):
-        print("Message (%s): %s" % (
-            chat_packet.field_string('position'), chat_packet.json_data))
-
-    chunks = ChunksManager(mcdata)
-    chunks.register(connection)
-
-    connection.register_packet_listener(
-        print_chat, clientbound.play.ChatMessagePacket)
 
     connection.connect()
 
     while True:
         try:
-            text = input()
-            if text == "/respawn":
-                print("respawning...")
-                packet = serverbound.play.ClientStatusPacket()
-                packet.action_id = serverbound.play.ClientStatusPacket.RESPAWN
-                connection.write_packet(packet)
-            else:
-                packet = serverbound.play.ChatPacket()
-                packet.message = text
-                connection.write_packet(packet)
+            importlib.reload(bot)
+            bot.main(connection, player_info)
+
         except KeyboardInterrupt:
             print("Bye!")
             sys.exit()
+        except BaseException as e:
+            import traceback
+            print(traceback.format_exc())
+
+            last_mod_time = get_mod_time()
+            print('locking')
+            while get_mod_time() == last_mod_time:
+                time.sleep(0.1)
 
 
 if __name__ == "__main__":