Fixed sorting on either int or time record.

cogs/post_highscores/__init__.py

@@ -3,7 +3,8 @@ Bot command to post the highscores
 """
 
 from nextcord.ext import commands
-import highscores  # pylint: disable=import-error
+from highscores import highscores_config  # pylint: disable=import-error
+from highscores import highscores_data  # pylint: disable=import-error
 from utils import data_storage  # pylint: disable=import-error
 from utils import highscore_message  # pylint: disable=import-error
 
@@ -17,24 +18,25 @@ class PostHighscores(commands.Cog, name="Post Highscores"):
     @commands.command(name="post-scores")
     async def post_highscores(self, ctx: commands.Context):
         """
-        A command which posts the highscore in the designated channel. Sends warning if no channel has been registered.
+        A command which posts the highscore in the designated channel. Sends warning if no channel
+        has been registered.
         Usage:
         ```
         ?post-scores
         ```
         """
-        # temporarily sending config data...
-        channel_id = highscores.highscores_data["channel_id"]
+        channel_id = highscores_data["channel_id"]
         print(f"Printing out highscores information in channel {channel_id}")
         channel = self.bot.get_channel(channel_id)
         if channel is None:
-            response = 'Registered Highscores channel does not exist or was never registered. Register with "?register" command.'
+            response = 'Registered Highscores channel does not exist or was never registered. \
+                Register with "?register" command.'
             await ctx.send(response)
             return
-        for boss in highscores.highscores_config["bosses"]:
-            await highscore_message.send_highscore_message(channel, boss)
+        for boss in highscores_config["bosses"]:
+            await highscore_message.send_highscore_message(channel, boss["boss"])
 
-        data_storage.save_highscores_data(highscores.highscores_data)
+        data_storage.save_highscores_data(highscores_data)
 
 
 # This function will be called when this extension is loaded.

cogs/register_highscore_channel/__init__.py

@@ -3,7 +3,7 @@ Bot command to register the highscores channel
 """
 
 from nextcord.ext import commands
-import highscores  # pylint: disable=import-error
+from highscores import highscores_data  # pylint: disable=import-error
 from utils import data_storage  # pylint: disable=import-error
 
 
@@ -24,8 +24,8 @@ class RegisterHighscoreChannel(commands.Cog, name="Register HighScore Channel"):
         print(f"Registering {ctx.channel.id}.")
         # respond to the message
         await ctx.send(f"Registered <#{ctx.channel.id}> as channel to post highscores in.")
-        highscores.highscores_data["channel_id"] = ctx.channel.id
-        data_storage.save_highscores_data(highscores.highscores_data)
+        highscores_data["channel_id"] = ctx.channel.id
+        data_storage.save_highscores_data(highscores_data)
 
 
 # This function will be called when this extension is loaded.

cogs/score/__init__.py

@@ -0,0 +1,33 @@
+"""
+Bot command to submit a score
+"""
+
+from nextcord.ext import commands
+from utils import highscore_manage  # pylint: disable=import-error
+
+# from utils import highscore_manage  # pylint: disable=import-error
+
+
+class RegisterHighscoreChannel(commands.Cog, name="Score"):
+    """Actions of bot command"""
+
+    def __init__(self, bot: commands.Bot):
+        self.bot = bot
+
+    @commands.command(name="score")
+    async def score(self, ctx: commands.Context, boss_name: str, category: str, score: str):
+        """A command which calls a function to submit the score to highscores. Gathers required
+        information from command and passes on.
+        Usage:
+        ```
+        ?score "Boss Name" "Category" "score"
+        ```
+        """
+        await highscore_manage.submit_score(self, ctx, boss_name, category, score)
+
+
+# This function will be called when this extension is loaded.
+# It is necessary to add these functions to the bot.
+def setup(bot: commands.Bot):
+    """Adds functon to bot"""
+    bot.add_cog(RegisterHighscoreChannel(bot))

highscores_config.json

@@ -181,22 +181,22 @@
             "hardmode": false
         }
     ],
