From 32894c3cb4c8e4e1726ae5f6ce3c6baec30826c2 Mon Sep 17 00:00:00 2001
From: r00telement <47005506+r00telement@users.noreply.github.com>
Date: Wed, 22 Dec 2021 18:44:39 +0000
Subject: [PATCH] Added breakdown of dps + landhand

---
 .../Configuration/PluginConfiguration.cs      |  48 ++++++
 PlayerTags/Data/DefaultPluginData.cs          |  92 +++++++----
 PlayerTags/Data/DpsRole.cs                    |   8 +
 PlayerTags/Data/LandHandRole.cs               |   8 +
 PlayerTags/Data/PluginData.cs                 |  99 +++++++++++-
 PlayerTags/Data/RangedDpsRole.cs              |   8 +
 PlayerTags/Data/Role.cs                       |   2 +-
 PlayerTags/Data/RoleHelper.cs                 | 153 ++++++++++++++++++
 PlayerTags/Resources/Strings.Designer.cs      |  62 ++++++-
 PlayerTags/Resources/Strings.resx             |  24 ++-
 10 files changed, 460 insertions(+), 44 deletions(-)
 create mode 100644 PlayerTags/Data/DpsRole.cs
 create mode 100644 PlayerTags/Data/LandHandRole.cs
 create mode 100644 PlayerTags/Data/RangedDpsRole.cs
 create mode 100644 PlayerTags/Data/RoleHelper.cs

diff --git a/PlayerTags/Configuration/PluginConfiguration.cs b/PlayerTags/Configuration/PluginConfiguration.cs
index 282baac..740bc2d 100644
--- a/PlayerTags/Configuration/PluginConfiguration.cs
+++ b/PlayerTags/Configuration/PluginConfiguration.cs
@@ -38,6 +38,15 @@ namespace PlayerTags.Configuration
         [JsonProperty(TypeNameHandling = TypeNameHandling.None, ItemTypeNameHandling = TypeNameHandling.None)]
         public Dictionary<Role, Dictionary<string, InheritableData>> RoleTagsChanges = new Dictionary<Role, Dictionary<string, InheritableData>>();
 
+        [JsonProperty(TypeNameHandling = TypeNameHandling.None, ItemTypeNameHandling = TypeNameHandling.None)]
+        public Dictionary<DpsRole, Dictionary<string, InheritableData>> DpsRoleTagsChanges = new Dictionary<DpsRole, Dictionary<string, InheritableData>>();
+
+        [JsonProperty(TypeNameHandling = TypeNameHandling.None, ItemTypeNameHandling = TypeNameHandling.None)]
+        public Dictionary<RangedDpsRole, Dictionary<string, InheritableData>> RangedDpsRoleTagsChanges = new Dictionary<RangedDpsRole, Dictionary<string, InheritableData>>();
+
+        [JsonProperty(TypeNameHandling = TypeNameHandling.None, ItemTypeNameHandling = TypeNameHandling.None)]
+        public Dictionary<LandHandRole, Dictionary<string, InheritableData>> LandHandRoleTagsChanges = new Dictionary<LandHandRole, Dictionary<string, InheritableData>>();
+
         [JsonProperty(TypeNameHandling = TypeNameHandling.None, ItemTypeNameHandling = TypeNameHandling.None)]
         public Dictionary<string, Dictionary<string, InheritableData>> JobTagsChanges = new Dictionary<string, Dictionary<string, InheritableData>>();
 
@@ -67,6 +76,45 @@ namespace PlayerTags.Configuration
                 }
             }
 
