Added dungeons stats to `/moo stalkskyblock`

4 files changed, 251 insertions, 1 deletions

diff --git a/src/main/java/de/cowtipper/cowlection/command/MooCommand.java b/src/main/java/de/cowtipper/cowlection/command/MooCommand.java
index d3dc658..7799e10 100644
--- a/src/main/java/de/cowtipper/cowlection/command/MooCommand.java
+++ b/src/main/java/de/cowtipper/cowlection/command/MooCommand.java
@@ -415,6 +415,85 @@ public class MooCommand extends CommandBase {
                 slayerLevelsComponent.setHover(slayerLevelsTooltipComponent.appendFreshSibling(new MooChatComponent(slayerLevelsTooltip.toString()).white()));
                 sbStats.appendFreshSibling(slayerLevelsComponent);
 
+                // dungeons:
+                MooChatComponent dungeonsComponent = null;
+                HySkyBlockStats.Profile.Dungeons dungeons = member.getDungeons();
+                boolean hasPlayedDungeons = dungeons != null && dungeons.hasPlayed();
+                if (hasPlayedDungeons) {
+                    DataHelper.DungeonClass selectedClass = dungeons.getSelectedClass();
+
+                    MooChatComponent dungeonHover = new MooChatComponent("Dungeoneering").gold().bold();
+                    int selectedClassLevel = dungeons.getSelectedClassLevel();
+                    dungeonsComponent = new MooChatComponent.KeyValueChatComponent("Dungeoneering", selectedClass.getName() + " " + (MooConfig.useRomanNumerals() ? Utils.convertArabicToRoman(selectedClassLevel) : selectedClassLevel))
+                            .setHover(dungeonHover);
+
+
+                    // for each class (Archer, Berserk, ...)
+                    Map<DataHelper.DungeonClass, Integer> classLevels = dungeons.getClassLevels();
+                    if (classLevels != null && !classLevels.isEmpty()) {
+                        dungeonHover.appendFreshSibling(new MooChatComponent("Classes:").gold());
+                        for (Map.Entry<DataHelper.DungeonClass, Integer> classEntry : classLevels.entrySet()) {
+                            String classLevel = (MooConfig.useRomanNumerals() ? Utils.convertArabicToRoman(classEntry.getValue()) : String.valueOf(classEntry.getValue()));
+                            dungeonHover.appendFreshSibling(new MooChatComponent.KeyValueChatComponent((classEntry.getKey() == selectedClass ? "\u279C " : "   ") + classEntry.getKey().getName(), classLevel));
+                        }
+                    }
+
+                    // for each dungeon type (Catacombs, ...)
+                    Map<String, HySkyBlockStats.Profile.Dungeons.Type> dungeonTypes = dungeons.getDungeonTypes();
+                    if (dungeonTypes != null && !dungeonTypes.isEmpty()) {
+                        // for each dungeon type: catacombs, ...
+                        for (Map.Entry<String, HySkyBlockStats.Profile.Dungeons.Type> dungeonTypeEntry : dungeonTypes.entrySet()) {
+                            // dungeon type entry for chat
+                            HySkyBlockStats.Profile.Dungeons.Type dungeonType = dungeonTypeEntry.getValue();
+                            String dungeonTypeName = Utils.fancyCase(dungeonTypeEntry.getKey());
+                            dungeonsComponent.appendFreshSibling(new MooChatComponent.KeyValueChatComponent("   " + dungeonTypeName, dungeonType.getSummary()))
+                                    .setHover(dungeonHover);
+                            // dungeon type entry for tooltip
+                            int dungeonTypeLevel = dungeonTypeEntry.getValue().getLevel();
+                            dungeonHover.appendFreshSibling(new MooChatComponent.KeyValueChatComponent(dungeonTypeName, "Level " + (MooConfig.useRomanNumerals() ? Utils.convertArabicToRoman(dungeonTypeLevel) : dungeonTypeLevel)));
+
+                            // for each floor
+                            Map<String, StringBuilder> floorStats = new LinkedHashMap<>();
+                            // ... add completed floors:
+                            if (dungeonType.getTierCompletions() != null) {
+                                for (Map.Entry<String, Integer> floorCompletions : dungeonType.getTierCompletions().entrySet()) {
+                                    StringBuilder floorSummary = new StringBuilder();
+                                    floorStats.put(floorCompletions.getKey(), floorSummary);
+                                    // completed floor count:
+                                    floorSummary.append(floorCompletions.getValue());
+                                }
+                            }
+                            // ... add played floors
+                            for (Map.Entry<String, Integer> floorPlayed : dungeonType.getTimesPlayed().entrySet()) {
+                                StringBuilder floorSummary = floorStats.get(floorPlayed.getKey());
+                                if (floorSummary == null) {
+                                    // hasn't beaten this floor, but already attempted it
+                                    floorSummary = new StringBuilder("0");
+                                    floorStats.put(floorPlayed.getKey(), floorSummary);
+                                }
+                                // played floor count:
+                                floorSummary.append(EnumChatFormatting.DARK_GRAY).append(" / ").append(EnumChatFormatting.YELLOW).append(floorPlayed.getValue());
+                            }
+                            // ... add best scores
+                            for (Map.Entry<String, Integer> bestScores : dungeonType.getBestScore().entrySet()) {
+                                StringBuilder floorSummary = floorStats.getOrDefault(bestScores.getKey(), new StringBuilder());
+                                // best floor score:
+                                floorSummary.append(EnumChatFormatting.DARK_GRAY).append(" (").append(EnumChatFormatting.WHITE).append(bestScores.getValue()).append(EnumChatFormatting.DARK_GRAY).append(")");
+                            }
+
+                            // add floor stats to dungeon type:
+                            for (Map.Entry<String, StringBuilder> floorInfo : floorStats.entrySet()) {
+                                dungeonHover.appendFreshSibling(new MooChatComponent.KeyValueChatComponent("   Floor " + floorInfo.getKey(), floorInfo.getValue().toString()));
+                            }
+                        }
+                        dungeonHover.appendFreshSibling(new MooChatComponent(" Floor nr: completed / total floors (best score)").gray().italic());
+                    }
+                }
+                if (!hasPlayedDungeons) {
+                    dungeonsComponent = new MooChatComponent.KeyValueChatComponent("Dungeons", EnumChatFormatting.ITALIC + "never played");
+                }
+                sbStats.appendFreshSibling(dungeonsComponent);
+
                 // pets:
                 Pet activePet = null;
                 Pet bestPet = null;
diff --git a/src/main/java/de/cowtipper/cowlection/data/DataHelper.java b/src/main/java/de/cowtipper/cowlection/data/DataHelper.java
index 37dd4a3..ceae06f 100644
--- a/src/main/java/de/cowtipper/cowlection/data/DataHelper.java
+++ b/src/main/java/de/cowtipper/cowlection/data/DataHelper.java
@@ -1,5 +1,6 @@
 package de.cowtipper.cowlection.data;
 
+import com.google.gson.annotations.SerializedName;
 import de.cowtipper.cowlection.util.Utils;
 import net.minecraft.util.EnumChatFormatting;
 
@@ -92,7 +93,12 @@ public final class DataHelper {
     }
 
     public enum DungeonClass {
-        ARCHER('A'), BERSERK('B'), HEALER('H'), MAGE('M'), TANK('T'), UNKNOWN('U');
+        @SerializedName("archer") ARCHER('A'),
+        @SerializedName("berserk") BERSERK('B'),
+        @SerializedName("healer") HEALER('H'),
+        @SerializedName("mage") MAGE('M'),
+        @SerializedName("tank") TANK('T'),
+        @SerializedName("") UNKNOWN('U');
         private final char shortName;
 
         DungeonClass(char shortName) {
@@ -111,6 +117,10 @@ public final class DataHelper {
         public char getShortName() {
             return shortName;
         }
+
+        public String getName() {
+            return Utils.fancyCase(name());
+        }
     }
 
     public static Map<String, String> getMinions() {
diff --git a/src/main/java/de/cowtipper/cowlection/data/HySkyBlockStats.java b/src/main/java/de/cowtipper/cowlection/data/HySkyBlockStats.java
index 05c1dd6..679a575 100644
--- a/src/main/java/de/cowtipper/cowlection/data/HySkyBlockStats.java
+++ b/src/main/java/de/cowtipper/cowlection/data/HySkyBlockStats.java
@@ -3,6 +3,7 @@ package de.cowtipper.cowlection.data;
 import com.google.common.collect.ComparisonChain;
 import com.mojang.realmsclient.util.Pair;
 import com.mojang.util.UUIDTypeAdapter;
+import de.cowtipper.cowlection.config.MooConfig;
 import de.cowtipper.cowlection.util.Utils;
 import net.minecraft.nbt.CompressedStreamTools;
 import net.minecraft.nbt.NBTTagCompound;
@@ -124,6 +125,7 @@ public class HySkyBlockStats {
             private double experience_skill_taming = -1;
             private Map<String, SlayerBossDetails> slayer_bosses;
             private List<Pet> pets;
+            private Dungeons dungeons;
 
             /**
              * No-args constructor for GSON
@@ -188,6 +190,10 @@ public class HySkyBlockStats {
                 return slayerLevels;
             }
 
+            public Dungeons getDungeons() {
+                return dungeons;
+            }
+
             public List<Pet> getPets() {
                 pets.sort((p1, p2) -> ComparisonChain.start().compare(p2.active, p1.active).compare(p2.getRarity(), p1.getRarity()).compare(p2.exp, p1.exp).result());
                 return pets;
@@ -254,6 +260,96 @@ public class HySkyBlockStats {
             }
         }
 
+        public static class Dungeons {
+            private Map<String, Type> dungeon_types;
+            private Map<DataHelper.DungeonClass, ClassDetails> player_classes;
+            private DataHelper.DungeonClass selected_dungeon_class;
+
+            public Map<String, Type> getDungeonTypes() {
+                return dungeon_types;
+            }
+
+            public Map<DataHelper.DungeonClass, Integer> getClassLevels() {
+                Map<DataHelper.DungeonClass, Integer> classLevels = new TreeMap<>();
+                for (Map.Entry<DataHelper.DungeonClass, ClassDetails> classEntry : player_classes.entrySet()) {
+                    classLevels.put(classEntry.getKey(), classEntry.getValue().getLevel());
+                }
+                return classLevels;
+            }
+
+            public DataHelper.DungeonClass getSelectedClass() {
+                return selected_dungeon_class;
+            }
+
+            public boolean hasPlayed() {
+                if (dungeon_types != null) {
+                    for (Type dungeonType : dungeon_types.values()) {
+                        if (dungeonType != null && dungeonType.hasPlayed()) {
+                            return true;
+                        }
+                    }
+                }
+                return false;
+            }
+
+            public int getSelectedClassLevel() {
+                return player_classes.get(selected_dungeon_class).getLevel();
+            }
+
+            public static class Type {
+                private Map<String, Integer> times_played;
+                private Map<String, Integer> tier_completions;
+                private Map<String, Integer> best_score;
+                private int highest_tier_completed;
+                private double experience;
+
+                public Map<String, Integer> getTimesPlayed() {
+                    return times_played;
+                }
+
+                public Map<String, Integer> getTierCompletions() {
+                    return tier_completions;
+                }
+
+                public Map<String, Integer> getBestScore() {
+                    return best_score;
+                }
+
+                public int getLevel() {
+                    return XpTables.Dungeoneering.DUNGEON.getLevel(experience);
+                }
+
+                public boolean hasPlayed() {
+                    return experience > 0;
+                }
+
+                /**
+                 * Level [lvl] ([amount]x Floor [highest])
+                 *
+                 * @return summary text
+                 */
+                public String getSummary() {
+                    String floorCompletion;
+                    if (tier_completions != null) {
+                        int highestTierCompletions = tier_completions.get(String.valueOf(highest_tier_completed));
+                        floorCompletion = "" + highestTierCompletions + EnumChatFormatting.GRAY + "x " + EnumChatFormatting.YELLOW + "Floor " + (MooConfig.useRomanNumerals() ? Utils.convertArabicToRoman(highest_tier_completed) : highest_tier_completed);
+                    } else {
+                        // played dungeons but never completed a floor
+                        floorCompletion = "not a single floor...";
+                    }
+                    return "Level " + getLevel() + EnumChatFormatting.GRAY + " (beaten " + EnumChatFormatting.YELLOW + floorCompletion + EnumChatFormatting.GRAY + ")";
+                }
+            }
+
+            private static class ClassDetails {
+                private double experience;
+
+                public int getLevel() {
+                    return XpTables.Dungeoneering.CLASS.getLevel(experience);
+                }
+            }
+        }
+
         public static class Banking {
             private double balance;
             // private List<Transaction> transactions;
diff --git a/src/main/java/de/cowtipper/cowlection/data/XpTables.java b/src/main/java/de/cowtipper/cowlection/data/XpTables.java
index 260983e..391f90a 100644
--- a/src/main/java/de/cowtipper/cowlection/data/XpTables.java
+++ b/src/main/java/de/cowtipper/cowlection/data/XpTables.java
@@ -250,4 +250,69 @@ public class XpTables {
             }
         }
     }
+
+    public enum Dungeoneering {
+        CLASS, // classes: Archer, Berserk, Healer, Mage, Tank
+        DUNGEON; // dungeon types: Catacombs, ...
+
+        private static final TreeMap<Integer, Integer> XP_TO_LEVEL = new TreeMap<>();
+
+        static {
+            XP_TO_LEVEL.put(0, 0);
+            XP_TO_LEVEL.put(50, 1);
+            XP_TO_LEVEL.put(125, 2);
+            XP_TO_LEVEL.put(235, 3);
+            XP_TO_LEVEL.put(395, 4);
+            XP_TO_LEVEL.put(625, 5);
+            XP_TO_LEVEL.put(955, 6);
+            XP_TO_LEVEL.put(1425, 7);
+            XP_TO_LEVEL.put(2095, 8);
+            XP_TO_LEVEL.put(3045, 9);
+            XP_TO_LEVEL.put(4385, 10);
+            XP_TO_LEVEL.put(6275, 11);
+            XP_TO_LEVEL.put(8940, 12);
+            XP_TO_LEVEL.put(12700, 13);
+            XP_TO_LEVEL.put(17960, 14);
+            XP_TO_LEVEL.put(25340, 15);
+            XP_TO_LEVEL.put(35640, 16);
+            XP_TO_LEVEL.put(50040, 17);
+            XP_TO_LEVEL.put(70040, 18);
+            XP_TO_LEVEL.put(97640, 19);
+            XP_TO_LEVEL.put(135640, 20);
+            XP_TO_LEVEL.put(188140, 21);
+            XP_TO_LEVEL.put(259640, 22);
+            XP_TO_LEVEL.put(356640, 23);
+            XP_TO_LEVEL.put(488640, 24);
+            XP_TO_LEVEL.put(668640, 25);
+            XP_TO_LEVEL.put(911640, 26);
+            XP_TO_LEVEL.put(1239640, 27);
+            XP_TO_LEVEL.put(1684640, 28);
+            XP_TO_LEVEL.put(2284640, 29);
+            XP_TO_LEVEL.put(3084640, 30);
+            XP_TO_LEVEL.put(4149640, 31);
+            XP_TO_LEVEL.put(5559640, 32);
+            XP_TO_LEVEL.put(7459640, 33);
+            XP_TO_LEVEL.put(9959640, 34);
+            XP_TO_LEVEL.put(13259640, 35);
+            XP_TO_LEVEL.put(17559640, 36);
+            XP_TO_LEVEL.put(23159640, 37);
+            XP_TO_LEVEL.put(30359640, 38);
+            XP_TO_LEVEL.put(39559640, 39);
+            XP_TO_LEVEL.put(51559640, 40);
+            XP_TO_LEVEL.put(66559640, 41);
+            XP_TO_LEVEL.put(85559640, 42);
+            XP_TO_LEVEL.put(109559640, 43);
+            XP_TO_LEVEL.put(139559640, 44);
+            XP_TO_LEVEL.put(177559640, 45);
+            XP_TO_LEVEL.put(225559640, 46);
+            XP_TO_LEVEL.put(285559640, 47);
+            XP_TO_LEVEL.put(360559640, 48);
+            XP_TO_LEVEL.put(453559640, 49);
+            XP_TO_LEVEL.put(569809640, 50);
+        }
+
+        public int getLevel(double exp) {
+            return XP_TO_LEVEL.floorEntry((int) exp).getValue();
+        }
+    }
 }