-    "categories": [
-        {
-            "category": "Kill Count",
+    "categories": {
+        "Kill Count": {
             "hardmode": true,
-            "ascending": false
+            "ascending": false,
+            "is_time_record": false
         },
-        {
-            "category": "Kill Time",
+        "Kill Time": {
             "hardmode": true,
-            "ascending": true
+            "ascending": true,
+            "is_time_record": true
         },
-        {
-            "category": "Spooned Log",
+        "Spooned Log": {
             "hardmode": false,
-            "ascending": true
+            "ascending": true,
+            "is_time_record": false
         }
-    ],
+    },
     "highscore_size": 3
 }

utils/data_storage.py

@@ -21,21 +21,16 @@ def open_highscores_data():
         # create the json object
         data = {"channel_id": -1}
         config = open_highscores_config()
-        size = config["highscore_size"]
         for boss in config["bosses"]:
-            data[boss["boss"]] = {"message_id": -1}
-            for category in config["categories"]:
+            data[boss["boss"]] = {"message_id": 0}
+            boss_categories = {}
+            for key, value in config["categories"].items():
                 rank_list = []
-                for i in range(size):  # pylint: disable=unused-variable
-                    rank = {"player": "", "score": -1}
-                    rank_list.append(rank)
-                data[boss["boss"]][category["category"]] = rank_list
-                if boss["hardmode"] and category["hardmode"]:
+                boss_categories[key] = rank_list
+                if boss["hardmode"] and value["hardmode"]:
                     rank_list = []
-                    for i in range(size):  # pylint: disable=unused-variable
-                        rank = {"player": "", "score": -1}
-                        rank_list.append(rank)
-                    data[boss["boss"]][category["category"] + "_hardmode"] = rank_list
+                    boss_categories["Hardmode " + key] = rank_list
+            data[boss["boss"]]["categories"] = boss_categories
     return data
 
 

utils/highscore_manage.py

@@ -0,0 +1,60 @@
+"""
+Contains various functions for managing the highscores data
+"""
+
+from nextcord.ext import commands
+from highscores import highscores_config  # pylint: disable=import-error
+from highscores import highscores_data  # pylint: disable=import-error
+from utils import highscore_message  # pylint: disable=import-error
+from utils import data_storage  # pylint: disable=import-error
+
+
+async def submit_score(self, ctx: commands.Context, boss_name: str, category: str, score: str):
+    """
+    Adds a score to the high scores and sorts. Removes a score if larger than size limit.
+    @param boss: the boss to add score to
+    @param category: the category to add score to
+    @param user: user who submitted score
+    @param score: score (int) to add
+    """
+    # TODO update user submission to not have dupe users
+
+    # create score tuple for either time or int
+    # define sort index
+    if highscores_config["categories"][category]["is_time_record"]:
+        score_list = score.split(":")
+        minutes = score_list[0]
+        seconds = score_list[1]
+        score_seconds = int(minutes) * 60 + int(seconds)
+        score_tuple = (ctx.author.display_name, score, score_seconds)
+        sort_index = 2
+
+    else:
+        score_tuple = (ctx.author.display_name, int(score))
+        sort_index = 1
+
+    scores = highscores_data[boss_name]["categories"][category]
+    scores.append(score_tuple)
+
+    # sort scores.
+    ascending = highscores_config["categories"][category]["ascending"]
+    scores.sort(key=lambda x: x[sort_index], reverse=not ascending)
+
+    # enforce highscore size
+    while len(scores) > highscores_config["highscore_size"]:
+        scores.pop()
+    highscores_data[boss_name]["categories"][category] = scores
+
+    # edit message
+    channel_id = highscores_data["channel_id"]
+    print(f"Editting message {channel_id}")
+    channel = self.bot.get_channel(channel_id)
+    if channel is None:
+        response = 'Registered Highscores channel does not exist or was never registered. \
+            Register with "?register" command.'
+        await ctx.send(response)
+        return
+    await highscore_message.send_highscore_message(channel, boss_name)
+
+    # save data
+    data_storage.save_highscores_data(highscores_data)

utils/highscore_message.py

@@ -3,58 +3,48 @@ Contains various functions for sending/editing the highscore messages.
 """
 
 import nextcord
-import highscores  # pylint: disable=import-error
+from highscores import highscores_config  # pylint: disable=import-error
+from highscores import highscores_data  # pylint: disable=import-error
 
 
-def format_highscore_message(boss):
+def format_highscore_message(boss_name: str):
     """
-    returns a formattedd string for a boss's highscore
+    returns a formatted string for a boss's highscore
     @param boss: the dictionary object for the boss
     @return the formatted string
     """
-    boss_name = boss["boss"]
     ret_string = f"**{boss_name}**\n"
+    boss_data = highscores_data[boss_name]
 
     # Gather all categories and add to string
-    for category in highscores.highscores_config["categories"]:
-        category_name = category["category"]
-        ret_string += f"{category_name}".ljust(30, " ")
+    for key, value in boss_data["categories"].items():
+        ret_string += f"{key}".ljust(50, " ")
     ret_string += "\n"
 
-    highscore_size = highscores.highscores_config["highscore_size"]
+    highscore_size = highscores_config["highscore_size"]
 
-    # list rankings
+    # list rankings in a single line. Start with first place for each category and then continue
     for i in range(highscore_size):
-        for category in highscores.highscores_config["categories"]:
-            ret_string += f"{i+1}: submit your score".ljust(30, " ")
+        for key, value in boss_data["categories"].items():
+            if len(value) > i:
+                score = value[i]
+                ret_string += f"{i+1}: {score[0]} - {score[1]}".ljust(50, " ")
+            else:
+                ret_string += f"{i+1}: submit your score".ljust(50, " ")
         ret_string += "\n"
 
-    # if boss is hardmode, repeat above for hardmode applicable categories
-    if boss["hardmode"]:
-        for category in highscores.highscores_config["categories"]:
-            if category["hardmode"]:
-                category_name = category["category"]
-                ret_string += f"{category_name}".ljust(30, " ")
-
-        ret_string += "\n"
-
-        for i in range(highscore_size):
-            for category in highscores.highscores_config["categories"]:
-                if category["hardmode"]:
-                    ret_string += f"{i+1}: (name here)".ljust(30, " ")
-            ret_string += "\n"
     return ret_string
 
 
-async def send_highscore_message(channel, boss):
+async def send_highscore_message(channel, boss_name: str):
     """
     Function takes care of checking if a message exists for a boss, then creating and sending/editing the message
     @param channel: the channel to send the message in/search for message id
     @param boss: the boss to send the message about
     """
-    highscore_string = format_highscore_message(boss)
+    highscore_string = format_highscore_message(boss_name)
 
-    message_id = highscores.highscores_data[boss["boss"]]["message_id"]
+    message_id = highscores_data[boss_name]["message_id"]
     try:
         message = await channel.fetch_message(message_id)
         await message.edit(content=highscore_string)
@@ -62,4 +52,4 @@ async def send_highscore_message(channel, boss):
         # message doesn't exist.
         message = await channel.send(highscore_string)
         message_id = message.id
-        highscores.highscores_data[boss["boss"]]["message_id"] = message_id
+        highscores_data[boss_name]["message_id"] = message_id