Added satle, and globle

bot.py

@@ -10,6 +10,10 @@ from dotenv import load_dotenv
 
 WORDLE_CHANNEL = 1317916234863480832
 
+MISC_GEOGRAPHY = 1317916442342981722
+
+GLOBLE_CHANNEL = 1320505660701413511
+
 load_dotenv()
 TOKEN = os.getenv('DISCORD_TOKEN')
 
@@ -22,106 +26,213 @@ bot = commands.Bot()
   guild_ids=[261345598987436033]
 )
 async def stats(interaction: discord.Interaction, game, user: discord.User = None): 
-    if game.lower() == 'wordle':
+    await interaction.response.defer()
-        channel = bot.get_channel(WORDLE_CHANNEL)
+    match game.lower():
+        case "wordle":
+            channel = bot.get_channel(WORDLE_CHANNEL)
 
-        if user is None:
+            if user is None:
-            user = interaction.user
+                user = interaction.user
 
-        WORDLE_PATTERN = r"^Wordle (\d{1,3}(?:,\d{3})*) (X|\d+)/(\d+)"
+            WORDLE_PATTERN = r"^Wordle (\d{1,3}(?:,\d{3})*) (X|\d+)/(\d+)"
 
-        total_guesses = 0
+            total_guesses = 0
-        total_games = 0
+            total_games = 0
-        wins = 0
+            wins = 0
+
+            async for message in channel.history(limit=1000):  # Limit can be adjusted
+                if message.author == user:
+                    for line in message.content.splitlines():
+                        match = re.match(WORDLE_PATTERN, line.strip())
+                        if match:
+                            total_games += 1
+                            guesses = match.group(2)
+                            if guesses != 'X':
+                                total_guesses += int(guesses)
+                                wins += 1
+                            break
+
+
+            if total_games == 0:
+                await interaction.followup.send(
+                    "No Wordle results found.",
+                    ephemeral=True
+                )
+                return
+
+            average_guesses = total_guesses / wins
+            win_rate = (wins / total_games) * 100
+
+            await interaction.followup.send(
+                f"Wordle stats for {user.mention}:\n"
+                f"Total Games Played: {total_games}\n"
+                f"Average Guesses per Winning Game: {average_guesses:.2f}\n"
+                f"Win Rate: {win_rate:.2f}%\n",
+                ephemeral=False  # Send message only to the user who called the command
+            )
+        case "connections":
+            channel = bot.get_channel(WORDLE_CHANNEL)
+
+            if user is None:
+                user = interaction.user
+
+            CONNECTIONS_PATTERN = r"^Connections\nPuzzle #(\d+)\n((?:[\u2B1B\u2B1C\u2B1D\u2B1E\u2B20]{4}\n?)+)$"
+
+            total_guesses = 0
+            total_games = 0
+            wins = 0
+            perfects = 0
+
+            async for message in channel.history(limit=1000):  # Limit can be adjusted
+                if message.author == user:
+
+                    color_grid = con.extract_connections_grid( message.content)
+
+                    if color_grid:
+
+                        guesses = con.check_connections_win(color_grid)
 
-        async for message in channel.history(limit=1000):  # Limit can be adjusted
-            if message.author == user:
-                for line in message.content.splitlines():
-                    match = re.match(WORDLE_PATTERN, line.strip())
-                    if match:
                         total_games += 1
-                        guesses = match.group(2)
+
-                        if guesses != 'X':
+                        if guesses > 0:
-                            total_guesses += int(guesses)
+                            total_guesses += guesses
                             wins += 1