+            DpsRoleTagsChanges = new Dictionary<DpsRole, Dictionary<string, InheritableData>>();
+            foreach ((var dpsRole, var dpsRoleTag) in pluginData.DpsRoleTags)
+            {
+                Dictionary<string, InheritableData>? defaultChanges;
+                pluginData.Default.DpsRoleTagsChanges.TryGetValue(dpsRole, out defaultChanges);
+
+                var changes = dpsRoleTag.GetChanges(defaultChanges);
+                if (changes.Any())
+                {
+                    DpsRoleTagsChanges[dpsRole] = changes;
+                }
+            }
+
+            RangedDpsRoleTagsChanges = new Dictionary<RangedDpsRole, Dictionary<string, InheritableData>>();
+            foreach ((var rangedDpsRole, var rangedDpsRoleTag) in pluginData.RangedDpsRoleTags)
+            {
+                Dictionary<string, InheritableData>? defaultChanges;
+                pluginData.Default.RangedDpsRoleTagsChanges.TryGetValue(rangedDpsRole, out defaultChanges);
+
+                var changes = rangedDpsRoleTag.GetChanges(defaultChanges);
+                if (changes.Any())
+                {
+                    RangedDpsRoleTagsChanges[rangedDpsRole] = changes;
+                }
+            }
+
+            LandHandRoleTagsChanges = new Dictionary<LandHandRole, Dictionary<string, InheritableData>>();
+            foreach ((var landHandRole, var landHandRoleTag) in pluginData.LandHandRoleTags)
+            {
+                Dictionary<string, InheritableData>? defaultChanges;
+                pluginData.Default.LandHandRoleTagsChanges.TryGetValue(landHandRole, out defaultChanges);
+
+                var changes = landHandRoleTag.GetChanges(defaultChanges);
+                if (changes.Any())
+                {
+                    LandHandRoleTagsChanges[landHandRole] = changes;
+                }
+            }
+
             JobTagsChanges = new Dictionary<string, Dictionary<string, InheritableData>>();
             foreach ((var jobAbbreviation, var jobTag) in pluginData.JobTags)
             {
diff --git a/PlayerTags/Data/DefaultPluginData.cs b/PlayerTags/Data/DefaultPluginData.cs
index 511a7e2..09fadbb 100644
--- a/PlayerTags/Data/DefaultPluginData.cs
+++ b/PlayerTags/Data/DefaultPluginData.cs
@@ -1,5 +1,4 @@
-using Dalamud.Data;
-using Dalamud.Game.Text.SeStringHandling;
+using Dalamud.Game.Text.SeStringHandling;
 using Lumina.Excel.GeneratedSheets;
 using PlayerTags.Inheritables;
 using PlayerTags.PluginStrings;
@@ -10,30 +9,19 @@ namespace PlayerTags.Data
 {
     public class DefaultPluginData
     {
-        public Dictionary<byte, Role> RolesById { get; }
-        public Dictionary<string, Role> RolesByJobAbbreviation { get; }
-
         public Dictionary<string, InheritableData> AllTagsChanges { get; }
 
         public Dictionary<string, InheritableData> AllRoleTagsChanges { get; }
         public Dictionary<Role, Dictionary<string, InheritableData>> RoleTagsChanges { get; }
+        public Dictionary<DpsRole, Dictionary<string, InheritableData>> DpsRoleTagsChanges { get; }
+        public Dictionary<RangedDpsRole, Dictionary<string, InheritableData>> RangedDpsRoleTagsChanges { get; }
+        public Dictionary<LandHandRole, Dictionary<string, InheritableData>> LandHandRoleTagsChanges { get; }
         public Dictionary<string, Dictionary<string, InheritableData>> JobTagsChanges { get; }
 
         public Dictionary<string, InheritableData> AllCustomTagsChanges { get; }
 
         public DefaultPluginData()
         {
-            RolesById = new Dictionary<byte, Role>()
-            {
-                { 0, Role.LandHand },
-                { 1, Role.Tank },
-                { 2, Role.DPS },
-                { 3, Role.DPS },
-                { 4, Role.Healer },
-            };
-
-            RolesByJobAbbreviation = new Dictionary<string, Role>();
-
             AllTagsChanges = new Tag(new LiteralPluginString(""))
             {
                 IsSelected = true,
@@ -90,35 +78,71 @@ namespace PlayerTags.Data
                 TextColor = 43,
             }.GetChanges();
 
-            RoleTagsChanges[Role.DPS] = new Tag(new LiteralPluginString(""))
+            RoleTagsChanges[Role.Dps] = new Tag(new LiteralPluginString(""))
             {
                 IsSelected = false,
-                IsExpanded = false,
+                IsExpanded = true,
                 Icon = BitmapFontIcon.DPS,
                 TextColor = 508,
             }.GetChanges();
 
-            JobTagsChanges = new Dictionary<string, Dictionary<string, InheritableData>>();
-            foreach ((var role, var roleTagChanges) in RoleTagsChanges)
+            DpsRoleTagsChanges = new Dictionary<DpsRole, Dictionary<string, InheritableData>>();
+            DpsRoleTagsChanges[DpsRole.Melee] = new Tag(new LiteralPluginString(""))
             {
-                var classJobs = PluginServices.DataManager.GetExcelSheet<ClassJob>();
-                if (classJobs == null)
-                {
-                    break;
-                }
+                IsSelected = false,
+                IsExpanded = false,
+            }.GetChanges();
 
-                foreach (var classJob in classJobs.Where(classJob => RolesById[classJob.Role] == role && !string.IsNullOrEmpty(classJob.Abbreviation.RawString)))
-                {
-                    RolesByJobAbbreviation[classJob.Abbreviation.RawString] = role;
+            DpsRoleTagsChanges[DpsRole.Ranged] = new Tag(new LiteralPluginString(""))
+            {
+                IsSelected = false,
+                IsExpanded = false,
+            }.GetChanges();
 
-                    if (!JobTagsChanges.ContainsKey(classJob.Abbreviation.RawString))
+            RangedDpsRoleTagsChanges = new Dictionary<RangedDpsRole, Dictionary<string, InheritableData>>();
+            RangedDpsRoleTagsChanges[RangedDpsRole.Magical] = new Tag(new LiteralPluginString(""))
+            {
+                IsSelected = false,
+                IsExpanded = false,
+            }.GetChanges();
+
+            RangedDpsRoleTagsChanges[RangedDpsRole.Physical] = new Tag(new LiteralPluginString(""))
+            {
+                IsSelected = false,
+                IsExpanded = false,
+            }.GetChanges();
+
+            LandHandRoleTagsChanges = new Dictionary<LandHandRole, Dictionary<string, InheritableData>>();
+            LandHandRoleTagsChanges[LandHandRole.Land] = new Tag(new LiteralPluginString(""))
+            {
+                IsSelected = false,
+                IsExpanded = false,
+            }.GetChanges();
+
+            LandHandRoleTagsChanges[LandHandRole.Hand] = new Tag(new LiteralPluginString(""))
+            {
+                IsSelected = false,
+                IsExpanded = false,
+            }.GetChanges();
+
+            JobTagsChanges = new Dictionary<string, Dictionary<string, InheritableData>>();
+
+            var classJobs = PluginServices.DataManager.GetExcelSheet<ClassJob>();
+            if (classJobs != null)
+            {
+                foreach ((var role, var roleTagChanges) in RoleTagsChanges)
+                {
+                    foreach (var classJob in classJobs.Where(classJob => RoleHelper.RolesByRoleId[classJob.Role] == role && !string.IsNullOrEmpty(classJob.Abbreviation.RawString)))
                     {
-                        JobTagsChanges[classJob.Abbreviation.RawString] = new Tag(new LiteralPluginString(""))
+                        if (!JobTagsChanges.ContainsKey(classJob.Abbreviation.RawString))
                         {
-                            IsSelected = false,
-                            IsExpanded = false,
-                            Text = classJob.Abbreviation.RawString,
-                        }.GetChanges();
+                            JobTagsChanges[classJob.Abbreviation.RawString] = new Tag(new LiteralPluginString(""))
+                            {
+                                IsSelected = false,
+                                IsExpanded = false,
+                                Text = classJob.Abbreviation.RawString,
+                            }.GetChanges();
+                        }
                     }
                 }
             }
diff --git a/PlayerTags/Data/DpsRole.cs b/PlayerTags/Data/DpsRole.cs
new file mode 100644
index 0000000..2559921
--- /dev/null
+++ b/PlayerTags/Data/DpsRole.cs
@@ -0,0 +1,8 @@
+namespace PlayerTags.Data
+{
+    public enum DpsRole
+    {
+        Melee,
+        Ranged
+    }
+}
diff --git a/PlayerTags/Data/LandHandRole.cs b/PlayerTags/Data/LandHandRole.cs
new file mode 100644
index 0000000..9c257ac
--- /dev/null
+++ b/PlayerTags/Data/LandHandRole.cs
@@ -0,0 +1,8 @@
+namespace PlayerTags.Data
+{
+    public enum LandHandRole
+    {
+        Land,
+        Hand
+    }
+}
diff --git a/PlayerTags/Data/PluginData.cs b/PlayerTags/Data/PluginData.cs
index f5b12bb..ae22f28 100644
--- a/PlayerTags/Data/PluginData.cs
+++ b/PlayerTags/Data/PluginData.cs
@@ -11,6 +11,9 @@ namespace PlayerTags.Data
         public Tag AllTags;
         public Tag AllRoleTags;
         public Dictionary<Role, Tag> RoleTags;
+        public Dictionary<DpsRole, Tag> DpsRoleTags;
+        public Dictionary<RangedDpsRole, Tag> RangedDpsRoleTags;
+        public Dictionary<LandHandRole, Tag> LandHandRoleTags;
         public Dictionary<string, Tag> JobTags;
         public Tag AllCustomTags;
         public List<Tag> CustomTags;
@@ -44,8 +47,56 @@ namespace PlayerTags.Data
                 }
             }
 
+            DpsRoleTags = new Dictionary<DpsRole, Tag>();
+            foreach (var dpsRole in Enum.GetValues<DpsRole>())
+            {
+                DpsRoleTags[dpsRole] = new Tag(new LocalizedPluginString(Localizer.GetName(dpsRole)));
+
+                if (Default.DpsRoleTagsChanges.TryGetValue(dpsRole, out var defaultChanges))
+                {
+                    DpsRoleTags[dpsRole].SetChanges(defaultChanges);
+                }
+
+                if (pluginConfiguration.DpsRoleTagsChanges.TryGetValue(dpsRole, out var savedChanges))
+                {
+                    DpsRoleTags[dpsRole].SetChanges(savedChanges);
+                }
+            }
+
+            RangedDpsRoleTags = new Dictionary<RangedDpsRole, Tag>();
+            foreach (var rangedDpsRole in Enum.GetValues<RangedDpsRole>())
+            {
+                RangedDpsRoleTags[rangedDpsRole] = new Tag(new LocalizedPluginString(Localizer.GetName(rangedDpsRole)));
+
+                if (Default.RangedDpsRoleTagsChanges.TryGetValue(rangedDpsRole, out var defaultChanges))
+                {
+                    RangedDpsRoleTags[rangedDpsRole].SetChanges(defaultChanges);
+                }
+
+                if (pluginConfiguration.RangedDpsRoleTagsChanges.TryGetValue(rangedDpsRole, out var savedChanges))
+                {
+                    RangedDpsRoleTags[rangedDpsRole].SetChanges(savedChanges);
+                }
+            }
+
+            LandHandRoleTags = new Dictionary<LandHandRole, Tag>();
+            foreach (var landHandRole in Enum.GetValues<LandHandRole>())
+            {
+                LandHandRoleTags[landHandRole] = new Tag(new LocalizedPluginString(Localizer.GetName(landHandRole)));
+
+                if (Default.LandHandRoleTagsChanges.TryGetValue(landHandRole, out var defaultChanges))
+                {
+                    LandHandRoleTags[landHandRole].SetChanges(defaultChanges);
+                }
+
+                if (pluginConfiguration.LandHandRoleTagsChanges.TryGetValue(landHandRole, out var savedChanges))
+                {
+                    LandHandRoleTags[landHandRole].SetChanges(savedChanges);
+                }
+            }
+
             JobTags = new Dictionary<string, Tag>();
-            foreach ((var jobAbbreviation, var role) in Default.RolesByJobAbbreviation)
+            foreach ((var jobAbbreviation, var role) in RoleHelper.RolesByJobAbbreviation)
             {
                 JobTags[jobAbbreviation] = new Tag(new LiteralPluginString(jobAbbreviation));
 
@@ -78,11 +129,55 @@ namespace PlayerTags.Data
             foreach ((var role, var roleTag) in RoleTags)
             {
                 roleTag.Parent = AllRoleTags;
+
+                if (role == Role.Dps)
+                {
+                    foreach ((var dpsRole, var dpsRoleTag) in DpsRoleTags)
+                    {
+                        dpsRoleTag.Parent = roleTag;
+
+                        if (dpsRole == DpsRole.Ranged)
+                        {
+                            foreach ((var rangedDpsRole, var rangedDpsRoleTag) in RangedDpsRoleTags)
+                            {
+                                rangedDpsRoleTag.Parent = dpsRoleTag;
+                            }
+                        }
+                    }
+                }
+                else if (role == Role.LandHand)
+                {
+                    foreach ((var landHandRole, var landHandRoleTag) in LandHandRoleTags)
+                    {
+                        landHandRoleTag.Parent = roleTag;
+                    }
+                }
             }
 
             foreach ((var jobAbbreviation, var jobTag) in JobTags)
             {
-                jobTag.Parent = RoleTags[Default.RolesByJobAbbreviation[jobAbbreviation]];
+                if (RoleHelper.RolesByJobAbbreviation.TryGetValue(jobAbbreviation, out var role))
+                {
+                    if (RoleHelper.DpsRolesByJobAbbreviation.TryGetValue(jobAbbreviation, out var dpsRole))
+                    {
+                        if (RoleHelper.RangedDpsRolesByJobAbbreviation.TryGetValue(jobAbbreviation, out var rangedDpsRole))
+                        {
+                            jobTag.Parent = RangedDpsRoleTags[rangedDpsRole];
+                        }
+                        else
+                        {
+                            jobTag.Parent = DpsRoleTags[dpsRole];
+                        }
+                    }
+                    else if (RoleHelper.LandHandRolesByJobAbbreviation.TryGetValue(jobAbbreviation, out var landHandRole))
+                    {
+                        jobTag.Parent = LandHandRoleTags[landHandRole];
+                    }
+                    else
+                    {
+                        jobTag.Parent = RoleTags[RoleHelper.RolesByJobAbbreviation[jobAbbreviation]];
+                    }
+                }
             }
 
             AllCustomTags.Parent = AllTags;
diff --git a/PlayerTags/Data/RangedDpsRole.cs b/PlayerTags/Data/RangedDpsRole.cs
new file mode 100644
index 0000000..eb47702
--- /dev/null
+++ b/PlayerTags/Data/RangedDpsRole.cs
@@ -0,0 +1,8 @@
+namespace PlayerTags.Data
+{
+    public enum RangedDpsRole
+    {
+        Magical,
+        Physical,
+    }
+}
diff --git a/PlayerTags/Data/Role.cs b/PlayerTags/Data/Role.cs
index 69a4780..a9ac88e 100644
--- a/PlayerTags/Data/Role.cs
+++ b/PlayerTags/Data/Role.cs
@@ -5,6 +5,6 @@
         LandHand,
         Tank,
         Healer,
-        DPS
+        Dps,
     }
 }
diff --git a/PlayerTags/Data/RoleHelper.cs b/PlayerTags/Data/RoleHelper.cs
new file mode 100644
index 0000000..c34d714
--- /dev/null
+++ b/PlayerTags/Data/RoleHelper.cs
@@ -0,0 +1,153 @@
+using Lumina.Excel.GeneratedSheets;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace PlayerTags.Data
+{
+    public static class RoleHelper
+    {
+        public static Dictionary<byte, Role> RolesByRoleId { get; } = new Dictionary<byte, Role>()
+        {
+            { 0, Role.LandHand },
+            { 1, Role.Tank },
+            { 2, Role.Dps },
+            { 3, Role.Dps },
+            { 4, Role.Healer },
+        };
+
+        public static Dictionary<byte, DpsRole> DpsRolesByRoleId { get; } = new Dictionary<byte, DpsRole>()
+        {
+            { 2, DpsRole.Melee },
+            { 3, DpsRole.Ranged },
+        };
+
+        public static Dictionary<byte, RangedDpsRole> RangedDpsRolesByPrimaryStat { get; } = new Dictionary<byte, RangedDpsRole>()
+        {
+            { 4, RangedDpsRole.Magical },
+            { 2, RangedDpsRole.Physical },
+        };
+
+        private static Dictionary<string, Role>? s_RolesByJobAbbreviation = null;
+        public static Dictionary<string, Role> RolesByJobAbbreviation
+        {
+            get
+            {
+                if (s_RolesByJobAbbreviation == null)
+                {
+                    s_RolesByJobAbbreviation = new Dictionary<string, Role>();
+
+                    var classJobs = PluginServices.DataManager.GetExcelSheet<ClassJob>();
+                    if (classJobs != null)
+                    {
+                        foreach (var classJob in classJobs.Where(classJob => !string.IsNullOrEmpty(classJob.Abbreviation.RawString)))
+                        {
+                            if (RolesByRoleId.TryGetValue(classJob.Role, out var role))
+                            {
+                                s_RolesByJobAbbreviation[classJob.Abbreviation] = role;
+                            }
+                        }
+                    }
+                }
+
+                return s_RolesByJobAbbreviation;
+            }
+        }
+
+        private static Dictionary<string, DpsRole>? s_DpsRolesByJobAbbreviation = null;
+        public static Dictionary<string, DpsRole> DpsRolesByJobAbbreviation
+        {
+            get
+            {
+                if (s_DpsRolesByJobAbbreviation == null)
+                {
+                    s_DpsRolesByJobAbbreviation = new Dictionary<string, DpsRole>();
+
+                    var classJobs = PluginServices.DataManager.GetExcelSheet<ClassJob>();
+                    if (classJobs != null)
+                    {
+                        foreach (var classJob in classJobs.Where(classJob => !string.IsNullOrEmpty(classJob.Abbreviation.RawString)))
+                        {
+                            if (DpsRolesByRoleId.TryGetValue(classJob.Role, out var dpsRole))
+                            {
+                                s_DpsRolesByJobAbbreviation[classJob.Abbreviation] = dpsRole;
+                            }
+                        }
+                    }
+                }
+
+                return s_DpsRolesByJobAbbreviation;
+            }
+        }
+
+        private static Dictionary<string, RangedDpsRole>? s_RangedDpsRolesByJobAbbreviation = null;
+        public static Dictionary<string, RangedDpsRole> RangedDpsRolesByJobAbbreviation
+        {
+            get
+            {
+                if (s_RangedDpsRolesByJobAbbreviation == null)
+                {
+                    s_RangedDpsRolesByJobAbbreviation = new Dictionary<string, RangedDpsRole>();
+
+                    var classJobs = PluginServices.DataManager.GetExcelSheet<ClassJob>();
+                    if (classJobs != null)
+                    {
+                        foreach (var classJob in classJobs.Where(classJob => !string.IsNullOrEmpty(classJob.Abbreviation.RawString)))
+                        {
+                            if (DpsRolesByJobAbbreviation.TryGetValue(classJob.Abbreviation, out var dpsRole) && dpsRole == DpsRole.Ranged)
+                            {
+                                if (RangedDpsRolesByPrimaryStat.TryGetValue(classJob.PrimaryStat, out var rangedDPSRole))
+                                {
+                                    s_RangedDpsRolesByJobAbbreviation[classJob.Abbreviation] = rangedDPSRole;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                return s_RangedDpsRolesByJobAbbreviation;
+            }
+        }
+
+        private static Dictionary<string, LandHandRole>? s_LandHandRolesByJobAbbreviation = null;
+        public static Dictionary<string, LandHandRole> LandHandRolesByJobAbbreviation
+        {
+            get
+            {
+                if (s_LandHandRolesByJobAbbreviation == null)
+                {
+                    s_LandHandRolesByJobAbbreviation = new Dictionary<string, LandHandRole>();
+
+                    var classJobs = PluginServices.DataManager.GetExcelSheet<ClassJob>();
+                    var gatheringSubCategories = PluginServices.DataManager.GetExcelSheet<GatheringSubCategory>();
+                    if (classJobs != null && gatheringSubCategories != null)
+                    {
+                        var gatheringJobAbbreviations = gatheringSubCategories
+                            .Select(gatheringSubCategory => gatheringSubCategory.ClassJob.Value)
+                            .Where(classJob => classJob != null)
+                            .Select(classJob => classJob!.Abbreviation).Distinct();
+
+                        foreach (var classJob in classJobs.Where(classJob => !string.IsNullOrEmpty(classJob.Abbreviation.RawString)))
+                        {
+                            if (RolesByRoleId.TryGetValue(classJob.Role, out var role))
+                            {
+                                if (role == Role.LandHand)
+                                {
+                                    if (gatheringJobAbbreviations.Contains(classJob.Abbreviation))
+                                    {
+                                        s_LandHandRolesByJobAbbreviation[classJob.Abbreviation] = LandHandRole.Land;
+                                    }
+                                    else
+                                    {
+                                        s_LandHandRolesByJobAbbreviation[classJob.Abbreviation] = LandHandRole.Hand;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                return s_LandHandRolesByJobAbbreviation;
+            }
+        }
+    }
+}
diff --git a/PlayerTags/Resources/Strings.Designer.cs b/PlayerTags/Resources/Strings.Designer.cs
index 4091608..d8bba8d 100644
--- a/PlayerTags/Resources/Strings.Designer.cs
+++ b/PlayerTags/Resources/Strings.Designer.cs
@@ -70,7 +70,7 @@ namespace PlayerTags.Resources {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to All Custom.
+        ///   Looks up a localized string similar to Custom.
         /// </summary>
         public static string Loc_AllCustomTags {
             get {
@@ -79,7 +79,7 @@ namespace PlayerTags.Resources {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to All Roles.
+        ///   Looks up a localized string similar to Roles.
         /// </summary>
         public static string Loc_AllRoleTags {
             get {
@@ -105,6 +105,24 @@ namespace PlayerTags.Resources {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Melee.
+        /// </summary>
+        public static string Loc_DpsRole_Melee {
+            get {
+                return ResourceManager.GetString("Loc_DpsRole_Melee", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Ranged.
+        /// </summary>
+        public static string Loc_DpsRole_Ranged {
+            get {
+                return ResourceManager.GetString("Loc_DpsRole_Ranged", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Add to players.
         /// </summary>
@@ -717,6 +735,24 @@ namespace PlayerTags.Resources {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Hand.
+        /// </summary>
+        public static string Loc_LandHandRole_Hand {
+            get {
+                return ResourceManager.GetString("Loc_LandHandRole_Hand", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Land.
+        /// </summary>
+        public static string Loc_LandHandRole_Land {
+            get {
+                return ResourceManager.GetString("Loc_LandHandRole_Land", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to Free company.
         /// </summary>
@@ -978,12 +1014,30 @@ namespace PlayerTags.Resources {
             }
         }
         
+        /// <summary>
+        ///   Looks up a localized string similar to Magical.
+        /// </summary>
+        public static string Loc_RangedDpsRole_Magical {
+            get {
+                return ResourceManager.GetString("Loc_RangedDpsRole_Magical", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Physical.
+        /// </summary>
+        public static string Loc_RangedDpsRole_Physical {
+            get {
+                return ResourceManager.GetString("Loc_RangedDpsRole_Physical", resourceCulture);
+            }
+        }
+        
         /// <summary>
         ///   Looks up a localized string similar to DPS.
         /// </summary>
-        public static string Loc_Role_DPS {
+        public static string Loc_Role_Dps {
             get {
-                return ResourceManager.GetString("Loc_Role_DPS", resourceCulture);
+                return ResourceManager.GetString("Loc_Role_Dps", resourceCulture);
             }
         }
         
diff --git a/PlayerTags/Resources/Strings.resx b/PlayerTags/Resources/Strings.resx
index 507b88e..bfb5a29 100644
--- a/PlayerTags/Resources/Strings.resx
+++ b/PlayerTags/Resources/Strings.resx
@@ -277,7 +277,7 @@
     <value>All</value>
   </data>
   <data name="Loc_AllRoleTags" xml:space="preserve">
-    <value>All Roles</value>
+    <value>Roles</value>
   </data>
   <data name="Loc_Role_LandHand" xml:space="preserve">
     <value>Land/Hand</value>
@@ -288,11 +288,29 @@
   <data name="Loc_Role_Healer" xml:space="preserve">
     <value>Healer</value>
   </data>
-  <data name="Loc_Role_DPS" xml:space="preserve">
+  <data name="Loc_Role_Dps" xml:space="preserve">
     <value>DPS</value>
   </data>
+  <data name="Loc_DpsRole_Melee" xml:space="preserve">
+    <value>Melee</value>
+  </data>
+  <data name="Loc_DpsRole_Ranged" xml:space="preserve">
+    <value>Ranged</value>
+  </data>
+  <data name="Loc_RangedDpsRole_Magical" xml:space="preserve">
+    <value>Magical</value>
+  </data>
+  <data name="Loc_RangedDpsRole_Physical" xml:space="preserve">
+    <value>Physical</value>
+  </data>
+  <data name="Loc_LandHandRole_Hand" xml:space="preserve">
+    <value>Hand</value>
+  </data>
+  <data name="Loc_LandHandRole_Land" xml:space="preserve">
+    <value>Land</value>
+  </data>
   <data name="Loc_AllCustomTags" xml:space="preserve">
-    <value>All Custom</value>
+    <value>Custom</value>
   </data>
   <data name="Loc_CustomTags" xml:space="preserve">
     <value>Custom</value>