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(): 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() 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 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 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 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()
class MinecraftDiscordBridge(): def __init__(self): self.return_code = os.EX_OK self.session_token = "" self.uuid_cache = bidict() self.webhooks = [] self.bot_username = "" self.next_message_time = datetime.now(timezone.utc) self.previous_message = "" self.player_list = bidict() self.previous_player_list = bidict() self.accept_join_events = False self.tab_header = "" self.tab_footer = "" # Initialize the discord part self.discord_bot = discord.Client() self.config = Configuration("config.json") self.connection_retries = 0 self.auth_token = None self.connection = None self.setup_logging(self.config.logging_level) self.database_session = DatabaseSession() self.logger = logging.getLogger("bridge") self.database_session.initialize(self.config) self.bot_perms = discord.Permissions() self.bot_perms.update(manage_messages=True, manage_webhooks=True) # Async http request pool self.req_future_session = FuturesSession(max_workers=100) self.reactor_thread = Thread(target=self.run_auth_server, args=(self.config.auth_port, )) self.aioloop = asyncio.get_event_loop() # We need to import twisted after setting up the logger because twisted hijacks our logging from . import auth_server auth_server.DATABASE_SESSION = self.database_session if self.config.es_enabled: if self.config.es_auth: self.es_logger = ElasticsearchLogger(self.req_future_session, self.config.es_url, self.config.es_username, self.config.es_password) else: self.es_logger = ElasticsearchLogger(self.req_future_session, self.config.es_url) @self.discord_bot.event async def on_ready(): # pylint: disable=W0612 self.logger.info("Discord bot logged in as %s (%s)", self.discord_bot.user.name, self.discord_bot.user.id) self.logger.info( "Discord bot invite link: %s", discord.utils.oauth_url(client_id=self.discord_bot.user.id, permissions=self.bot_perms)) await self.discord_bot.change_presence( activity=discord.Game("mc!help for help")) self.webhooks = [] session = self.database_session.get_session() channels = session.query(DiscordChannel).all() session.close() for channel in channels: channel_id = channel.channel_id discord_channel = self.discord_bot.get_channel(channel_id) if discord_channel is None: session = self.database_session.get_session() session.query(DiscordChannel).filter_by( channel_id=channel_id).delete() session.close() continue channel_webhooks = await discord_channel.webhooks() found = False for webhook in channel_webhooks: if webhook.name == "_minecraft" and webhook.user == self.discord_bot.user: self.webhooks.append(webhook.url) found = True self.logger.debug("Found webhook %s in channel %s", webhook.name, discord_channel.name) if not found: # Create the hook await discord_channel.create_webhook(name="_minecraft") @self.discord_bot.event async def on_message(message): # pylint: disable=W0612 # We do not want the bot to reply to itself if message.author == self.discord_bot.user: return this_channel = message.channel.id # PM Commands if message.content.startswith("mc!help"): try: send_channel = message.channel if isinstance(message.channel, discord.abc.GuildChannel): await message.delete() dm_channel = message.author.dm_channel if not dm_channel: await message.author.create_dm() send_channel = message.author.dm_channel msg = self.get_discord_help_string() await send_channel.send(msg) return except discord.errors.Forbidden: if isinstance(message.author, discord.abc.User): msg = "{}, please allow private messages from this bot.".format( message.author.mention) error_msg = await message.channel.send(msg) await asyncio.sleep(3) await error_msg.delete() return elif message.content.startswith("mc!register"): try: send_channel = message.channel if isinstance(message.channel, discord.abc.GuildChannel): await message.delete() dm_channel = message.author.dm_channel if not dm_channel: await message.author.create_dm() send_channel = message.author.dm_channel session = self.database_session.get_session() discord_account = session.query(DiscordAccount).filter_by( discord_id=message.author.id).first() if not discord_account: new_discord_account = DiscordAccount(message.author.id) session.add(new_discord_account) session.commit() discord_account = session.query( DiscordAccount).filter_by( discord_id=message.author.id).first() new_token = self.generate_random_auth_token(16) account_link_token = AccountLinkToken( message.author.id, new_token) discord_account.link_token = account_link_token session.add(account_link_token) session.commit() msg = "Please connect your minecraft account to `{}.{}:{}` in order to link it to this bridge!"\ .format(new_token, self.config.auth_dns, self.config.auth_port) session.close() del session await send_channel.send(msg) return except discord.errors.Forbidden: if isinstance(message.author, discord.abc.User): msg = "{}, please allow private messages from this bot.".format( message.author.mention) error_msg = await message.channel.send(msg) await asyncio.sleep(3) await error_msg.delete() return # Global Commands elif message.content.startswith("mc!chathere"): if isinstance(message.channel, discord.abc.PrivateChannel): msg = "Sorry, this command is only available in public channels." await message.channel.send(msg) return if message.author.id not in self.config.admin_users: await message.delete() try: dm_channel = message.author.dm_channel if not dm_channel: await message.author.create_dm() dm_channel = message.author.dm_channel msg = "Sorry, you do not have permission to execute that command!" await dm_channel.send(msg) return except discord.errors.Forbidden: if isinstance(message.author, discord.abc.User): msg = "{}, please allow private messages from this bot.".format( message.author.mention) error_msg = await message.channel.send(msg) await asyncio.sleep(3) await error_msg.delete() return session = self.database_session.get_session() channels = session.query(DiscordChannel).filter_by( channel_id=this_channel).all() if not channels: new_channel = DiscordChannel(this_channel) session.add(new_channel) session.commit() session.close() del session webhook = await message.channel.create_webhook( name="_minecraft") self.webhooks.append(webhook.url) msg = "The bot will now start chatting here! To stop this, run `mc!stopchathere`." await message.channel.send(msg) else: msg = "The bot is already chatting in this channel! To stop this, run `mc!stopchathere`." await message.channel.send(msg) return elif message.content.startswith("mc!stopchathere"): if isinstance(message.channel, discord.abc.PrivateChannel): msg = "Sorry, this command is only available in public channels." await message.channel.send(msg) return if message.author.id not in self.config.admin_users: await message.delete() try: dm_channel = message.author.dm_channel if not dm_channel: await message.author.create_dm() dm_channel = message.author.dm_channel msg = "Sorry, you do not have permission to execute that command!" await dm_channel.send(msg) return except discord.errors.Forbidden: if isinstance(message.author, discord.abc.User): msg = "{}, please allow private messages from this bot.".format( message.author.mention) error_msg = await message.channel.send(msg) await asyncio.sleep(3) await error_msg.delete() return session = self.database_session.get_session() deleted = session.query(DiscordChannel).filter_by( channel_id=this_channel).delete() session.commit() session.close() for webhook in await message.channel.webhooks(): if webhook.name == "_minecraft" and webhook.user == self.discord_bot.user: # Copy the list to avoid some problems since # we're deleting indicies form it as we loop # through it if webhook.url in self.webhooks[:]: self.webhooks.remove(webhook.url) await webhook.delete() if deleted < 1: msg = "The bot was not chatting here!" await message.channel.send(msg) return else: msg = "The bot will no longer chat here!" await message.channel.send(msg) return elif message.content.startswith("mc!tab"): send_channel = message.channel try: if isinstance(message.channel, discord.abc.GuildChannel): await message.delete() dm_channel = message.author.dm_channel if not dm_channel: await message.author.create_dm() send_channel = message.author.dm_channel player_list = ", ".join( list(map(lambda x: x[1], self.player_list.items()))) msg = "{}\n" \ "Players online: {}\n" \ "{}".format(self.escape_markdown( self.strip_colour(self.tab_header)), self.escape_markdown( self.strip_colour(player_list)), self.escape_markdown( self.strip_colour(self.tab_footer))) await send_channel.send(msg) return except discord.errors.Forbidden: if isinstance(message.author, discord.abc.User): msg = "{}, please allow private messages from this bot.".format( message.author.mention) error_msg = await message.channel.send(msg) await asyncio.sleep(3) await error_msg.delete() return elif message.content.startswith("mc!botlink"): send_channel = message.channel try: if isinstance(message.channel, discord.abc.GuildChannel): await message.delete() dm_channel = message.author.dm_channel if not dm_channel: await message.author.create_dm() send_channel = message.author.dm_channel msg = "Use the following link to invite this bot to a guild:\n{}".format( discord.utils.oauth_url( client_id=self.discord_bot.user.id, permissions=self.bot_perms)) await send_channel.send(msg) return except discord.errors.Forbidden: if isinstance(message.author, discord.abc.User): msg = "{}, please allow private messages from this bot.".format( message.author.mention) error_msg = await message.channel.send(msg) await asyncio.sleep(3) await error_msg.delete() return elif message.content.startswith("mc!about"): send_channel = message.channel try: if isinstance(message.channel, discord.abc.GuildChannel): await message.delete() dm_channel = message.author.dm_channel if not dm_channel: await message.author.create_dm() send_channel = message.author.dm_channel msg = "This bot is running minecraft-discord-bridge version {}.\n" \ "The source code is available at https://github.com/starcraft66/minecraft-discord-bridge" \ .format(minecraft_discord_bridge.__version__) await send_channel.send(msg) return except discord.errors.Forbidden: if isinstance(message.author, discord.abc.User): msg = "{}, please allow private messages from this bot.".format( message.author.mention) error_msg = await message.channel.send(msg) await asyncio.sleep(3) await error_msg.delete() return elif message.content.startswith("mc!"): # Catch-all send_channel = message.channel try: if isinstance(message.channel, discord.abc.GuildChannel): await message.delete() dm_channel = message.author.dm_channel if not dm_channel: await message.author.create_dm() send_channel = message.author.dm_channel msg = "Unknown command, type `mc!help` for a list of commands." await send_channel.send(msg) return except discord.errors.Forbidden: if isinstance(message.author, discord.abc.User): msg = "{}, please allow private messages from this bot.".format( message.author.mention) error_msg = await message.channel.send(msg) await asyncio.sleep(3) await error_msg.delete() return elif "https://discord.gg" in message.content.lower(): await message.delete() # Deletes the message # Add something more if you want to msg = f"{message.author.mention} invites aren't allowed!" # Your message await send_channel.send(msg) elif not message.author.bot: session = self.database_session.get_session() channel_should_chat = session.query(DiscordChannel).filter_by( channel_id=this_channel).first() if channel_should_chat: await message.delete() discord_user = session.query(DiscordAccount).filter_by( discord_id=message.author.id).first() if discord_user: if discord_user.minecraft_account: minecraft_uuid = discord_user.minecraft_account.minecraft_uuid session.close() del session minecraft_username = self.mc_uuid_to_username( minecraft_uuid) # Max chat message length: 256, bot username does not count towards this # Does not count|Counts # <BOT_USERNAME> minecraft_username: message padding = 2 + len(minecraft_username) message_to_send = self.remove_emoji( message.clean_content.encode('utf-8').decode( 'ascii', 'replace')).strip() message_to_discord = self.escape_markdown( message.clean_content) total_len = padding + len(message_to_send) if total_len > 256: message_to_send = message_to_send[:(256 - padding)] message_to_discord = message_to_discord[:( 256 - padding)] elif not message_to_send: return session = self.database_session.get_session() channels = session.query(DiscordChannel).all() session.close() del session if message_to_send == self.previous_message or \ datetime.now(timezone.utc) < self.next_message_time: send_channel = message.channel try: if isinstance(message.channel, discord.abc.GuildChannel): dm_channel = message.author.dm_channel if not dm_channel: await message.author.create_dm() send_channel = message.author.dm_channel msg = "Your message \"{}\" has been rate-limited.".format( message.clean_content) await send_channel.send(msg) return except discord.errors.Forbidden: if isinstance(message.author, discord.abc.User): msg = "{}, please allow private messages from this bot.".format( message.author.mention) error_msg = await message.channel.send( msg) await asyncio.sleep(3) await error_msg.delete() return self.previous_message = message_to_send self.next_message_time = datetime.now( timezone.utc) + timedelta( seconds=self.config.message_delay) self.logger.info( "Outgoing message from discord: Username: %s Message: %s", minecraft_username, message_to_send) for channel in channels: discord_channel = self.discord_bot.get_channel( channel.channel_id) if not discord_channel: session = self.database_session.get_session( ) session.query(DiscordChannel).filter_by( channel_id=channel.channel_id).delete( ) session.close() continue webhooks = await discord_channel.webhooks() for webhook in webhooks: if webhook.name == "_minecraft": await webhook.send( username=minecraft_username, avatar_url= "https://visage.surgeplay.com/face/160/{}" .format(minecraft_uuid), content=message_to_discord) packet = serverbound.play.ChatPacket() packet.message = "{}: {}".format( minecraft_username, message_to_send) self.connection.write_packet(packet) else: send_channel = message.channel try: if isinstance(message.channel, discord.abc.GuildChannel): dm_channel = message.author.dm_channel if not dm_channel: await message.author.create_dm() send_channel = message.author.dm_channel msg = "Unable to send chat message: there is no Minecraft account linked to this discord " \ "account, please run `mc!register`." await send_channel.send(msg) return except discord.errors.Forbidden: if isinstance(message.author, discord.abc.User): msg = "{}, please allow private messages from this bot.".format( message.author.mention) error_msg = await message.channel.send(msg) await asyncio.sleep(3) await error_msg.delete() return finally: session.close() del session else: session.close() del session def run(self): self.logger.debug( "Checking if the server {} is online before connecting.") if not self.config.mc_online: self.logger.info("Connecting in offline mode...") while not self.is_server_online(): self.logger.info( 'Not connecting to server because it appears to be offline.' ) time.sleep(15) self.bot_username = self.config.mc_username self.connection = Connection( self.config.mc_server, self.config.mc_port, username=self.config.mc_username, handle_exception=self.minecraft_handle_exception) else: self.auth_token = authentication.AuthenticationToken() try: self.auth_token.authenticate(self.config.mc_username, self.config.mc_password) except YggdrasilError as ex: self.logger.info(ex) sys.exit(os.EX_TEMPFAIL) self.bot_username = self.auth_token.profile.name self.logger.info("Logged in as %s...", self.auth_token.profile.name) while not self.is_server_online(): self.logger.info( 'Not connecting to server because it appears to be offline.' ) time.sleep(15) self.connection = Connection( self.config.mc_server, self.config.mc_port, auth_token=self.auth_token, handle_exception=self.minecraft_handle_exception) self.register_handlers(self.connection) self.connection_retries += 1 self.reactor_thread.start() self.connection.connect() try: self.aioloop.run_until_complete( self.discord_bot.start(self.config.discord_token)) except (KeyboardInterrupt, SystemExit): # log out of discord self.aioloop.run_until_complete(self.discord_bot.logout()) # log out of minecraft self.connection.disconnect() # shut down auth server from twisted.internet import reactor reactor.callFromThread(reactor.stop) # clean up auth server thread self.reactor_thread.join() finally: # close the asyncio event loop discord uses self.aioloop.close() return self.return_code def mc_uuid_to_username(self, mc_uuid: str): if mc_uuid not in self.uuid_cache: try: short_uuid = mc_uuid.replace("-", "") mojang_response = self.req_future_session.get( "https://api.mojang.com/user/profiles/{}/names".format( short_uuid)).result().json() if len(mojang_response) > 1: # Multiple name changes player_username = mojang_response[-1]["name"] else: # Only one name player_username = mojang_response[0]["name"] self.uuid_cache[mc_uuid] = player_username return player_username except RequestException as ex: self.logger.error(ex, exc_info=True) self.logger.error( "Failed to lookup %s's username using the Mojang API.", mc_uuid) else: return self.uuid_cache[mc_uuid] def mc_username_to_uuid(self, username: str): if username not in self.uuid_cache.inv: try: player_uuid = self.req_future_session.get( "https://api.mojang.com/users/profiles/minecraft/{}". format(username)).result().json()["id"] long_uuid = uuid.UUID(player_uuid) self.uuid_cache.inv[username] = str(long_uuid) return player_uuid except RequestException: self.logger.error( "Failed to lookup %s's username using the Mojang API.", username) else: return self.uuid_cache.inv[username] def get_discord_help_string(self): help_str = ( "Admin commands:\n" "`mc!chathere`: Starts outputting server messages in this channel\n" "`mc!stopchathere`: Stops outputting server messages in this channel\n" "User commands:\n" "`mc!tab`: Sends you the content of the server's player/tab list\n" "`mc!register`: Starts the minecraft account registration process\n" "`mc!botlink`: Sends you the link to invite this bot to a guild\n" "`mc!about`: Sends you information about the running bridge\n" "To start chatting on the minecraft server, please register your account using `mc!register`." ) return help_str # https://stackoverflow.com/questions/33404752/removing-emojis-from-a-string-in-python def remove_emoji(self, dirty_string): emoji_pattern = re.compile( "[" u"\U0001F600-\U0001F64F" # emoticons u"\U0001F300-\U0001F5FF" # symbols & pictographs u"\U0001F680-\U0001F6FF" # transport & map symbols u"\U0001F1E0-\U0001F1FF" # flags (iOS) u"\U0001F900-\U0001FAFF" # CJK Compatibility Ideographs # u"\U00002702-\U000027B0" # u"\U000024C2-\U0001F251" "]+", flags=re.UNICODE) return emoji_pattern.sub(r'', dirty_string) def escape_markdown(self, md_string): # Don't mess with urls url_regex = re.compile( r'^(?:http|ftp)s?://' # http:// or https:// r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|' # domain... r'localhost|' # localhost... r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|' # ...or ipv4 r'\[?[A-F0-9]*:[A-F0-9:]+\]?)' # ...or ipv6 r'(?::\d+)?' # optional port r'(?:/?|[/?]\S+)$', re.IGNORECASE) escaped_string = "" # Split the message into pieces, each "word" speparated into a string is a piece # Discord ignores formatting characters in urls so we can't just replace the whole # string... We need to go through words one by one to find out what is a url (don't) # escape) and what isn't (escape). for piece in md_string.split(" "): if url_regex.match(piece): escaped_string += "{} ".format(piece) continue # Absolutely needs to go first or it will replace our escaping slashes! piece = piece.replace("\\", "\\\\") piece = piece.replace("_", "\\_") piece = piece.replace("*", "\\*") escaped_string += "{} ".format(piece) if escaped_string.startswith(">"): escaped_string = "\\" + escaped_string escaped_string.strip() return escaped_string def strip_colour(self, dirty_string): colour_pattern = re.compile( u"\U000000A7" # selection symbol ".", flags=re.UNICODE) return colour_pattern.sub(r'', dirty_string) def setup_logging(self, level): if level.lower() == "debug": log_level = logging.DEBUG else: log_level = logging.INFO log_format = "%(asctime)s:%(name)s:%(levelname)s:%(message)s" logging.basicConfig(filename="bridge_log.log", format=log_format, level=log_level) stdout_logger = logging.StreamHandler(sys.stdout) stdout_logger.setFormatter(logging.Formatter(log_format)) logging.getLogger().addHandler(stdout_logger) def run_auth_server(self, port): # We need to import twisted after setting up the logger because twisted hijacks our logging from twisted.internet import reactor from .auth_server import AuthFactory # Create factory factory = AuthFactory() # Listen self.logger.info("Starting authentication server on port %d", port) factory.listen("", port) reactor.run(installSignalHandlers=False) def generate_random_auth_token(self, length): letters = string.ascii_lowercase + string.digits + string.ascii_uppercase return ''.join(random.choice(letters) for i in range(length)) def handle_disconnect(self, json_data=""): self.logger.info('Disconnected.') if json_data: self.logger.info("Disconnect json data: %s", json_data) if self.connection_retries >= self.config.failsafe_retries: self.logger.info( "Failed to join the server %s times in a row. Exiting.", self.connection_retries) self.logger.info( "Use a process supervisor if you wish to automatically restart the bridge." ) # This is possibly a huge hack... Since we cannot reliably raise exceptions on this thread # for them to be caught on the main thread, we call interrupt_main to raise a KeyboardInterrupt # on main and tell it to shut the bridge down. self.return_code = os.EX_TEMPFAIL _thread.interrupt_main() return self.previous_player_list = self.player_list.copy() self.accept_join_events = False self.player_list = bidict() if self.connection.connected: self.logger.info( "Forced a disconnection because the connection is still connected." ) self.connection.disconnect(immediate=True) time.sleep(15) while not self.is_server_online(): self.logger.info( 'Not reconnecting to server because it appears to be offline.') time.sleep(15) self.logger.info('Reconnecting.') self.connection_retries += 1 self.connection.connect() def handle_disconnect_packet(self, disconnect_packet): self.handle_disconnect(disconnect_packet.json_data) def minecraft_handle_exception(self, exception, exc_info): self.logger.error("A minecraft exception occured! %s:", exception, exc_info=exc_info) self.handle_disconnect() def is_server_online(self): server = MinecraftServer.lookup("{}:{}".format(self.config.mc_server, self.config.mc_port)) try: status = server.status() del status return True except ConnectionRefusedError: return False # AttributeError: 'TCPSocketConnection' object has no attribute 'socket' # This might not be required as it happens upstream except AttributeError: return False def register_handlers(self, connection): connection.register_packet_listener(self.handle_join_game, clientbound.play.JoinGamePacket) connection.register_packet_listener(self.handle_chat, clientbound.play.ChatMessagePacket) connection.register_packet_listener( self.handle_health_update, clientbound.play.UpdateHealthPacket) connection.register_packet_listener(self.handle_disconnect_packet, clientbound.play.DisconnectPacket) connection.register_packet_listener( self.handle_tab_list, clientbound.play.PlayerListItemPacket) connection.register_packet_listener( self.handle_player_list_header_and_footer_update, clientbound.play.PlayerListHeaderAndFooterPacket) def handle_player_list_header_and_footer_update(self, header_footer_packet): self.logger.debug("Got Tablist H/F Update: header=%s", header_footer_packet.header) self.logger.debug("Got Tablist H/F Update: footer=%s", header_footer_packet.footer) self.tab_header = json.loads(header_footer_packet.header)["text"] self.tab_footer = json.loads(header_footer_packet.footer)["text"] def handle_tab_list(self, tab_list_packet): self.logger.debug("Processing tab list packet") for action in tab_list_packet.actions: if isinstance( action, clientbound.play.PlayerListItemPacket.AddPlayerAction): self.logger.debug( "Processing AddPlayerAction tab list packet, name: %s, uuid: %s", action.name, action.uuid) username = action.name player_uuid = action.uuid if action.name not in self.player_list.inv: self.player_list.inv[action.name] = action.uuid else: # Sometimes we get a duplicate add packet on join idk why return if action.name not in self.uuid_cache.inv: self.uuid_cache.inv[action.name] = action.uuid # Initial tablist backfill if self.accept_join_events: webhook_payload = { 'username': username, 'avatar_url': "https://visage.surgeplay.com/face/160/{}".format( player_uuid), 'content': '', 'embeds': [{ 'color': 65280, 'title': '**Joined the game**' }] } for webhook in self.webhooks: self.req_future_session.post(webhook, json=webhook_payload) if self.config.es_enabled: self.es_logger.log_connection( uuid=action.uuid, reason=ConnectionReason.CONNECTED, count=len(self.player_list)) return else: # The bot's name is sent last after the initial back-fill if action.name == self.bot_username: self.accept_join_events = True if self.config.es_enabled: diff = set(self.previous_player_list.keys()) - set( self.player_list.keys()) for idx, player_uuid in enumerate(diff): self.es_logger.log_connection( uuid=player_uuid, reason=ConnectionReason.DISCONNECTED, count=len(self.previous_player_list) - (idx + 1)) # Don't bother announcing the bot's own join message (who cares) but log it for analytics still if self.config.es_enabled: self.es_logger.log_connection( uuid=action.uuid, reason=ConnectionReason.CONNECTED, count=len(self.player_list)) if self.config.es_enabled: self.es_logger.log_connection(uuid=action.uuid, reason=ConnectionReason.SEEN) if isinstance( action, clientbound.play.PlayerListItemPacket.RemovePlayerAction): self.logger.debug( "Processing RemovePlayerAction tab list packet, uuid: %s", action.uuid) username = self.mc_uuid_to_username(action.uuid) player_uuid = action.uuid webhook_payload = { 'username': username, 'avatar_url': "https://visage.surgeplay.com/face/160/{}".format( player_uuid), 'content': '', 'embeds': [{ 'color': 16711680, 'title': '**Left the game**' }] } for webhook in self.webhooks: self.req_future_session.post(webhook, json=webhook_payload) del self.uuid_cache[action.uuid] if action.uuid in self.player_list: del self.player_list[action.uuid] if self.config.es_enabled: self.es_logger.log_connection( uuid=action.uuid, reason=ConnectionReason.DISCONNECTED, count=len(self.player_list)) def handle_join_game(self, join_game_packet): self.logger.info('Connected and joined game as entity id %d', join_game_packet.entity_id) self.player_list = bidict() self.connection_retries = 0 def handle_chat(self, chat_packet): json_data = json.loads(chat_packet.json_data) if "extra" not in json_data: return chat_string = "" for chat_component in json_data["extra"]: chat_string += chat_component["text"] # Handle chat message regexp_match = re.match("<(.*?)> (.*)", chat_string, re.M | re.I) if regexp_match: username = regexp_match.group(1) original_message = regexp_match.group(2) player_uuid = self.mc_username_to_uuid(username) if username.lower() == self.bot_username.lower(): # Don't relay our own messages if self.config.es_enabled: bot_message_match = re.match( "<{}> (.*?): (.*)".format(self.bot_username.lower()), chat_string, re.M | re.I) if bot_message_match: self.es_logger.log_chat_message( uuid=self.mc_username_to_uuid( bot_message_match.group(1)), display_name=bot_message_match.group(1), message=bot_message_match.group(2), message_unformatted=chat_string) self.es_logger.log_raw_message( msg_type=chat_packet.Position.name_from_value( chat_packet.position), message=chat_packet.json_data) return self.logger.info( "Incoming message from minecraft: Username: %s Message: %s", username, original_message) self.logger.debug("msg: %s", repr(original_message)) message = self.escape_markdown( self.remove_emoji(original_message.strip().replace( "@", "@\N{zero width space}"))) webhook_payload = { 'username': username, 'avatar_url': "https://visage.surgeplay.com/face/160/{}".format(player_uuid), 'content': '{}'.format(message) } for webhook in self.webhooks: self.req_future_session.post(webhook, json=webhook_payload) if self.config.es_enabled: self.es_logger.log_chat_message( uuid=player_uuid, display_name=username, message=original_message, message_unformatted=chat_string) if self.config.es_enabled: self.es_logger.log_raw_message( msg_type=chat_packet.Position.name_from_value( chat_packet.position), message=chat_packet.json_data) def handle_health_update(self, health_update_packet): if health_update_packet.health <= 0: self.logger.debug("Respawned the player because it died") packet = serverbound.play.ClientStatusPacket() packet.action_id = serverbound.play.ClientStatusPacket.RESPAWN self.connection.write_packet(packet)
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 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. 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()
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) # debug chat callback def print_chat(chat_packet): print("Message (%s): %s" % (chat_packet.field_string('position'), chat_packet.json_data)) # lists serves as output message queues outQueue = [] # boolean to tell if we are running running = True # console input callback def input_thread(): while running: text = input() outQueue.append(text) time.sleep(0.1) # helper function to insert into message queue def insert_into_queue(message, player, globalFlag): if globalFlag: outQueue.append(message) else: outQueue.append('/msg ' + player + ' ' + message) # helper function to handle commands def process_message(message, player, playerId, globalFlag): if message == '$whoami': insert_into_queue('You are ' + player + '!', player, globalFlag) if message == '$selling': try: dealFile = open('deals.json', 'r') deals = json.loads(dealFile.read()) dealFile.close() items = [] for item in deals['selling']: items.append(item['item']) insert_into_queue('Selling these items: ' + str(items), player, globalFlag) except: insert_into_queue( 'Sorry! Deals are not available at this time.', player, globalFlag) if message == '$buying': try: dealFile = open('deals.json', 'r') deals = json.loads(dealFile.read()) dealFile.close() insert_into_queue( 'Buying these items: ' + str(deals['buying']), player, globalFlag) except: insert_into_queue( 'Sorry! Deals are not available at this time.', player, globalFlag) if message == '$reps': try: dealFile = open('deals.json', 'r') deals = json.loads(dealFile.read()) dealFile.close() outQueue.append('Representatives of Astara: ' + str(deals['representatives'])) except: insert_into_queue( 'Sorry! Database is not available at this time.', player, globalFlag) if message == '$help': insert_into_queue('Hi! I\'m the Astaran Trade Bot. Minimum trade value is 1db.' + \ ' Here are some commands you can use: $selling, $buying, $price <item>, ' + \ '$whoami, $reps, $help', player, globalFlag) if message.startswith('$price '): try: query = message[7:] dealFile = open('deals.json', 'r') deals = json.loads(dealFile.read()) dealFile.close() name = '' price = '' for item in deals['selling']: for alias in item['alias']: if query.lower() == alias.lower(): name = item['item'] price = item['price'] break if name != '': break if name == '' or price == '': insert_into_queue('Sorry! No price listed for that item.', player, globalFlag) else: insert_into_queue('Astara sells ' + name + ' for ' + price, player, globalFlag) except: insert_into_queue('Sorry! No price listed for that item.', player, globalFlag) # chat processing callback def process_chat(chat_packet): position = chat_packet.field_string('position') if position == 'CHAT' or position == 'SYSTEM': data = json.loads(chat_packet.json_data) # Global Chat if data['translate'] == 'chat.type.text': # grab useful data from json message = data['with'][1] player = data['with'][0]['insertion'] hoverStr = data['with'][0]['hoverEvent']['value']['text'] start = hoverStr.index('id:\"') + 4 end = hoverStr.index('\",type:') playerId = hoverStr[start:end] # print chat message outStr = playerId + ' (' + player + '): ' + message print(outStr) # log message log = open('log.txt', 'a') log.write(outStr + '\n') log.close() # process message process_message(message, player, playerId, True) # Private Chat if data['translate'] == 'commands.message.display.incoming': # grab useful data from json message = data['with'][1]['text'] player = data['with'][0]['insertion'] hoverStr = data['with'][0]['hoverEvent']['value']['text'] start = hoverStr.index('id:\"') + 4 end = hoverStr.index('\",type:') playerId = hoverStr[start:end] # print chat message outStr = playerId + ' (' + player + ') PRIVATE: ' + message print(outStr) # log message log = open('log.txt', 'a') log.write(outStr + '\n') log.close() # process message process_message(message, player, playerId, False) # Register Debug callback #connection.register_packet_listener( # print_chat, clientbound.play.ChatMessagePacket) # Register our chatbot logic connection.register_packet_listener(process_chat, clientbound.play.ChatMessagePacket) # start network thread connection.connect() # start console thread inThread = threading.Thread(target=input_thread) inThread.start() # Main bot console loop while running: try: time.sleep(0.05) if len(outQueue) != 0: msg = outQueue.pop() if msg == '/respawn': print('Respawning...') packet = serverbound.play.ClientStatusPacket() packet.action_id = serverbound.play.ClientStatusPacket.RESPAWN connection.write_packet(packet) elif msg == '/exit': print('Disconnecting') running = False else: print('Sent Message: ' + msg) packet = serverbound.play.ChatPacket() packet.message = msg connection.write_packet(packet) except KeyboardInterrupt: outQueue.append('/exit')
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() 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()
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() 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()
class Player: __retries = 0 def __init__(self, account: str, password: str, server_address: str, port: int, version: int, auto_reconnect: bool, auto_respawn: bool, lang: Lang): self.__email = account self.__password = base64.b64encode(password.encode()) self.__lang = lang self.__logger = logging.getLogger("Auth") logging.basicConfig(level=logging.INFO) tokens = self.__get_tokens() self.__auth = authentication.AuthenticationToken( username=self.__email, access_token=tokens["access"], client_token=tokens["client"]) self.auth() self.__auto_reconnect = auto_reconnect self.__auto_respawn = auto_respawn self.__connection = Connection(address=server_address, port=port, initial_version=version, auth_token=self.__auth) if not self.__auth.authenticated: return self.username = self.__auth.profile.name self.__logger = logging.getLogger(self.username) self.__connection.register_packet_listener( self.handle_join_game, clientbound.play.JoinGamePacket) self.__connection.register_packet_listener( self.print_chat, clientbound.play.ChatMessagePacket) self.__connection.register_packet_listener( self.handle_disconnect, clientbound.play.DisconnectPacket) self.__connection.register_packet_listener( self.handle_health_change, clientbound.play.UpdateHealthPacket) self.__connection.register_exception_handler(self.handle_exception) try: self.__connection.connect() except Exception as e: self.__logger.error(str(e)) self.__retry() # def connect(self, ip, port): # self.__init(self.username Connection) def __get_tokens(self) -> dict: try: with open('./data.json', 'r') as fs: auth = json.load(fs) except FileNotFoundError: return {"access": None, "client": None} else: if self.__email in auth: return auth[self.__email] else: return {"access": None, "client": None} def __refresh_tokens(self, access: str, client: str): auth = {} try: with open('./data.json', 'r') as fs: auth = json.load(fs) except FileNotFoundError: pass finally: auth[self.__email] = {"access": access, "client": client} with open('./data.json', 'w') as fs: json.dump(auth, fs, indent=2) def auth(self): try: self.__auth.refresh() except YggdrasilError: self.__login() except ValueError: self.__login() else: self.__logger.info( self.__lang.lang("main.auth.still_valid").format( email=self.__email)) self.__refresh_tokens(access=self.__auth.access_token, client=self.__auth.client_token) def __login(self): self.__logger.info( self.__lang.lang("main.auth.login").format(email=self.__email)) try: self.__auth.authenticate(username=self.__email, password=base64.b64decode( self.__password).decode()) except YggdrasilError as e: self.__logger.error( self.__lang.lang("main.auth.error").format(email=self.__email, message=str(e))) else: self.__refresh_tokens(access=self.__auth.access_token, client=self.__auth.client_token) def reconnect(self): try: self.__connection.connect() except Exception as e: self.__logger.error(str(e)) self.__retry() # noinspection PyUnusedLocal def handle_join_game(self, join_game_packet): self.__logger.info( self.__lang.lang("player.connected").format( server=self.__connection.options.address, port=self.__connection.options.port)) self.__retries = 0 packet = serverbound.play.ClientSettingsPacket() packet.locale = self.__lang.lang_name packet.view_distance = 10 packet.chat_mode = packet.ChatMode.FULL packet.chat_colors = False packet.displayed_skin_parts = packet.SkinParts.ALL packet.main_hand = AbsoluteHand.RIGHT self.__connection.write_packet(packet) def print_chat(self, chat_packet): self.__logger.info("[{position}] {message}".format( position=chat_packet.field_string('position'), message=self.__lang.parse_json(json.loads(chat_packet.json_data)))) def handle_disconnect(self, disconnect_packet): self.__logger.warning( self.__lang.lang("player.connection.lost").format( reason=self.__lang.parse_json( json.loads(disconnect_packet.json_data)))) if self.__auto_reconnect: self.__retry() def handle_health_change(self, health_packet): self.__logger.warning( self.__lang.lang("player.health.changed").format( health=str(health_packet.health), food=str(health_packet.food), saturation=str(health_packet.food_saturation))) if self.__auto_respawn and health_packet.health == 0: self.__logger.info(self.__lang.lang("player.respawn.hint")) timer = threading.Timer(1.0, self.respawn) timer.start() def handle_exception(self, e, info): if type(info[1]) == LoginDisconnect: message = str(e).replace( 'The server rejected our login attempt with: "', '').replace('".', '') try: self.__logger.error( self.__lang.lang("player.connection.rejected").format( reason=self.__lang.parse_json(json.loads(message)))) except json.decoder.JSONDecodeError: self.__logger.error( self.__lang.lang("player.connection.rejected").format( reason=message)) elif type(info[1]) == YggdrasilError: self.__logger.error(self.__lang.lang("player.session.expired")) self.auth() timer = threading.Timer(1.0, self.reconnect) timer.start() return else: self.__logger.error("{type}: {message}".format(type=type(info[1]), message=str(e))) if self.__auto_reconnect: if not self.__connection.connected: self.__retry() def __retry(self): self.__retries += 1 if self.__retries >= 6: self.__retries = 0 return self.__logger.info( self.__lang.lang("player.connection.retry").format( times=str(self.__retries))) timer = threading.Timer(5.0, self.reconnect) timer.start() def respawn(self): packet = serverbound.play.ClientStatusPacket() packet.action_id = serverbound.play.ClientStatusPacket.RESPAWN self.__connection.write_packet(packet) self.__logger.info(self.__lang.lang("player.respawned")) def disconnect(self): self.__connection.disconnect() self.__logger.info(self.__lang.lang("player.disconnected")) def toggle_auto_respawn(self): self.__auto_respawn = not self.__auto_respawn self.__logger.info( self.__lang.lang("player.auto_respawn.toggle").format( value=self.__auto_respawn)) def toggle_auto_reconnect(self): self.__auto_reconnect = not self.__auto_reconnect self.__logger.info( self.__lang.lang("player.auto_reconnect.toggle").format( value=self.__auto_reconnect)) def chat(self, text: str): if text == "": return packet = serverbound.play.ChatPacket() packet.message = text self.__connection.write_packet(packet)
connection.register_packet_listener( handle_join_game, clientbound.play.JoinGamePacket) connection.register_packet_listener( print_chat, clientbound.play.ChatMessagePacket) connection.register_packet_listener( sound, clientbound.play.SoundEffectPacket) connection.connect() time.sleep(3) useitem() 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() 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()
def main(): args = sys.argv[1:] if (len(args) != 1): print("Uso : bot.py queue\nEx: bot.py towny") sys.exit() else: EMAIL = "" PASSWORD = "" MULTIMC_INSTANCE = "" auth = authentication.AuthenticationToken() try: auth.authenticate(EMAIL, PASSWORD) except YggdrasilError as e: print(e) sys.exit() print("Logado como %s" % auth.username) connection = Connection("dc-f626de6d73b7.earthmc.net", 25577, auth_token=auth, allowed_versions=[477]) def entra_server(join_game_packet): print("Conectado no servidor") packet = serverbound.play.ChatPacket() packet.message = ("/joinqueue %s" % (args[0])) connection.write_packet(packet) connection.register_packet_listener(entra_server, clientbound.play.JoinGamePacket) def mensagem(chat_packet): if (chat_packet.field_string( 'position' ) == "SYSTEM" and chat_packet.json_data.startswith( '{"extra":[{"color":"yellow","text":"You are currently in position ' )): result = queue_message_from_dict( json.loads(chat_packet.json_data)) print( "Pos : (%s) %s [%s]" % (result.extra[1].text[:-1], result.extra[3].text, args[0])) if (int(result.extra[1].text[:-1].replace(" ", ""), 10) <= 5): connection.disconnect() os.system('multimc -l "%s"' % (MULTIMC_INSTANCE)) elif (chat_packet.field_string('position') == "CHAT"): result = chat_message_from_dict( json.loads(chat_packet.json_data)) print("[%s] %s > %s" % (result.extra[0].hover_event.value[0].extra[1].text[:-1], result.extra[0].extra[0].text[:-2], result.extra[1].extra[0].text)) elif (chat_packet.field_string('position') != "SYSTEM"): print("UNHANDLED %s MESSAGE : \n(%s)" % (chat_packet.field_string('position'), chat_packet.json_data)) connection.register_packet_listener(mensagem, clientbound.play.ChatMessagePacket) connection.connect() while True: try: text = input() if text == "/respawn": print("Respawnando ...") 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("Tchau!") sys.exit()
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.profile.name) 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): js = ujson.loads(chat_packet.json_data) if len(js) == 1 and js.get('text'): js['translate'] = "MCDR" js['with'] = [0, 0, 0] try: translate = js['translate'] msg = js['with'][-1] if type(msg) is dict: msg = msg['text'] # 1.15.2 server message = '[{} {}] '.format( datetime.now().strftime("%Y-%m-%d %H:%M:%S"), chat_packet.field_string('position')) try: name = js['with'][0]['insertion'] except: name = None if translate == 'chat.type.announcement': # from server message += '[Server] {}'.format(msg) elif translate == 'chat.type.text': # chat message += '<{}> {}'.format(name, msg) try: uuid = js['with'][0]['hoverEvent']['contents'][ 'id'] # 1.16 server except: try: text = js['with'][0]['hoverEvent']['value']['text'] except TypeError: # 1.15.2 server text = js['with'][0]['hoverEvent']['value'][0]['text'] uuid = text[text.find(',id:"'):].split('"')[1] elif translate == 'commands.message.display.incoming': # tell message += '<{}>(tell) {}'.format(name, msg['text']) elif translate in [ 'multiplayer.player.joined', 'multiplayer.player.left' ]: # login in/out game message += '{} {} the game'.format(name, translate.split('.')[2]) elif translate == 'chat.type.emote': # me message += '* {} {}'.format(name, msg) elif translate == 'MCDR': message += js.get('text') else: message = chat_packet.json_data print(message) except: print('Cannot resolve chat json data: \n {}'.format( chat_packet.json_data)) pass 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() 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 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