-                        break
+                            perfect_game = con.is_perfect_game(color_grid)
+                            if perfect_game:
+                                perfects += 1
 
 
-        if total_games == 0:
+
-            await interaction.response.send_message(
+            if total_games == 0:
-                "No Wordle results found.",
+                await interaction.followup.send(
+                    "No Connections results found.",
+                    ephemeral=True
+                )
+                return
+
+            average_guesses = total_guesses / wins
+            win_rate = (wins / total_games) * 100
+
+            await interaction.followup.send(
+                f"Connections stats for {user.mention}:\n"
+                f"Total Games Played: {total_games}\n"
+                f"Average Guesses per Winning Game: {average_guesses:.2f}\n"
+                f"Win Rate: {win_rate:.2f}%\n"
+                f"Perfect Games: {perfects}\n",
+
+                ephemeral=False  # Send message only to the user who called the command
+            )
+        case "satle":
+            channel = bot.get_channel(MISC_GEOGRAPHY)
+
+            if user is None:
+                user = interaction.user
+
+            SATLE_PATTERN = r"🛰Satle #[0-9]+ (\d)/6"
+
+            total_guesses = 0
+            total_games = 0
+            wins = 0
+
+            async for message in channel.history(limit=1000):  # Limit can be adjusted
+                if message.author == user:
+                    lines = message.content.splitlines()
+                    for line in lines:
+                        match = re.match(SATLE_PATTERN, line.strip())
+                        if match:
+                            total_games += 1
+                            guesses = match.group(1)
+                            if lines[lines.index(line)+1].__contains__("🟩"):
+                                total_guesses += int(guesses)
+                                wins += 1
+                            break
+
+
+            if total_games == 0:
+                await interaction.followup.send(
+                    "No Satle results found.",
+                    ephemeral=True
+                )
+                return
+
+            average_guesses = total_guesses / wins
+            win_rate = (wins / total_games) * 100
+
+            await interaction.followup.send(
+                f"Satle stats for {user.mention}:\n"
+                f"Total Games Played: {total_games}\n"
+                f"Average Guesses per Winning Game: {average_guesses:.2f}\n"
+                f"Win Rate: {win_rate:.2f}%\n",
+                ephemeral=False  # Send message only to the user who called the command
+            )
+        case "globle":
+            misc_channel = bot.get_channel(MISC_GEOGRAPHY)
+            globle_channel = bot.get_channel(GLOBLE_CHANNEL)
+
+            if user is None:
+                user = interaction.user
+
+            GLOBLE_PATTERN = r"I guessed today’s Globle in ([0-9]+) tries:"
+            BAD_GLOBLE_PATTERN = r".* = ([0-9]+)"
+
+            total_guesses = 0
+            total_games = 0
+
+            async for message in misc_channel.history(limit=1000):  # Limit can be adjusted
+                if message.author == user:
+                    lines = message.content.splitlines()
+                    for line in lines:
+                        match = re.match(GLOBLE_PATTERN, line.strip())
+                        if match:
+                            total_games += 1
+                            guesses = match.group(1)
+                            total_guesses += int(guesses)
+                            break
+                        match = re.match(BAD_GLOBLE_PATTERN, line.strip())
+                        if match:
+                            total_games += 1
+                            guesses = match.group(1)
+                            total_guesses += int(guesses)
+                            break
+
+            async for message in globle_channel.history(limit=1000):  # Limit can be adjusted
+                if message.author == user:
+                    lines = message.content.splitlines()
+                    for line in lines:
+                        match = re.match(GLOBLE_PATTERN, line.strip())
+                        if match:
+                            total_games += 1
+                            guesses = match.group(1)
+                            total_guesses += int(guesses)
+                            break
+                        match = re.match(BAD_GLOBLE_PATTERN, line.strip())
+                        if match:
+                            total_games += 1
+                            guesses = match.group(1)
+                            total_guesses += int(guesses)
+                            break
+
+
+            if total_games == 0:
+                await interaction.followup.send(
+                    "No Globle results found.",
+                    ephemeral=True
+                )
+                return
+
+            average_guesses = total_guesses / total_games
+
+            await interaction.followup.send(
+                f"Globle stats for {user.mention}:\n"
+                f"Total Games Played: {total_games}\n"
+                f"Average Guesses per Game: {average_guesses:.2f}\n",
+                ephemeral=False  # Send message only to the user who called the command
+            )
+        case _:
+            await interaction.followup.send(
+                "Not a game.",
                 ephemeral=True
             )
-            return
-
-        average_guesses = total_guesses / wins
-        win_rate = (wins / total_games) * 100
-
-        await interaction.response.send_message(
-            f"Wordle stats for {user.mention}:\n"
-            f"Total Games Played: {total_games}\n"
-            f"Total Guesses: {total_guesses}\n"
-            f"Average Guesses per Winning Game: {average_guesses:.2f}\n"
-            f"Win Rate: {win_rate:.2f}%\n",
-            ephemeral=False  # Send message only to the user who called the command
-        )
-    elif game.lower() == 'connections':
-        channel = bot.get_channel(WORDLE_CHANNEL)
-
-        if user is None:
-            user = interaction.user
-
-        CONNECTIONS_PATTERN = r"^Connections\nPuzzle #(\d+)\n((?:[\u2B1B\u2B1C\u2B1D\u2B1E\u2B20]{4}\n?)+)$"
-
-        total_guesses = 0
-        total_games = 0
-        wins = 0
-        perfects = 0
-
-        async for message in channel.history(limit=1000):  # Limit can be adjusted
-            if message.author == user:
-
-                color_grid = con.extract_connections_grid( message.content)
-
-                if color_grid:
-
-                    guesses = con.check_connections_win(color_grid)
-
-                    total_games += 1
-
-                    if guesses > 0:
-                        total_guesses += guesses
-                        wins += 1
-                        perfect_game = con.is_perfect_game(color_grid)
-                        if perfect_game:
-                            perfects += 1
-
-
-
-        if total_games == 0:
-            await interaction.response.send_message(
-                "No Connections results found.",
-                ephemeral=True
-            )
-            return
-
-        average_guesses = total_guesses / wins
-        win_rate = (wins / total_games) * 100
-
-        await interaction.response.send_message(
-            f"Connections stats for {user.mention}:\n"
-            f"Total Games Played: {total_games}\n"
-            f"Average Guesses per Winning Game: {average_guesses:.2f}\n"
-            f"Win Rate: {win_rate:.2f}%\n"
-            f"Perfect Games: {perfects}\n",
-
-            ephemeral=False  # Send message only to the user who called the command
-        )
-    else:
-        await interaction.response.send_message(
-            "Not a game.",
-            ephemeral=True
-        )
 
         
 @bot.event