import os from math import floor import json import time from minecraft.networking.packets import clientbound, serverbound from mosfet.protocol import packets from mosfet import utils from mosfet.info import blocks 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 class ChunksManager: def __init__(self, data_manager): self.data = data_manager self.chunks = {} #self.biomes = {} self.index = {} self.loading = False 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) 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) def handle_chunk(self, chunk_packet): for i in chunk_packet.chunks: chunk = chunk_packet.chunks[i] self.chunks[(chunk_packet.x, i, chunk_packet.z)] = chunk if chunk.sub_index: dx = chunk.x * 16 dy = chunk.y * 16 dz = chunk.z * 16 for item_id, locations in chunk.sub_index.items(): if item_id not in self.index: self.index[item_id] = set() for l in locations: coords = (dx + l%16, dy + l//256, dz + l%256//16) self.index[item_id].add(coords) #self.biomes[(chunk_packet.x, None, chunk_packet.z)] = chunk_packet.biomes # FIXME if self.loading: print('.', end='', flush=True) 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_chunk, packets.ChunkDataPacket) def get_chunk(self, x, y, z): index = (x, y, z) if not index in self.chunks: return None #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)) if not c: return None 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)) if not c: return None c.set_block_at(x%16, y%16, z%16, block) if block in blocks.INDEXED_IDS: if block not in self.index: self.index[block] = set() self.index[block].add((x, y, z)) def check_loaded(self, chunk_distance): num = (chunk_distance * 2 + 1) ** 2 num_subchunks = num * 16 return len(self.chunks) >= num_subchunks def unload_chunk(self, x, z): for y in range(16): try: del self.chunks[(x, y, z)] except KeyError: pass def unload_all_chunks(self): self.chunks = {} self.index = {} 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]) class ChatManager: def __init__(self, global_state): self.g = global_state self.handler = None self.g.connection.register_packet_listener(self.print_chat, clientbound.play.ChatMessagePacket) def translate_chat(self, data): if isinstance(data, str): return data result = data.get('text', '') result += data.get('translate', '') if 'with' in data: result += ' ' + ' '.join([self.translate_chat(x) for x in data['with']]) elif 'extra' in data: result += ''.join([self.translate_chat(x) for x in data['extra']]) return result def print_chat(self, chat_packet): #print(chat_packet) #print(chat_packet.json_data) #import json #print(json.dumps(json.loads(chat_packet.json_data), indent=4)) try: source = chat_packet.field_string('position') sender = chat_packet.sender text = self.translate_chat(json.loads(chat_packet.json_data)) print('[%s] %s'%(source, text)) except Exception as ex: print('Exception %r on message (%s): %s' % (ex, chat_packet.field_string('position'), chat_packet.json_data)) return if self.handler: self.handler((source, sender, text)) def set_handler(self, func): self.handler = func def send(self, text): if not text: # Prevents connection bug when sending empty chat message return packet = serverbound.play.ChatPacket() packet.message = text self.g.connection.write_packet(packet)