wynncraft-bot/cogs/wynncraft/wynncraftcog.py

import asyncio
from redbot.core import commands
from redbot.core import Config, checks
from discord import TextChannel
import discord
import traceback
import requests
import datetime


class WynncraftCog(commands.Cog):
    def __init__(self, bot):
        self.bot = bot
        self.config = Config.get_conf(self, identifier=48775419874)
        default_guild = {
            "guild_name": None,  # OK
            "ping_levels": False,  # OK
            "ping_channel": None,  # OK
            "role_levels": [
                750098524976185525,  # 0-9
                750098542802239488,  # 10-19
                750098546883166292,  # 20-29
                750098551756947496,  # 30-39
                750098557444292740,  # 40-49
                750098560732889088,  # 50-59
                750098568194424872,  # 60-69
                750098573353418822,  # 70-79
                750098579535822918,  # 80-89
                750098584082448434,  # 90-99
                750098593976811550,  # 100+
            ],
            "role_class": {
                "mage": 750097053840965752,
                "assassin": 750097058362425417,
                "shaman": 750097056093438012,
                "archer": 750097050867204246,
                "warrior": 750097044433272833
            },
            "update_msg": 750124413529358467
        }
        default_global = {
            "log": True
        }
        self.config.register_guild(**default_guild)
        self.config.register_global(**default_global)

    @commands.command()
    @checks.admin_or_permissions(manage_guild=True)
    async def ping_channel(self, ctx, channel: TextChannel):
        i = channel.id
        await self.config.guild(ctx.guild).ping_channel.set(i)
        await self.config.guild(ctx.guild).ping_levels.set(True)
        await ctx.send("Les messages de montée de niveau seront désormais envoyés dans %s" % channel.mention)

    @commands.command()
    @checks.admin_or_permissions(manage_guild=True)
    async def ping_levels(self, ctx, state):
        if state == "true" or state == "on":
            await self.config.ping_levels.set(True)
            await ctx.send(":white_check_mark: Activé!")
        elif state == "false" or state == "off":
            await self.config.ping_levels.set(False)
            await ctx.send(":white_check_mark: Désactivé!")
        else:
            await ctx.send(":x:")

    @commands.command()
    @checks.admin_or_permissions(manage_guild=True)
    async def set_guild(self, ctx, guild_name):
        await self.config.guild(ctx.guild).guild_name.set(guild_name)
        await ctx.send(":white_check_mark: Votre guilde est désormais **%s**" % guild_name)

    @commands.command()
    @checks.is_owner()
    async def log(self, ctx, state):
        state = state.lower()
        if state == "true" or state == "on":
            await self.config.log.set(True)
            await ctx.send(":white_check_mark:")
            print("Logs on")
        elif state == "false" or state == "off":
            await self.config.log.set(False)
            await ctx.send(":white_check_mark:")
            print("Logs off")
        else:
            await ctx.send(":x:")

    async def _log(self, s):
        if await self.config.log():
            print(s)

    async def loop(self):
        await self.bot.wait_until_ready()
        last_status = {}
        while self is self.bot.get_cog("WynncraftCog"):
            await self._log("Looping guilds")
            for guild in self.bot.guilds:
                roles_combat_level = await self.config.guild(guild).role_levels()
                roles_classes = await self.config.guild(guild).role_class()
                guild_id = guild.id
                online_players = []
                await self._log("Loop id %s" % guild_id)
                try:
                    guild_name = await self.config.guild(guild).guild_name()
                    if not guild_name:
                        continue
                    r = requests.get("https://api.wynncraft.com/public_api.php?action=guildStats&command=%s" % guild_name).json()
                    for member in r["members"]:
                        member_name = member["name"]
                        await self._log("calling API for player %s" % member_name)
                        r = requests.get("https://api.wynncraft.com/v2/player/%s/stats" % member_name).json()

                        max_combat_lvl_class = None
                        if not r["data"]:
                            await self._log("%s had data %s" % (member_name, r["data"]))
                            continue
                        for cl in r["data"][0]["classes"]:
                            if guild_id not in last_status:
                                last_status[guild_id] = {}

                            if member_name not in last_status[guild_id]:
                                last_status[guild_id][member_name] = {}

                            if cl["name"] not in last_status[guild_id][member_name]:
                                last_status[guild_id][member_name][cl["name"]] = cl

                            # ping level up
                            ping_channel_id = await self.config.guild(guild).ping_channel()
                            if await self.config.guild(guild).ping_levels() and ping_channel_id:
                                await self._log("Checking for level up")
                                if cl["professions"]["combat"]["level"] > last_status[guild_id][member_name][cl["name"]]["professions"]["combat"]["level"]:
                                    ping_channel = self.bot.get_channel(ping_channel_id)
                                    await ping_channel.send(":high_brightness: %s a level up au niveau %s! GG!" % (member_name, cl["professions"]["combat"]["level"]))
                                else:
                                    await self._log("Player %s had last level %s and current %s" % (member_name, last_status[guild_id][member_name][cl["name"]]["professions"]["combat"]["level"], cl["professions"]["combat"]["level"]))
                            last_status[guild_id][member_name][cl["name"]] = cl

                            # get max_combat_lvl_class
                            if not max_combat_lvl_class or cl["professions"]["combat"]["level"] > max_combat_lvl_class["professions"]["combat"]["level"]:
                                # await self._log("cl: %s, max_combat_lvl_class: %s" % (cl, max_combat_lvl_class))
                                max_combat_lvl_class = cl

                        if r["data"][0]["meta"]["location"]["online"]:
                            await self._log("%s is online" % member_name)
                            online_players.append(r)
                        else:
                            await self._log("%s was offline: %s" % (member_name, r["data"][0]["meta"]["location"]))

                        await self._log("Setting roles")
                        # set max_combat_lvl_class role
                        discord_member = discord.utils.find(lambda m: m.display_name.lower() == member_name.lower(), guild.members)
                        if max_combat_lvl_class and discord_member:
                            await self._log("max_combat_lvl_class and discord_member True")

                            # update level
                            max_combat_lvl = max_combat_lvl_class["professions"]["combat"]["level"]
                            combat_role_index = max_combat_lvl // 10
                            if combat_role_index > 10: combat_role_index = 10
                            combat_role_id = roles_combat_level[combat_role_index]
                            combat_role = guild.get_role(combat_role_id)
                            if combat_role not in discord_member.roles:
                                await self._log("Add role: %s" % combat_role)
                                await discord_member.add_roles(combat_role)

                            roles_to_remove = list(filter(lambda role: role.id in roles_combat_level and role.id != combat_role_id, discord_member.roles))
                            if roles_to_remove:
                                await self._log("remove roles: %s" % roles_to_remove)
                                await discord_member.remove_roles(*roles_to_remove)

                            # update class
                            class_name = max_combat_lvl_class["name"]

                            class_role_id = None
                            if class_name.startswith("archer") or class_name.startswith("hunter"):
                                class_role_id = roles_classes["archer"]
                            if class_name.startswith("mage") or class_name.startswith("darkwizard"):
                                class_role_id = roles_classes["mage"]
                            if class_name.startswith("assassin") or class_name.startswith("ninja"):
                                class_role_id = roles_classes["assassin"]
                            if class_name.startswith("warrior") or class_name.startswith("knight"):
                                class_role_id = roles_classes["warrior"]
                            if class_name.startswith("shaman") or class_name.startswith("skyseer"):
                                class_role_id = roles_classes["shaman"]

                            class_role = guild.get_role(class_role_id)
                            if class_role not in discord_member.roles:
                                await self._log("Add role: %s" % class_role)
                                await discord_member.add_roles(class_role)

                            roles_to_remove = list(filter(lambda role: role.id in list(roles_classes.values()) and role.id != class_role_id, discord_member.roles))
                            if roles_to_remove:
                                await self._log("remove roles: %s" % roles_to_remove)
                                await discord_member.remove_roles(*roles_to_remove)

                        else:
                            await self._log("max_combat_lvl_class: %s, discord_member: %s (name: %s)" % (max_combat_lvl_class, discord_member, member_name))

                    # update online players
                    await self._log("Updating online list")
                    full_text = ""
                    for online_player in online_players:
                        s = ":green_circle: **%s** connecté sur %s" % (online_player["data"][0]["username"], online_player["data"][0]["meta"]["location"]["server"])
                        full_text += s + "\n"
                    if not online_players:
                        full_text = "Personne n'est connecté :disappointed_relieved:"
                    full_text += "\n*Dernière mise à jour: %s*" % datetime.datetime.now().strftime("%d-%m-%Y %H:%M:%S")
                    online_channel = self.bot.get_channel(750100968766701708)
                    update_msg = await online_channel.fetch_message(await self.config.guild(guild).update_msg())
                    await update_msg.edit(content=full_text)

                except:
                    if await self.config.log():
                        traceback.print_exc()
            await asyncio.sleep(30)