def setup_connection(address, port, version, auth_token, state, username=None): connection = Connection( address, port, auth_token=auth_token, initial_version=version, username=username, handle_exception=partial(handle_exception, state=state), ) print_timestamped(f"Connecting to {address}:{port}") # Cast rod on join connection.register_packet_listener(partial(handle_join_game, state=state), clientbound.play.JoinGamePacket) # Reel in and recast rod on bobber splash connection.register_packet_listener( partial(handle_sound_play, state=state), clientbound.play.SoundEffectPacket) if state["sleep_helper"]: # Disconnect for a while when people need to sleep connection.register_packet_listener(partial(handle_chat, state=state), clientbound.play.ChatMessagePacket) # Handle disconnects connection.register_packet_listener(partial(handle_dc, state=state), clientbound.play.DisconnectPacket) connection.register_packet_listener(partial(handle_dc, state=state), clientbound.login.DisconnectPacket) return connection
def main(): options = get_options() auth_token = authentication.AuthenticationToken() try: auth_token.authenticate(options.username, options.password) except YggdrasilError as e: print(e) sys.exit() print("Logged in as " + auth_token.username) connection = Connection(options.address, options.port, auth_token) connection.connect() def print_chat(chat_packet): print("Position: " + str(chat_packet.position)) print("Data: " + chat_packet.json_data) connection.register_packet_listener(print_chat, ChatMessagePacket) while True: try: text = input() packet = ChatPacket() packet.message = text connection.write_packet(packet) except KeyboardInterrupt: print("Bye!") sys.exit()
def startChat(update, context): usr = "******" + str(update.message.from_user.first_name) connection = Connection("ioya.de", username=usr) context.user_data["connection"] = connection id = update.effective_chat.id def handle_join_game(join_game_packet): print("handle_join_Game") context.bot.send_message(chat_id=id, text='Connected to Corona Land.') connection.register_packet_listener(handle_join_game, clientbound.play.JoinGamePacket) def print_chat(chat_packet): msg = json.loads(chat_packet.json_data) translate = msg["translate"] if translate == "chat.type.text": name = msg["with"][0]["text"] content = msg["with"][1]["text"] if name != usr: context.bot.send_message(chat_id=update.effective_chat.id, text="%s: %s" % (name, content)) connection.register_packet_listener(print_chat, clientbound.play.ChatMessagePacket) connection.connect() return SENDMESSAGE
def main(): options = get_options() auth_token = authentication.AuthenticationToken() try: auth_token.authenticate(options.username, options.password) except YggdrasilError as e: print(e) sys.exit() connection = Connection(options.address, options.port, auth_token) connection.connect() print("Logged in as " + auth_token.username) s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind(("", 9001)) s.listen(5) connection.register_packet_listener(print_chat, ChatMessageClientboundPacket) #send_message("GET http://www.google.com/ HTTP/1.1\r\nhost: www.google.com\r\n\r\n", "address", connection) #GET http://www.uga.edu/ HTTP/1.1\r\nHost: www.uga.edu\r\n #time.sleep(100) #sys.exit() while True: try: (conn, addr) = s.accept() print("got packet") data = conn.recv(8192) send_message(data, addr, connection) except KeyboardInterrupt: sys.exit() s.close()
def main(): options = get_options() auth_token = authentication.AuthenticationToken() try: auth_token.authenticate(options.username, options.password) except YggdrasilError as e: print(e) sys.exit() connection = Connection(options.address, options.port, auth_token) connection.connect() print("Logged in as " + auth_token.username) s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.bind(("", 9001)) s.listen(5) connection.register_packet_listener(print_chat, ChatMessageClientboundPacket) #send_message("GET http://www.google.com/ HTTP/1.1\r\nhost: www.google.com\r\n\r\n", "address", connection) #GET http://www.uga.edu/ HTTP/1.1\r\nHost: www.uga.edu\r\n #time.sleep(100) #sys.exit() while True: try: (conn, addr) = s.accept() print("got packet") data = conn.recv(8192) send_message(data, addr, connection) except KeyboardInterrupt: sys.exit() s.close()
def main(): options = get_options() auth_token = authentication.AuthenticationToken() try: auth_token.authenticate(options.username, options.password) except YggdrasilError as e: print(e) sys.exit() print("Logged in as " + auth_token.username) connection = Connection(options.address, options.port, auth_token) connection.connect() def print_chat(chat_packet): print("Position: " + str(chat_packet.position)) print("Data: " + chat_packet.json_data) connection.register_packet_listener(print_chat, ChatMessagePacket) while True: try: text = input() packet = ChatPacket() packet.message = text connection.write_packet(packet) except KeyboardInterrupt: print("Bye!") sys.exit()
class MinecraftBot(): def __init__(self, username, server, port, commands): self.username = username self.server = server self.port = port self.commands = commands self.bot = Connection(server, port, username=username, allowed_versions=[47]) self.bot.register_packet_listener(self.handle_join_game, clientbound.play.JoinGamePacket) log("INFO", "Trying to connect {0} to {1}:{2}.".format(username, server, port)) self.bot.connect() threading.Thread(target=self.execute_go, args=["/go"], daemon=True).start() def execute_go(self, command): time.sleep(15) self.execute_command(command) def handle_join_game(self, join_game_packet): log("INFO", "{0} is connected to {1}:{2}.".format(self.username, self.server, self.port)) time.sleep(3) self.execute_command(self.commands[0]) def execute_command(self, command): log("INFO", "{0} is doing command {1}".format(self.username, command)) packet = serverbound.play.ChatPacket() packet.message = command self.bot.write_packet(packet) def disconnect(self): log("INFO", "Disconnecting {0} from {1}:{2}.".format(self.username, self.server, self.port)) self.bot.disconnect() log("INFO", "{0} is disconnected of {1}:{2}.".format(self.username, self.server, self.port))
def main(): config = read_config() # split port and host match = re.match( r"((?P<host>[^\[\]:]+)|\[(?P<addr>[^\[\]]+)\])" r"(:(?P<port>\d+))?$", config["server"]) if match is None: raise ValueError(f"Invalid server address: '{config['server']}'") address = match.group("host") or match.group("addr") port = int(match.group("port") or 25565) auth_token = authentication.AuthenticationToken() try: auth_token.authenticate(config["username"], config["password"]) except YggdrasilError as e: print(e) sys.exit() print(f"Authenticated successfully as {auth_token.username}") connection = Connection(address, port, auth_token=auth_token) def handle_goodbye(signum, frame): print("Signing out!") payload = { 'username': config["username"], 'password': config["password"] } try: authentication._make_request(authentication.AUTH_SERVER, "signout", payload) except: print("Failed to sign out with Yggdrasil") finally: sys.exit() def handle_disconnect(): print("Disconnected from server") if config["reconnect"] == True: connection.connect() else: sys.exit() connection.register_packet_listener( lambda packet: print(f"Connected to {address}!"), clientbound.play.JoinGamePacket) connection.register_packet_listener(handle_disconnect, clientbound.login.DisconnectPacket) try: connection.connect() except Exception as err: print(err) print("Failed to connect to specified server") sys.exit() signal.signal(signal.SIGINT, handle_goodbye) while True: time.sleep(1)
class Main(object): def __init__(self, options): self.auth_token = authentication.AuthenticationToken() try: self.auth_token.authenticate(options.username, options.password) except YggdrasilError as e: print(e) sys.exit() print("Logged in as " + self.auth_token.username) self.network = Connection(options.address, options.port, self.auth_token) self.network.connect() self.register_listeners() #sys.stdout = Speaker(self) while not self.network.playing: pass self.respawn() while True: try: self.tick() except KeyboardInterrupt: print("Bye!") sys.exit() def register_listeners(self): self.network.register_packet_listener(self.print_chat, ChatMessagePacket) self.network.register_packet_listener(self.set_pos, PlayerPositionAndLookPacket) self.network.register_packet_listener(self.recieve_plugin_message, PluginMessage) self.network.register_packet_listener(self.set_health, UpdateHealth) def tick(self): text = input() self.speak(text) def speak(self, message): packet = ChatPacket() packet.message = message self.network.write_packet(packet) def set_health(self, health_packet): if health_packet.health == 0.0: print "RESPAWN" self.respawn() def respawn(self): packet = ClientStatus() packet.action_id = 0 self.network.write_packet(packet) #print packet def print_chat(self, chat_packet): print type(chat_packet) print("Position: " + str(chat_packet.position)) print("Data: " + chat_packet.json_data) def recieve_plugin_message(self, plugin_message): data = plugin_message.data.split("|") if len(data) == 2 and data[0] == "MC": if data[1] == "Brand": print "Brand:", plugin_message.channel else: print "PLUGIN MESSAGE:", data[1], plugin_message.channel
def ServerWakeUp(): connection = Connection("ioya.de", username="******") 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)) connection.register_packet_listener(print_chat, clientbound.play.ChatMessagePacket) connection.connect() sleep(2)
def main(): username = '******' # connection = Connection(address, port, username='******'.format(random.randint(0, 1000))) connection = Connection(address, port, username=username) bot = Bot(connection, username) def print_outgoing(packet): if type(packet) is not my_svbnd_play.DiggingPacket: print('<-- %s' % packet, file=sys.stderr) connection.register_packet_listener( bot.process_packet, Packet) connection.register_packet_listener( print_outgoing, Packet, outgoing=True) def handle_join_game(join_game_packet, early=True): print('Connected.') connection.register_packet_listener( handle_join_game, clientbound.play.JoinGamePacket) connection.connect() while True: # making a loop try: # used try so that if user pressed other than the given key error will not be shown a = input() except Exception as e: # print(e) pass #
def main(): authenticate(MINECRAFT_USERNAME, MINECRAFT_PASSWORD) connection = Connection(SERVER_IP, 25565, auth_token=auth_token) connection.register_packet_listener(packet_handler.handle_join_game, packets.JoinGamePacket) # Lambda function is used to inject the connection so the handle_chat function can also send chat packets. # That's important for AFK connection.register_packet_listener( lambda chat_packet: packet_handler.handle_chat( chat_packet, connection), packets.ChatMessagePacket) connection.register_packet_listener(packet_handler.handle_player_list, packets.PlayerListItemPacket) connection.connect() # Allows user to enter chat messages in the terminal and we'll send them. # Sometimes needed to run /l bedwars. while True: try: text = input() packet = serverbound.play.ChatPacket() packet.message = text connection.write_packet(packet) except KeyboardInterrupt: print("Exiting bedwars bot.") sys.exit()
def main(): 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 " + auth_token.username) connection = Connection( options.address, options.port, auth_token=auth_token) connection.connect() def print_chat(chat_packet): print("Position: " + str(chat_packet.position)) print("Data: " + chat_packet.json_data) connection.register_packet_listener(print_chat, ChatMessagePacket) while True: try: text = input() if text == "/respawn": print("respawning...") packet = ClientStatusPacket() packet.action_id = ClientStatusPacket.RESPAWN connection.write_packet(packet) else: packet = ChatPacket() packet.message = text connection.write_packet(packet) except KeyboardInterrupt: print("Bye!") sys.exit()
def main(): options = get_options() def handle_exception(*args): print('handle exception') os.kill(os.getpid(), signal.SIGINT) if options.offline: print("Connecting in offline mode...") connection = Connection(options.address, options.port, username=options.username, handle_exception=handle_exception, handle_exit=handle_exception) 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) 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)) connection.register_packet_listener(print_chat, clientbound.play.ChatMessagePacket) connection.connect() def send(text): print("sending", text) packet = serverbound.play.ChatPacket() packet.message = text connection.write_packet(packet) time.sleep(10) send("/server main") # time.sleep(3) # send("Hello world! I'm online!") while connection.connected: try: time.sleep(10) send("/server main") # text = input() # if text == "/respawn": # print("respawning...") # packet = serverbound.play.ClientStatusPacket() # packet.action_id = serverbound.play.ClientStatusPacket.RESPAWN # connection.write_packet(packet) # else: # send(text) except KeyboardInterrupt: send("Bye!") print("Bye!") time.sleep(5) sys.exit()
def main(): 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) once = False def handle_join_game(join_game_packet): message_queue.append(("CONNECTION", "**Connected**")) once = True print('Connected.') connection.register_packet_listener( handle_join_game, clientbound.play.JoinGamePacket) def print_chat(chat_packet): print("[%s]: %s" % ( chat_packet.field_string('position'), parse_chat_item(json.loads(chat_packet.json_data)))) connection.register_packet_listener( print_chat, clientbound.play.ChatMessagePacket) # Add a deque for chat messages and register a method to get them message_queue = deque() def forward_chat(chat_packet): msg = parse_chat_item(json.loads(chat_packet.json_data)) if msg.startswith("<"): author, message = parse_message(msg) if (author != auth_token.username and message != ""): # Don't put in queue your own messages! message_queue.append((author, message)) connection.register_packet_listener( forward_chat, clientbound.play.ChatMessagePacket) # More maybe? Add here shit for a chatbot # Auto respawn because we can't send chat while dead def auto_respawn(update_health_packet): if update_health_packet.health <= 0: print("Respawning") packet = serverbound.play.ClientStatusPacket() packet.action_id = serverbound.play.ClientStatusPacket.RESPAWN connection.write_packet(packet) connection.register_packet_listener( auto_respawn, clientbound.play.UpdateHealthPacket) # Start the discord thread and provide the message deque botThread = DiscordBotThread(message_queue, connection) botThread.daemon = True botThread.start() 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) except KeyboardInterrupt: print("Bye!") sys.exit()
print(e) sys.exit() with open('minecraft.auth', 'w') as fout: fout.write(auth_token.client_token + '\n') fout.write(auth_token.access_token) print("Logged in as %s..." % auth_token.username) connection = Connection("localhost", 25565, auth_token=auth_token) 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)) # connection.register_packet_listener( # print_chat, clientbound.play.ChatMessagePacket) # global connected # connected = True # def disconnect(disconnect_packet): # print("You were disconnected: %s" % disconnect_packet.json_data) # global connected # connected = False
packet = minecraft.networking.packets.serverbound.play.UseItemPacket() packet.hand = 0 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) def handle_join_game(join_game_packet): print('Connected.') def print_chat(chat_packet): # TODO 聊天信息正常化 #print(chat_packet.json_data) decode = json.loads(chat_packet.json_data)
def main() -> int: # Handle program arguments ap = argparse.ArgumentParser( prog="mchat", description="A console chat client for most Minecraft server versions") ap.add_argument("server_address", help="IP address of a Minecraft server") ap.add_argument("-p", "--port", help="Minecraft server port (default: %(default)s)", type=int, default=25565) ap.add_argument("-u", "--username", help="Minecraft username or email") ap.add_argument( "-v", "--version", help="Client -> Server protocol version to use (default: %(default)s)", default="1.16.4") args = ap.parse_args() # Verify server version to keep the terminal looking clean if args.version not in SUPPORTED_MINECRAFT_VERSIONS.keys(): console.print( f"[bold yellow]{args.version} is not a valid Minecraft version. Versions from {list(SUPPORTED_MINECRAFT_VERSIONS.keys())[0]} to {list(SUPPORTED_MINECRAFT_VERSIONS.keys())[-1]} are allowed." ) return 1 # Do authentication if not args.username: username = Prompt.ask("Username or email") else: username = args.username password = getpass.getpass("Password: "******"[bright_black]Loaded authentication information") # Determine the actual protocol version number protocol_version_num = SUPPORTED_MINECRAFT_VERSIONS[args.version] console.print( f"[bright_black]Selecting protocol version {protocol_version_num}") # Authenticate with Mojang auth_token = AuthenticationToken() console.print(f"[bright_black]Contacting Yggdrasil...") try: auth_token.authenticate(username, password) except YggdrasilError as e: console.print(f"[bold red]Failed to authenticate Minecraft session") return 1 # Open a connection server_connection = Connection(args.server_address, args.port, auth_token, allowed_versions=[protocol_version_num]) try: server_connection.connect() except: console.print(f"[bold red]Could not connect to server") return 1 # Set up an incoming chat handler server_connection.register_packet_listener(incomingChatHandler, ChatMessagePacket) console.print(f"[bright_black]Listen to incoming chat packets") # Set up input loop console.print( "All further inputs will be sent to server chat. Press CTRL+C to stop") try: while True: # Get a line from the user chat_message = console.input() # Send the chat message packet = serverbound.play.ChatPacket() packet.message = chat_message server_connection.write_packet(packet) except KeyboardInterrupt as e: print("\rGoodbye") return 0
class Minecraft(): def __init__(self, username, password=None, server=None, versions=("1.12.2", "1.12.2"), auto_connect=False): self.username = username self.password = password self.server = server self.versions = versions self.event = lambda x: print(x) self.auth_token = authentication.AuthenticationToken( username=self.username, access_token=self.password) print("authenticated: %s" % self.auth_token.authenticate( self.username, self.password, invalidate_previous=False)) self.connection = Connection(self.server, auth_token=self.auth_token, allowed_versions=self.versions) self.connection.register_packet_listener(lambda x: self.print_chat(x), ChatMessagePacket) print(self.auth_token) print(self.connection) if auto_connect: self._loop_reconect() def _loop_reconect(self): Timer(30.0, self._loop_reconect).start() try: self.connect() except: pass def add_chat_event(self, event): self.event = event def connect(self): self.connection.connect() def disconnect(self, immediate=False): self.connection.disconnect(immediate=immediate) def send_message(self, message): if message.strip() == "" or message == None: return False packet = ChatPacket() packet.message = message self.connection.write_packet(packet) def print_chat(self, chat_packet): try: a = json.loads(chat_packet.json_data) except Exception as e: pass else: self.event(self.parse_chat(a)) def parse_chat(self, chat_data): try: chat_data["extra"][0]["extra"] try: return (True, self.parse_chat(chat_data["extra"][0])[1]) except Exception as e: print(e) except: try: return (False, "".join([x["text"] for x in chat_data["extra"]])) except: pass return
def main(): 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) def handle_join_game(join_game_packet): print('Connected.') connection.register_packet_listener(handle_join_game, clientbound.play.JoinGamePacket) def print_raw_json(chat_packet): print("Message (%s): %s" % (chat_packet.field_string('position'), chat_packet.json_data)) def print_raw_text(chat_packet): print("Message (%s): " % chat_packet.field_string('position'), end="") printRawText(json.loads(chat_packet.json_data)) print("") def print_color_text(chat_packet): print("Message (%s): " % chat_packet.field_string('position'), end="") printColorText(json.loads(chat_packet.json_data)) print("") def keep_alive(packet): print("keep_alive[%d] packet receive." % packet.keep_alive_id) from random import randint ret = serverbound.play.KeepAlivePacket() ret.keep_alive_id = randint(0, 10000) connection.write_packet(ret) print("Write packet ok.") connection.register_packet_listener(print_color_text, clientbound.play.ChatMessagePacket) connection.register_packet_listener(keep_alive, clientbound.play.KeepAlivePacket) 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) except KeyboardInterrupt: print("Bye!") sys.exit()
def new_connection(): m=authentication.AuthenticationToken() auth=False while not auth: #Retry authentication until we get it try: auth=m.authenticate(user,pw) except YggdrasilError as e: #If authentication fails print(e) time.sleep(5) print("Retrying...") c=Connection(server_ip,auth_token=m,initial_version=server_version) c.allowed_proto_versions={SUPPORTED_MINECRAFT_VERSIONS[server_version]} c.register_packet_listener(keep_alive,KeepAlivePacketClientbound) c.register_packet_listener(process_chat,ChatMessagePacket,early=True) c.register_packet_listener(respawn,UpdateHealthPacket) c.register_packet_listener(set_slot,SetSlotPacket) if debug: c.register_packet_listener(in_out,Packet,outgoing=True) c.register_packet_listener(lambda x:in_out(x,"IN"),Packet) return c
def main(): """Our main function for running the simple pyCraft implementation. This function handles and maintains: - Gaining authentication tokens & 'logging in' - Connecting to the provided server, online or offline - Prints the chat packet data to standard out on Clientbound Packet - Writes Serverbound chat Packets when required - Dumping all packets to standard out Notes ----- This is a blocking function. """ 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 # 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) 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) 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)) 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) except KeyboardInterrupt: print("Bye!") sys.exit()
def main(): options = get_options() assets = AssetsManager(options.assets) mcdata = DataManager("./mcdata") if options.offline: print("Connecting in offline mode...") connection = Connection(options.address, options.port, username=options.username, allowed_versions=[options.mcversion]) else: auth_token = authentication.AuthenticationToken() try: auth_token.authenticate(options.username, options.password) except YggdrasilError as e: print(e) return print("Logged in as %s..." % auth_token.username) connection = Connection(options.address, options.port, auth_token=auth_token, allowed_versions=[options.mcversion]) 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 if type(packet) in [ clientbound.play.EntityVelocityPacket, clientbound.play.EntityLookPacket ]: # Prevents useless console spam 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) chat = ChatManager(assets) chat.register(connection) chunks = ChunksManager(mcdata) chunks.register(connection) def handle_join_game(join_game_packet): print('Connected.') connection.register_packet_listener(handle_join_game, clientbound.play.JoinGamePacket) connection.connect() while True: try: text = input() if text.startswith("!"): if text == "!respawn": print("respawning...") packet = serverbound.play.ClientStatusPacket() packet.action_id = serverbound.play.ClientStatusPacket.RESPAWN connection.write_packet(packet) elif text.startswith("!print "): p = text.split(" ") chunks.print_chunk( chunks.get_chunk(int(p[1]), int(p[2]), int(p[3])), int(p[4])) elif text == "!chunks": area = chunks.get_loaded_area() y_count = area[1][1] - area[0][1] print("Bounds: %s" % (area, )) for y in range(area[0][1], area[1][1]): print("Slice %d:" % (y)) for z in range(area[0][2], area[1][2]): for x in range(area[0][0], area[1][0]): if (x, y, z) in chunks.chunks: c = 'X' else: c = '.' print(c, end="") print() elif text == "!export": area = chunks.get_loaded_area(True) export_area(area[0][0] * 16, area[0][1] * 16, area[0][2] * 16, area[1][0] * 16, area[1][1] * 16, area[1][2] * 16, chunks, assets, mcdata) else: print("Unknow test command: %s" % (text)) else: chat.send(connection, text) except KeyboardInterrupt: print("Bye!") sys.exit() except Exception as ex: print("Exception: %s" % (ex)) traceback.print_exc()
custom_answers = config["custom"] auth_token = authentication.AuthenticationToken() #auth_token.authenticate(ACCOUNT[0], ACCOUNT[1]) while 1: try: auth_token.authenticate(ACCOUNT[0], ACCOUNT[1]) break except: print("waiting for mojang cooldown") time.sleep(10) print("Logged in as %s..." % auth_token.username) connection = Connection("gommehd.net", auth_token=auth_token) #connection = Connection("localhost", 62139, username="******") ''' 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) '''
def onMessage(self, payload, isBinary): if not isBinary: message = json.loads(payload.decode('utf8')) if message["type"] == "login": try: if message["username"] in connections and message[ "password"] == connections[ message["username"]]["password"]: connections[message["username"]][ "connection"].register_packet_listener( self.sendPacket, Packet, early=True) self.username = message["username"] print("Resuming session as " + connections[ message["username"]]["auth_token"].username + " on " + message["host"]) return print("Trying to log in as " + message["username"] + " on " + message["host"] + ":" + message["port"]) auth_token = authentication.AuthenticationToken() auth_token.authenticate(message["username"], message["password"]) connection = Connection(message["host"], int(message["port"]), auth_token=auth_token) connection.register_packet_listener(self.sendPacket, Packet, early=True) connection.register_packet_listener(self.onGameJoin, JoinGamePacket, early=True) connection.register_packet_listener( self.onDisconnection, DisconnectPacket) connection.connect() @connection.exception_handler(LoginDisconnect, early=True) def onFailedLogin(exc, exc_info): data = {"type": "LoginDisconnect", "packet": str(exc)} self.sendMessage(json.dumps( data, ensure_ascii=False).encode('utf8'), isBinary=False) connections[self.username]["connection"].disconnect() connections.pop(self.username) self._closeConnection() connections[message["username"]] = { "password": message["password"], "host": message["host"], "port": message["port"], "auth_token": auth_token, "connection": connection } self.username = message["username"] print("Started new session as " + auth_token.username + " on " + message["host"]) except Exception as e: print("Error while logging in: " + repr(e)) self.sendMessage( ("Error while logging in: " + repr(e)).encode('utf8'), False) self._closeConnection() elif message["type"] == "respawn": packet = serverbound.play.ClientStatusPacket() packet.action_id = serverbound.play.ClientStatusPacket.RESPAWN connections[self.username]["connection"].write_packet(packet) elif message["type"] == "chat": packet = serverbound.play.ChatPacket() packet.message = message["message"] connections[self.username]["connection"].write_packet(packet) elif message["type"] == "disconnect": connections[self.username]["connection"].disconnect() connections.pop(self.username) self._closeConnection() elif message["type"] == "connect": connections[self.username]["connection"].connect()
def main(): auth_token = authentication.AuthenticationToken() try: with open('minecraft.auth', 'r') as f: auth_token.client_token, auth_token.access_token = f.read().splitlines() # Library has issues need to do some hackey stuff to make sure it works. # I would use validate, but that would require some rewriting as well. auth_token.username = "******" auth_token.refresh() except (IOError, YggdrasilError): # IF there is no authentication file authenticate using username and password try: options = get_options() auth_token.authenticate(options["username"], options["password"]) except YggdrasilError as e: print(e) sys.exit() with open('minecraft.auth', 'w') as fout: fout.write(auth_token.client_token + '\n') fout.write(auth_token.access_token) print("Logged in as %s..." % auth_token.username) connection = Connection( "localhost", 25565, auth_token=auth_token) 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)) connection.register_packet_listener( print_chat, clientbound.play.ChatMessagePacket) global connected connected = True def disconnect(disconnect_packet): print("You were disconnected: %s" % disconnect_packet.json_data) global connected connected = False connection.register_packet_listener(disconnect, clientbound.play.DisconnectPacket) connection.connect() while connected: 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) except KeyboardInterrupt: print("Bye!") sys.exit()
def main(): 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) def handle_join_game(join_game_packet): print('Connected.') connection.register_packet_listener(handle_join_game, clientbound.play.JoinGamePacket) def print_chat(chat_packet, output="default"): if output == "raw": print( "Message (%s): %s" % (chat_packet.field_string('position'), chat_packet.json_data)) chat_json = json.loads(chat_packet.json_data) if output == "pretty": print( json.dumps(chat_json, sort_keys=True, indent=4, separators=(',', ': '))) if output == "default": message = Message(chat_json) ts = datetime.datetime.fromtimestamp( time.time()).strftime('%Y-%m-%d %H:%M:%S') print("[{}] {}".format(colored(ts, "grey"), message.formatted_str)) connection.register_packet_listener(print_chat, clientbound.play.ChatMessagePacket) connection.connect() def requeue(realm): message = "/joinqueue " + realm packet = serverbound.play.ChatPacket() packet.message = message print(message) connection.write_packet(packet) # Re-join realm every 60 seconds rt = RepeatedTimer(60, requeue, options.realm) 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) except KeyboardInterrupt: rt.stop() print("Bye!") sys.exit()
#playSong("thetop") if kb.is_pressed("ctrl+shift"): #MultiDimPrint("https://cdn.discordapp.com/attachments/255681374025941003/677868965674090526/wall.schematic", (219, 231, -155)) while kb.is_pressed("ctrl+shift"): pass if kb.is_pressed("f4"): exit() updatePosition() if __name__ == '__main__': # connect and register listeners dj = Connection("127.0.0.1", username="******") dj.connect() dj.register_packet_listener( _setPosition, clientbound.play.player_position_and_look_packet. PlayerPositionAndLookPacket) dj.register_packet_listener(_onChatMessage, clientbound.play.ChatMessagePacket) print("Connecting...") while pos is None: # wait for server to update dj's position pass print("Connected") sendChat("<3") main()
class bot: def __init__(self, username, password, bot_ign, reply_rate=20, whitelist=False): self.username = username self.password = password self.bot_ign = bot_ign self.debug = False self.whitelist = whitelist self.reply_rate = int(reply_rate) self.auth_token = authentication.AuthenticationToken() try: self.auth_token.authenticate(self.username, self.password) except YggdrasilError as error: print(error) exit() print("Logged in as %s." % self.auth_token.username) self.connection = Connection("mc.hypixel.net", 25565, auth_token=self.auth_token) self.command_delay = 0 self.msgQueue = [] self.partyQueue = [] self.commandQueue = [] self.msgCurrentChannel = "" self.party = {"inP": False, "from": "", "timestamp": 0} self.partyConfig = {} self.playercooldown = {} self.cooldownTimer = time.time() self.heartbeat = time.time() + 120 self.heartbeatCooldown = time.time() + 120 self.msgformat = msgformat.formats(self.bot_ign, 24) self.bots = {x: 0 for x in msgformat.bots if x != self.bot_ign} self.current_load = 0 self.inQueue = False self.inQueueTime = 0 self.muted = False self.muteDuration = 3600 self.unmutetime = 0 self.muteheartbeat = 0 self.leaderBuffer = [] self.mods = [] self.whitelisted = [] try: with open("whitelisted.txt", "r") as file: self.whitelisted = [x for x in file.read().split("\n")] except Exception: self.whitelisted = [] print("whitelisted loaded", len(self.whitelisted)) def initialize(self): self.connection.register_packet_listener( self.handle_join_game, clientbound.play.JoinGamePacket) self.connection.register_packet_listener( self.handle_chat, clientbound.play.ChatMessagePacket) self.connection.connect() def disconnect(self): self.msgQueue = [] self.partyQueue = [] self.friendQueue = [] self.connection.disconnect(True) exit() def send_chat(self, text, delay=0.6, bypass=False): if not self.inQueue or bypass: text = text[:255] # limit to 255 characters packet = serverbound.play.ChatPacket() packet.message = text self.connection.write_packet(packet) if self.debug: debugtext = "".join(x for x in text if x not in "-⛬⛫⛭⛮⛶_") print(debugtext) self.command_delay = time.time() time.sleep(delay * 1.05) def handle_join_game(self, packet): print(packet) self.heartbeat = time.time() - 50 self.heartbeatCooldown = time.time() - 50 time.sleep(0.5) self.send_chat("/p leave") print('Connected.') def handle_chat(self, chat_packet): try: chat_raw = str(chat_packet.json_data) chat_json = json.loads(chat_raw) msg = util.raw_to_msg(chat_json) if not (self.muted): if ("red" in chat_raw and len(msg) < 75 and "+]" not in msg) or self.debug: debugtext = "".join(x for x in msg if x not in "-⛬⛫⛭⛮⛶_") print(debugtext) if ("red" in chat_raw and len(msg) < 75 and "+]" not in msg): mutedetect = "".join(x for x in msg if x not in "-⛬⛫⛭⛮⛶_") if "Your mute will expire in" in mutedetect: muted = True duration = mutedetect[ mutedetect.index("Your mute will expire in") + 25:] duration = duration.split(' Find') del duration[1] duration = duration.pop(0) print(f'You are muted for {duration}.') if "extra" in chat_json: # On party request if chat_raw.count("/party accept") >= 2: for data in chat_json["extra"]: if "/party accept" in str(data): user = data["clickEvent"]["value"].split()[-1] if (user not in self.whitelisted ) and self.whitelist: return # whitelist if self.cooldowncheck(user, 5): return # cooldown self.partyQueue.append({ "mode": "queue", "user": user }) return return # On heartbeat elif "HeartBeat-KeepAlive" in chat_raw and "from" not in chat_raw.lower( ) and self.bot_ign in chat_raw: if time.time() - self.heartbeat > 70 and self.debug: self.debug = False self.heartbeat = time.time() onlinehb = ['bwstatsv2'] onlinehb.append([ int(time.time()), self.bot_ign, min( int( max(self.current_load, 1) / max(self.reply_rate, 0.1) * 100), 100) ]) onlinehb = [ x for x in onlinehb if time.time() - x[0] < 130 ] msgformat.bots = list( set([ x[1] for x in onlinehb if time.time() - x[0] < 130 ])) self.bots = {} for bot in onlinehb: if bot[1] in self.bots: self.bots[bot[1]] = max( bot[2], self.bots[bot[1]]) else: self.bots[bot[1]] = bot[2] if self.debug: for bot in self.bots: print(bot, self.bots[bot], "%") # print(msgformat.bots) return elif "Party Leader" in chat_raw and "●" in chat_raw: leader = [ leader for leader in msg[msg.index(":") + 1:].split("●") if len(leader) > 1 ] leader = [leader.split()[-1] for leader in leader] leader = leader.pop(0) self.leaderBuffer.append(leader) elif "Party Moderators" in chat_raw and "●" in chat_raw: mods = [ mods for mods in msg[msg.index(":") + 1:].split("●") if len(mods) > 1 ] mods = [mods.split()[-1] for mods in mods] self.mods.append(self.leaderBuffer[0]) # On party list return elif "Party Members" in chat_raw and "●" in chat_raw: # Party members (2): [VIP] MinuteBrain ● [MVP+] Its_Me_Me ● users = [ user for user in msg[msg.index(":") + 1:].split("●") if len(user) > 1 ] users = [user.split()[-1] for user in users] # remove ranks users.append(self.leaderBuffer[0]) users.extend(self.mods) self.leaderBuffer = [] self.mods = [] users.remove(self.bot_ign) # remove bot from the list self.partyQueue = [{ "mode": "list", "user": users }] + self.partyQueue # put on top of the queue return # On msg request elif ("From " in chat_raw) and ("light_purple" in chat_raw) and (self.bot_ign not in chat_raw): self.chat_msg(msg) return # On open PM channel elif { "text": " for the next 5 minutes. Use ", "color": "green" } in chat_json["extra"]: user = msg[msg.index("with") + 4:msg.index("for")].split()[-1] #print(user) self.msgCurrentChannel = user return # On friend request elif ("Click to" in chat_raw) and ("/f accept " in chat_raw): for data in chat_json["extra"]: if "/f accept " in str(data).lower(): user = data["clickEvent"]["value"].split()[-1] if self.cooldowncheck(user, 2): return # cooldown self.commandQueue.append({ "command": "friend_request", "user": user }) return return # On queue elif ("The game starts in" in chat_raw) or ( "has joined" in msg and "/" in msg ) or ("has quit" in msg and "/" in msg) or ("The party leader, " in chat_raw and "yellow" in chat_raw): if not (self.inQueue ) and time.time() - self.inQueueTime > 5: self.inQueue = True self.inQueueTime = time.time() print("Blocked - " + self.party["from"]) self.cooldowncheck(self.party["from"], 60) self.party["inP"] = True self.party["timestamp"] = time.time() + 99999 time.sleep(1) self.party["inP"] = True self.send_chat("/pchat :( hey! don't warp me!", 0.07, True) self.send_chat("/p leave", 1, True) self.send_chat("/hub bw", 0.7, True) for _ in range(15): self.send_chat("/golimbo", 0.07, True) self.party["inP"] = True self.party["timestamp"] = time.time() + 5 self.inQueue = False self.inQueueTime = time.time() return # On whereami respond elif "You are currently connected to server" in msg and "aqua" in chat_raw.lower( ): if "lobby" in msg: self.commandQueue.append({"command": "in_lobby"}) else: self.commandQueue.append({"command": "in_game"}) return else: # while muted print('idk ur muted or smth') except Exception as error_code: print("chat handle error!!", error_code) def chat_msg(self, msg): # >>> msg = 'From [MVP+] FatDubs: FatDubs gamerboy80 5' if "+send" not in msg.lower(): msg = "".join([ char for char in msg if char.lower() in "[]:abcdefghijklmnopqrstuvwxyz0123456789_ +/" ]) msg = " ".join(msg.split()) # remove double space msg = msg.replace("+ ", "+").replace("++", "+").replace("+]", "]") user = msg[:msg.index(":")].split()[-1] if (user not in self.whitelisted) and self.whitelist: return # whitelist agus = msg[msg.index(":") + 1:].split() # user = '******' # agus = ['FatDubs', 'gamerboy80', '5'] mode = 0 # stats mode if len(agus) > 1 and "+send" not in "".join(agus).lower(): mode = agus[-1] if mode in [str(x) for x in range(6)]: mode = int(mode) agus.pop(-1) else: mode = 0 # user = '******' # agus = ['FatDubs', 'gamerboy80'] # mode = 5 if self.cooldowncheck(user, 1) and user.lower() not in ["fatdubs"]: return # player cooldown # commands if "+" in msg: command = agus[0] if command.lower() == "+send" and user.lower() in [ "fatdubs" ] and len(agus) >= 2: self.commandQueue.append({ "command": "send_command", "send": " ".join(agus[1:]) }) elif command.lower() == "+limbo" and user.lower() in ["fatdubs"]: print("Warp to Limbo") for _ in range(15): self.send_chat("/golimbo", 0.07, True) self.send_chat("/whereami") elif command.lower() == "+whitelist" and user.lower() in [ "fatdubs" ] and len(agus) >= 2: self.whitelistChange = ("".join(agus[1:])) print('whitelist queue - ' + self.whitelistChange) elif command.lower() == "+stop" and user.lower() in ["fatdubs"]: print('disconnecting..') self.disconnect() elif command.lower() in ["+pmode", "+setpartymode"]: self.partyConfig[user] = mode self.msgQueue = [{ "msgMode": "party_mode", "user": user, "mode": mode }] + self.msgQueue elif command.lower() == "+resetcooldown" and user.lower() in [ "fatdubs" ]: self.playercooldown = {} print('reset cooldown') elif command.lower() in ["+reload", "+reloadall"] and user.lower( ) in ["fatdubs"] + [x.lower() for x in list(self.bots)]: print("Reloading...") try: reload(msgformat) self.msgformat = msgformat.formats(self.bot_ign, 24) self.bots = { x: 0 for x in msgformat.bots if x != self.bot_ign } except Exception: print("Fail to reload msgformat") try: reload(hypixelapi) except Exception: print("Fail to reload hypixelapi") elif command.lower() == "+debug" and user.lower() in ["fatdubs"]: self.debug = not (self.debug) print(f"Debug : {self.debug}") else: self.msgQueue = [{ "msgMode": "wrong_syntax", "user": user }] + self.msgQueue return # stats request if self.current_load <= self.reply_rate: if len(agus) > 0: if len(agus[0]) <= 16: if len(agus) == 1: self.msgQueue = [{ "msgMode": "stats", "replyto": user, "username": agus[0], "mode": mode }] + self.msgQueue elif len(agus) > 1 and len(agus) <= 4: self.msgQueue = [{ "msgMode": "stats_multiple", "replyto": user, "username": agus, "mode": mode }] + self.msgQueue else: self.msgQueue = [{ "msgMode": "wrong_syntax", "user": user }] + self.msgQueue else: self.msgQueue = [{ "msgMode": "wrong_syntax", "user": user }] + self.msgQueue else: self.msgQueue = [{ "msgMode": "wrong_syntax", "user": user }] + self.msgQueue def cooldowncheck(self, user, n=1): if user not in self.playercooldown: self.playercooldown[user] = n else: if self.playercooldown[user] > 6: self.playercooldown[user] += 3 else: self.playercooldown[user] += n if self.playercooldown[user] > 100 and user.lower() not in ["fatdubs"]: self.commandQueue.append({"command": "ignore", "user": user}) print("Ignored", user, self.playercooldown[user]) return True elif self.playercooldown[user] > 6 and user.lower() not in ["fatdubs"]: print("Reject spam from", user, self.playercooldown[user]) return True else: self.current_load += 1 return False def cooldown_tick(self): if time.time() - self.cooldownTimer >= 6: self.cooldownTimer = time.time() for user in list(self.playercooldown): self.playercooldown[user] -= 1 self.playercooldown = { x: self.playercooldown[x] for x in list(self.playercooldown) if self.playercooldown[x] > 0 } def msg_tick(self): if len(self.msgQueue) > 0: currentQueue = self.msgQueue.pop(0) if currentQueue["msgMode"] == "stats": replyTo = currentQueue["replyto"] username = currentQueue["username"] if currentQueue["username"].lower() == "me": username = currentQueue["replyto"] mode = currentQueue["mode"] if self.msgCurrentChannel != replyTo: while time.time() - self.command_delay < 0.5: time.sleep(0.05) self.send_chat("/r", 0) data = hypixelapi.getPlayer(username, hypixelapi.nextKey()) raw = hypixelapi.convert(data, mode, "msg") msg = self.msgformat.msg(raw, replyTo.lower() == username.lower()) while time.time() - self.command_delay < 0.7: time.sleep(0.05) if replyTo.lower() == self.msgCurrentChannel.lower(): print(f"(R) {replyTo} --> {username}") self.send_chat(msg, 0.4) else: if hypixelapi.getPlayer( replyTo, hypixelapi.nextKey())["msgsetting"]: print(f"(MSG) {replyTo} --> {username}") self.send_chat(f"/msg {replyTo} " + msg, 0.4) else: print(f"(MSG) Couldn't reply to {replyTo}") self.msgCurrentChannel = "" if currentQueue["msgMode"] == "stats_multiple": replyTo = currentQueue["replyto"] usernames = currentQueue["username"] mode = currentQueue["mode"] #util.dict_increment(self.quotaChange,replyTo,len(usernames)) if self.msgCurrentChannel != replyTo: while time.time() - self.command_delay < 0.6: time.sleep(0.05) self.send_chat("/r", 0) handle = util.multithreading(usernames, mode) handle.start() raws = [handle.output[x] for x in list(handle.output)] msg = list(self.msgformat.party(raws, mode))[0] msg = msgformat.insertInvis(msg, 20) while time.time() - self.command_delay < 0.7: time.sleep(0.05) if replyTo.lower() == self.msgCurrentChannel.lower(): print(f"(R) {replyTo} --> {usernames}") self.send_chat(msg, 0.4) else: if hypixelapi.getPlayer( replyTo, hypixelapi.nextKey())["msgsetting"]: print(f"(MSG) {replyTo} --> {username}") self.send_chat(f"/msg {replyTo} " + msg, 0.4) else: print(f"(MSG) Can't send msg {replyTo}") self.msgCurrentChannel = "" elif currentQueue["msgMode"] == "wrong_syntax": print(f"Wrong_syntax: {currentQueue['user']}") while time.time() - self.command_delay < 0.5: time.sleep(0.05) self.send_chat("/r " + self.msgformat.wrong_syntax(), 0.5) elif currentQueue["msgMode"] == "party_mode": print( f"Party Mode: {currentQueue['user']} --> {currentQueue['mode']}" ) while time.time() - self.command_delay < 0.5: time.sleep(0.05) self.send_chat( "/r " + self.msgformat.party_mode(currentQueue["mode"]), 0.5) def party_chat_transit(self, msg, delay=0.5): while len(self.msgQueue) > 0: self.msg_tick() time.sleep(0.05) while time.time() - self.command_delay < delay: time.sleep(0.05) self.send_chat(msg, delay) self.party["timestamp"] = time.time() def party_tick(self): if len(self.partyQueue) > 0 and len(self.msgQueue) == 0: currentQueue = self.partyQueue.pop(0) if currentQueue["mode"] == "queue" and self.party[ "inP"]: # requeue if in party #print("Party Requeued !!") self.partyQueue.append(currentQueue) else: if currentQueue["mode"] == "queue": self.party = {"inP": True, "from": currentQueue["user"]} #util.dict_increment(self.quotaChange,self.party["from"],1) while time.time() - self.command_delay < 0.5: time.sleep(0.05) # prevent sending command too fast self.party_chat_transit(f"/p accept {self.party['from']}", 0.4) self.party_chat_transit(f"/pl", 0.3) elif currentQueue["mode"] == "list": users = currentQueue['user'] print("Party list -", " ".join(users)) for user in users: if user.lower() != self.bot_ign and user in list( self.bots): print("multiple bots in party!!!!!") self.cooldowncheck(self.party["from"], 20) while time.time() - self.command_delay < 2: self.msg_tick() time.sleep(0.05) self.send_chat("/p leave") self.party["inP"] = False return if len(users) <= self.msgformat.party_max: if self.party["from"] in self.partyConfig: mode = self.partyConfig[self.party["from"]] else: mode = 0 handle = util.multithreading(users, mode) handle.start() raws = [handle.output[x] for x in list(handle.output)] msgs = self.msgformat.party(raws, mode) while time.time() - self.command_delay < 0.3: time.sleep(0.05) for msg in msgs: self.party_chat_transit(f"/pchat {msg}", 0.3) else: while time.time() - self.command_delay < 0.3: time.sleep(0.05) self.party_chat_transit( "/pchat " + self.msgformat.party_too_large(), 0.3) while time.time() - self.command_delay < 1: self.msg_tick() time.sleep(0.05) self.send_chat("/p leave") self.party["inP"] = False if self.party["inP"] and time.time() - self.party["timestamp"] > 2: print("Party timeout", self.party["from"]) while time.time() - self.command_delay < 0.8: time.sleep(0.05) self.send_chat("/p leave", 0.3) self.party["inP"] = False def command_tick(self): if len(self.commandQueue) > 0: currentQueue = self.commandQueue.pop(0) if currentQueue["command"] == "friend_request": print(f"Friend accepted - {currentQueue['user']}") while time.time() - self.command_delay < 0.7: time.sleep(0.05) self.send_chat(f"/f accept {currentQueue['user']}", 0.3) elif currentQueue["command"] == "send_command": print(f"Command sent - {currentQueue['send']}") while time.time() - self.command_delay < 0.7: time.sleep(0.05) self.send_chat(currentQueue["send"], 0.3, True) elif currentQueue["command"] == "in_game": print("Warp to Lobby") while time.time() - self.command_delay < 0.5: time.sleep(0.05) self.send_chat("/hub bw", 0.3, True) elif currentQueue["command"] == "in_lobby": print("Warp to Limbo") for _ in range(15): self.send_chat("/golimbo", 0.07, True) self.send_chat("/whereami") elif currentQueue["command"] == "ignore": print(f"Ignored - {currentQueue['user']}") while time.time() - self.command_delay < 0.7: time.sleep(0.05) self.send_chat(f"/ignore add {currentQueue['user']}") def heartbeat_tick(self): if time.time() - self.heartbeat > 610: self.connection.disconnect(True) raise Exception("No heartbeat detect! Reconnecting") return if time.time() - self.heartbeat > 120 and not (self.debug): #self.debug = True self.connection.connect() #print("Debug : True") print("Reconnecting") if time.time() - self.heartbeat > 60 and time.time( ) - self.heartbeatCooldown > 30: heartbeat_length = time.time() - self.heartbeat random_msg = "".join( [chr(random.randint(64, 125)) for _ in range(30)]) while time.time() - self.command_delay < 0.5: time.sleep(0.7) self.send_chat( f"/msg {self.bot_ign} HeartBeat-KeepAlive {random_msg}", 0.3) #comment this to test heartbeat restart system. self.heartbeatCooldown = time.time() self.send_chat("/whereami", 0.2) if self.current_load > self.reply_rate: print("Overloaded!! <-----") self.current_load = 0 if time.time() - self.heartbeat > 300: self.connection.connect() print("Reconnecting") print(f"Heartbeat ({int(heartbeat_length)}sec)") return def tick(self): self.heartbeat_tick() try: self.party_tick() self.msg_tick() self.command_tick() self.cooldown_tick() except Exception as error_code: print("Tick error! (skiped) -", error_code)
def main(): 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 # 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) 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) 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)) connection.register_packet_listener( print_chat, clientbound.play.ChatMessagePacket) def handle_zzz(chat_packet): if json.loads(chat_packet.json_data).get("with", " ")[-1] == "zzz": connection.disconnect() time.sleep(5) connection.connect() connection.register_packet_listener( handle_zzz, 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) except KeyboardInterrupt: print("Bye!") sys.exit()
class CallbackCallable(): def __init__(self): self.connection = None self.done = False self.ip = None self.port = None def __call__(self, ch, method, properties, body): json_body = json.loads(body) self.ip = json_body["ip"] self.port = int(json_body["port"]) try: ipstr = "{}:{}".format(self.ip, self.port) status = MinecraftServer.lookup(ipstr).status(retries=2) if status.players.online > 0: print("server {} skipped because of {} online players".format( ipstr, status.players.online)) channel.basic_publish( exchange='', routing_key=os.environ['RABBIT_MOTD_QUEUE'], body=json.dumps({ 'ip': self.ip, 'port': int(self.port) }), properties=pika.BasicProperties( delivery_mode=2, # make message persistent )) except (socket.timeout, ConnectionRefusedError, ConnectionResetError, OSError): return try: self.connect() except Exception as e: self.disconnect(ch, method) print(e) return if self.connection.connected: self.connection.disconnect(immediate=True) self.disconnect(ch, method) def exception_handler(self, exception): print(exception) def connect(self): self.connection = Connection(self.ip, self.port, auth_token=auth_token, handle_exception=self.exception_handler) print("connecting to", self.ip) self.connection.register_packet_listener( self.handle_join_game, clientbound.play.JoinGamePacket) self.connection.register_packet_listener( self.on_login_disconnect_packet, clientbound.play.DisconnectPacket, early=True) # self.connection.register_packet_listener(self.print_packet, Packet, early=True) self.connection.register_packet_listener( self.on_login_disconnect_packet, clientbound.login.DisconnectPacket, early=True) with timeout(2): self.connection.connect() start = time.time() while not self.done: time.sleep(0.01) now = time.time() diff = now - start if diff > 2: self.done = True def disconnect(self, ch, method): self.connection = None self.done = False ch.basic_ack(method.delivery_tag) def print_packet(self, packet): if type(packet) is Packet: return print('--> %s' % packet) def handle_join_game(self, join_game_packet): print("found server without whitelist") conn = psycopg2.connect(database=os.environ['POSTGRES_DATABASE'], user=os.environ['POSTGRES_USER'], password=os.environ['POSTGRES_PASSWORD'], host=os.environ['POSTGRES_HOST'], port=os.environ['POSTGRES_PORT']) with conn.cursor() as c: c.execute( "INSERT INTO public.servers (ip, port) VALUES(%s, %s) ON CONFLICT DO NOTHING;", (self.ip, self.port)) conn.commit() self.done = True def on_login_disconnect_packet(self, packet): #print("disconnected from game:",packet) self.done = True
class Player: """ A class built to handle all required actions to maintain: - Gaining auth tokens, and connecting to online minecraft servers. - Clientbound chat - Serverbound chat Warnings -------- This class explicitly expects a username & password, then expects to be able to connect to a server in online mode. If you wish to add different functionality please view the example headless client, `start.py`, for how to implement it. """ def __init__(self, username, password, *, admins=None): """ Init handles the following: - Client Authentication - Setting the current connection state - Setting the recognized 'admins' for this instance Parameters ---------- username : String Used for authentication password : String Used for authentication admins : list, optional The minecraft accounts to auto accept tpa's requests from Raises ------ YggdrasilError Username or Password was incorrect """ self.kickout = False self.admins = [] if admins is None else admins self.auth_token = authentication.AuthenticationToken() self.auth_token.authenticate(username, password) def Parser(self, data): """ Converts the chat packet received from the server into human readable strings Parameters ---------- data : JSON The chat data json receive from the server Returns ------- message : String The text received from the server in human readable form """ message = DefaultParser(data) # This is where you would call other parsers if not message: return False if "teleport" in message.lower(): self.HandleTpa(message) return message def HandleTpa(self, message): """ Using the given message, figure out whether or not to accept the tpa Parameters ---------- message : String The current chat, where 'tpa' was found in message.lower() """ try: found = re.search( "(.+?) has requested that you teleport to them.", message ).group(1) if found in self.admins: self.SendChat("/tpyes") return except AttributeError: pass try: found = re.search("(.+?) has requested to teleport to you.", message).group( 1 ) if found in self.admins: self.SendChat("/tpyes") return except AttributeError: pass def SendChat(self, msg): """ Send a given message to the server Parameters ---------- msg : String The message to send to the server """ msg = str(msg) if len(msg) > 0: packet = serverbound.play.ChatPacket() packet.message = msg self.connection.write_packet(packet) def ReceiveChat(self, chat_packet): """ The listener for ClientboundChatPackets Parameters ---------- chat_packet : ClientboundChatPacket The incoming chat packet chat_packet.json : JSON The chat packet to pass of to our Parser for handling """ message = self.Parser(chat_packet.json_data) if not message: # This means our Parser failed lol print("Parser failed") return print(message) def SetServer(self, ip, port=25565, handler=None): """ Sets the server, ready for connection Parameters ---------- ip : str The server to connect to port : int, optional The port to connect on handler : Function pointer, optional Points to the function used to handle Clientbound chat packets """ handler = handler or self.ReceiveChat self.ip = ip self.port = port self.connection = Connection( ip, port, auth_token=self.auth_token, handle_exception=print ) self.connection.register_packet_listener( handler, clientbound.play.ChatMessagePacket ) self.connection.exception_handler(print) def Connect(self): """ Actually connect to the server for this player and maintain said connection Notes ----- This is a blocking function and will not return until `Disconnect()` is called on said instance. """ self.connection.connect() print(f"Connected to server with: {self.auth_token.username}") while True: time.sleep(1) if self.kickout: break def Disconnect(self): """ In order to disconnect the client, and break the blocking loop this method must be called """ self.kickout = True self.connection.disconnect()
class Main(object): def __init__(self, options): self.auth_token = authentication.AuthenticationToken() try: self.auth_token.authenticate(options.username, options.password) except YggdrasilError as e: print(e) sys.exit() print("Logged in as " + self.auth_token.username) self.network = Connection(options.address, options.port, self.auth_token) self.network.connect() self.register_listeners() #sys.stdout = Speaker(self) while not self.network.playing: pass self.respawn() while True: try: self.tick() except KeyboardInterrupt: print("Bye!") sys.exit() def register_listeners(self): self.network.register_packet_listener(self.print_chat, ChatMessagePacket) self.network.register_packet_listener(self.set_pos, PlayerPositionAndLookPacket) self.network.register_packet_listener(self.recieve_plugin_message, PluginMessage) self.network.register_packet_listener(self.set_health, UpdateHealth) def tick(self): text = input() self.speak(text) def speak(self, message): packet = ChatPacket() packet.message = message self.network.write_packet(packet) def set_health(self, health_packet): if health_packet.health == 0.0: print "RESPAWN" self.respawn() def respawn(self): packet = ClientStatus() packet.action_id = 0 self.network.write_packet(packet) #print packet def print_chat(self, chat_packet): print type(chat_packet) print("Position: " + str(chat_packet.position)) print("Data: " + chat_packet.json_data) def recieve_plugin_message(self, plugin_message): data = plugin_message.data.split("|") if len(data) == 2 and data[0] == "MC": if data[1] == "Brand": print "Brand:", plugin_message.channel else: print "PLUGIN MESSAGE:", data[1], plugin_message.channel