Refine online command interface

Author: theNatePi

cogs/looped_tasks.py

@@ -13,9 +13,11 @@ def __init__(self, bot: commands.Bot):
         self._bot = bot
         self._current_activity = 0
         self._messages_to_delete = []
+        self._previous_messages = []
         self._cooldown_for_deletion = []
         self._make_wish = True
 
+        self.online_player_cache = []
 
     def add_message_to_delete(self, cooldown: int, message: discord.Message):
         """
@@ -30,6 +32,10 @@ def add_message_to_delete(self, cooldown: int, message: discord.Message):
         self._messages_to_delete.append(message)
 
 
+    def add_message_to_previous(self, message: discord.Message):
+        self._previous_messages.append(message)
+
+
     async def _delete_messages(self):
         """
         Deletes all messages which have a cooldown of zero,
@@ -105,6 +111,13 @@ async def update_activity(self):
         """
         activity = None
 
+        new_player_cache = get_players_online()
+        if new_player_cache != self.online_player_cache:
+            for message in self._previous_messages:
+                self.add_message_to_delete(config.DELETION_COOLDOWN, message)
+            self.online_player_cache = new_player_cache
+            self._previous_messages.clear()
+
         await self._delete_messages()
         self._make_wish = await handle_server_commands(self._make_wish)
 

cogs/mcstatus_commands.py

@@ -6,36 +6,80 @@
 from discord.ext import commands
 from typing import List
 from server import get_players_online, setup_player
-
+from PIL import Image
+from io import BytesIO
+import os
 
 class McStatus(commands.Cog, name = config.MCSTATUS_COG_NAME):
     """Commands which give info about the server's status"""
     def __init__(self, bot: commands.Bot):
         self._bot = bot
 
-
     @staticmethod
-    def _create_online_embed(players: List[str]) -> discord.Embed:
+    def _create_embed_player_image(previous_images, next_image):
+        image1 = previous_images.convert("RGBA")
+        image2 = next_image.convert("RGBA")
+        gap = 10
+
+        (width1, height1) = image1.size
+        (width2, height2) = image2.size
+
+        result_width = width1 + gap + width2
+        result_height = max(height1, height2)
+
+        # Create a new image with RGBA mode to support transparency
+        result = Image.new('RGBA', (result_width, result_height), (255, 255, 255, 0))
+        result.paste(im = image1, box = (0, 0))
+
+        # Extract the alpha channel of the second image
+        image2_alpha = image2.split()[-1]
+        result.paste(im = image2, box = (width1 + gap, 0), mask = image2_alpha)
+
+        # Save the merged image as PNG to preserve transparency
+        return result
+
+    def _create_online_embed(self, players: List[tuple[str, Image.Image]]) -> discord.Embed:
         """
         Creates an embed for the !online command
 
         :param players: List of players currently online
         :return: discord.Embed to be sent by the !online command
         """
-        print(players)
+        file = None
+
         if players:
-            players_formatted = '\n'.join(players)
+            script_dir = os.path.dirname(os.path.abspath(__file__))
+            file_path = os.path.join(script_dir, "temp.png")
+
+            usernames = []
+            for player in players:
+                usernames.append(player[0])
+
+            image = players[0][1]
+            if len(players) > 1:
+                for player in players[1:]:
+                    image = self._create_embed_player_image(image, player[1])
+
+
+            image.save(file_path)
+
+            players_formatted = '\n'.join(usernames)
             players_formatted = f'```\n{players_formatted}\n```'
 
             embed = discord.Embed(title = 'The following players are online!',
                                   color = discord.Color.green(),
                                   description = players_formatted)
+            embed.set_footer(text = "This message will disappear when outdated")
+
+            file = discord.File(file_path, filename = "image.png")
+            embed.set_image(url = "attachment://image.png")
+
+            os.remove(file_path)
         else:
             embed = discord.Embed(title = 'No one is online!',
                                   color = discord.Color.red())
 
-        return embed
-
+        return embed, file
 
     @commands.command(name = 'online', description = config.ONLINE_DESCRIPTION, help = config.ONLINE_HELP)
     async def _online(self, ctx: commands.Context):
@@ -44,16 +88,19 @@ async def _online(self, ctx: commands.Context):
 
         :param ctx: Message context sent by the Discord API
         """
-        original_message = await ctx.send('Loading...')
+        loading_message = await ctx.send('Loading...')
         try:
-            players = get_players_online()
+            _loop_cog = self._bot.get_cog('LoopedTasks')
+            players = _loop_cog.online_player_cache
+
+            embed, file = self._create_online_embed(players)
+            # await original_message.edit(content = None, embed = embed)
+            await loading_message.delete()
+            original_message = await ctx.send(content = None, embed = embed, file = file)
 
-            embed = self._create_online_embed(players)
-            await original_message.edit(content = None, embed = embed)
 
-            loop_cog = self._bot.get_cog('LoopedTasks')
-            loop_cog.add_message_to_delete(config.DELETION_COOLDOWN, original_message)
-            loop_cog.add_message_to_delete(config.DELETION_COOLDOWN, ctx.message)
+            _loop_cog.add_message_to_previous(original_message)
+            _loop_cog.add_message_to_previous(ctx.message)
         except Exception as exc:
             print(f"ERROR during !online: {exc}")
             await original_message.edit(content = config.ONLINE_ERROR)

server/commands.py

@@ -1,10 +1,10 @@
-from .status import _send_rcon_command
+from .utils import send_rcon_command
 import asyncio
 import datetime
 
 
 async def send_eleven_eleven():
-    _send_rcon_command('/tellraw @a ["",{"text":"it is 11:11, ","color":"dark_purple"},{"text":"make a wish! ✨","color":"dark_purple","italic":true}]')
+    send_rcon_command('/tellraw @a ["",{"text":"it is 11:11, ","color":"dark_purple"},{"text":"make a wish! ✨","color":"dark_purple","italic":true}]')
 
 async def handle_server_commands(make_wish):
     # Handle the 11:11 notification
@@ -19,6 +19,5 @@ async def handle_server_commands(make_wish):
     return make_wish
 
 def setup_player(player_name: str):
-    _send_rcon_command(f'/whitelist add {player_name}')
-    _send_rcon_command(f'/spawnpoint {player_name} 2969 67 -9608')
-    _send_rcon_command(f'/tellraw @a "Added player {player_name}"')
+    send_rcon_command(f'/whitelist add {player_name}')
+    send_rcon_command(f'/tellraw @a "Added player {player_name}"')

server/status.py

@@ -1,6 +1,7 @@
+from .utils import send_rcon_command, get_player_head
 from mcstatus import JavaServer
-from mcrcon import MCRcon
 from collections import namedtuple
+from PIL import Image
 import config
 
 serverInfo = namedtuple('serverInfo', ['players', 'num_online'])
@@ -10,43 +11,47 @@
 
 
 def connect_to_server() -> JavaServer:
-    """
-    Connects to the server defined in config
-    :return: JavaServer connection
-    """
-    server = JavaServer(config.SERVER, config.QUERY_PORT)
-    return server
+	"""
+	Connects to the server defined in config
+	:return: JavaServer connection
+	"""
+	server = JavaServer(config.SERVER, config.QUERY_PORT)
+	return server
 
 
 def get_info_from_server(server: JavaServer) -> serverInfo:
-    """
-    Gets info from JavaServer connection
-
-    :param server: JavaServer connection from connect_to_server method
-    :return: ServerInfo namedtuple
-    """
-    status = server.status().raw
-    num_online = status['players']['online']
-    if num_online == 0:
-        server_info = serverInfo([], num_online)
-    else:
-        players = [user['name'] for user in status['players']['sample']]
-        server_info = serverInfo(players, num_online)
-
-    return server_info
-
-def _send_rcon_command(command: str) -> str:
-	with MCRcon(f"{config.SERVER}", config.RCON_PASSWORD, port=config.RCON_PORT) as mcr:
-		resp = mcr.command(command)
-		return resp
-
-def get_players_online() -> list[str]:
-	raw_players = _send_rcon_command("/list")
+	"""
+	Gets info from JavaServer connection
+
+	:param server: JavaServer connection from connect_to_server method
+	:return: ServerInfo namedtuple
+	"""
+	status = server.status().raw
+	num_online = status['players']['online']
+	if num_online == 0:
+		server_info = serverInfo([], num_online)
+	else:
+		players = [user['name'] for user in status['players']['sample']]
+		server_info = serverInfo(players, num_online)
+
+	return server_info
+
+def get_players_online() -> list[tuple[str, Image.Image]]:
+	player_head_url = "https://minotar.net/helm/{username}/50.png"
+
+	raw_players = send_rcon_command("/list")
 	raw_players = raw_players.split(":")[1].split(",")
 	players = []
 	for player in raw_players:
 		players.append(player.strip())
 
 	if players == [""]:
-		return []
-	return players
+		players = []
+
+	response = []
+	for player in players:
+		_formatted_url = player_head_url.format(username = player)
+		player_head = get_player_head(_formatted_url)
+		response.append((player, player_head))
+
+	return response

server/utils.py

@@ -0,0 +1,24 @@
+from mcrcon import MCRcon
+from io import BytesIO
+from PIL import Image
+import requests
+import config
+
+def send_rcon_command(command: str) -> str:
+	with MCRcon(f"{config.SERVER}", config.RCON_PASSWORD, port=config.RCON_PORT) as mcr:
+		resp = mcr.command(command)
+		return resp
+
+def _make_api_request(url: str) -> requests.Response:
+	response = requests.get(url)
+	response.raise_for_status()  # Raise an error on bad status code
+	return response
+
+def _get_image_from_response(response: requests.Response) -> Image.Image:
+	image = Image.open(BytesIO(response.content))
+	return image
+
+def get_player_head(url: str) -> Image.Image:
+	response = _make_api_request(url)
+	head = _get_image_from_response(response)
+	return head