Fix Charged point support in ComboPointsBar

There are controls on the player castbar module for flashing when a spell succeeds or fails, and separate controls for flashing when an instant cast completes. Those were broken (flashing never happened), but now work again.

UpdateBar() was necessary in MyOnUpdate() in the event that no other spell has been cast (in order to set the alpha so that the bottom text displays). The spellId is being passed along so that spells that aren't currently being cast can have their name and icon displayed appropriately, and so the early-out for "no known spell" doesn't trigger (which allows the Flash to actually work). The self.current reset fixes instant casts after a normal cast (we were only clearing the "current" spell conditionally when we only meant to filter StopBar, so if it wasn't cleared, future successful casts thought they were for a different spell than was currently being cast.

.github/workflows/release.yml

@@ -0,0 +1,58 @@
+# description of this workflow, can be anything you want
+name: Package and release
+
+# we need to let GitHub know _when_ we want to release, typically only when we create a new tag.
+# this will target only tags, and not all pushes to the master branch.
+# this part can be heavily customized to your liking, like targeting only tags that match a certain word,
+# other branches or even pullrequests.
+on:
+  push:
+    tags:
+      - '**'
+
+# a workflow is built up as jobs, and within these jobs are steps
+jobs:
+
+  # "release" is a job, you can name it anything you want
+  release:
+
+    # we can run our steps on pretty much anything, but the "ubuntu-latest" image is a safe bet
+    runs-on: ubuntu-latest
+
+    # specify the environment variables used by the packager, matching the secrets from the project on GitHub
+    env:
+      CF_API_KEY: ${{ secrets.CF_API_KEY }}
+      WOWI_API_TOKEN: ${{ secrets.WOWI_API_TOKEN }}
+      WAGO_API_TOKEN: ${{ secrets.WAGO_API_TOKEN }}
+      GITHUB_OAUTH: ${{ secrets.GITHUB_TOKEN }}  # "GITHUB_TOKEN" is a secret always provided to the workflow
+                                                 # for your own token, the name cannot start with "GITHUB_"
+
+    # "steps" holds a list of all the steps needed to package and release our AddOn
+    steps:
+
+      # we first have to clone the AddOn project, this is a required step
+      - name: Clone project
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0  # gets git history for changelogs
+
+      # once cloned, we just run the GitHub Action for the packager project
+      - name: Package and release
+        uses: BigWigsMods/packager@v2
+
+      # another example where we supply additional arguments, this example is specifically to release
+      # for the Classic version of the game
+      - name: Package and release for Classic
+        uses: BigWigsMods/packager@v2
+        with:
+          args: -g classic -w 0
+
+      - name: Package and release for TBC
+        uses: BigWigsMods/packager@v2
+        with:
+          args: -g bcc -w 0
+
+      - name: Package and release for Wrath
+        uses: BigWigsMods/packager@v2
+        with:
+          args: -g wrath -w 0

.mailmap

@@ -1,2 +1,3 @@
 Parnic <parnic@parnic.com> Parnic <chris@parnic.com>
 rokiyo <rokiyo@example.com> Rokiyo <Rokiyo@example.com>
+Parnic <parnic@parnic.com> Chris Pickett <chris@perniciousgames.com>

.pkgmeta

@@ -24,7 +24,7 @@ externals:
         tag: latest
     libs/AceGUI-3.0:
         url: svn://svn.wowace.com/wow/ace3/mainline/trunk/AceGUI-3.0
-		tag: latest
+        tag: latest
     libs/AceGUI-3.0-SharedMediaWidgets:
         url: svn://svn.wowace.com/wow/ace-gui-3-0-shared-media-widgets/mainline/trunk/AceGUI-3.0-SharedMediaWidgets
         tag: latest
@@ -37,15 +37,18 @@ externals:
     libs/AceLocale-3.0:
         url: svn://svn.wowace.com/wow/ace3/mainline/trunk/AceLocale-3.0
         tag: latest
+    libs/AceHook-3.0:
+        url: svn://svn.wowace.com/wow/ace3/mainline/trunk/AceHook-3.0
+        tag: latest
     libs/LibRangeCheck-2.0:
-        url: svn://svn.wowace.com/wow/librangecheck-2-0/mainline/trunk/LibRangeCheck-2.0
+        url: https://github.com/WeakAuras/LibRangeCheck-2.0/
     libs/LibSharedMedia-3.0:
         url: svn://svn.wowace.com/wow/libsharedmedia-3-0/mainline/trunk
         tag: latest
     libs/LibDogTag-3.0:
-        url: git://git.wowace.com/wow/libdogtag-3-0/mainline.git
+        url: https://github.com/parnic/LibDogTag-3.0
     libs/LibDogTag-Unit-3.0:
-        url: git://git.wowace.com/wow/libdogtag-unit-3-0/mainline.git
+        url: https://github.com/parnic/LibDogTag-Unit-3.0
     libs/LibDBIcon-1.0:
         url: svn://svn.wowace.com/wow/libdbicon-1-0/mainline/trunk/LibDBIcon-1.0
     libs/LibDualSpec-1.0:
@@ -58,6 +61,16 @@ optional-dependencies:
 
 move-folders:
     IceHUD/IceHUD_Options: IceHUD_Options
+    IceHUD/libs/LibRangeCheck-2.0/LibRangeCheck-2.0: IceHUD/libs/LibRangeCheck-2.0
 
 tools-used:
     - libdatabroker-1-1
+
+ignore:
+    - readme.md
+    - FUNDING.yml
+    - this_version.md
+
+manual-changelog: this_version.md
+
+enable-nolib-creation: yes

FUNDING.yml

@@ -0,0 +1,3 @@
+github: parnic
+ko_fi: parnic
+custom: "https://www.paypal.me/parnic"

IceBarElement.lua

@@ -171,6 +171,7 @@ function IceBarElement.prototype:GetDefaultSettings()
 	settings["rotateBar"] = false
 	settings["markers"] = {}
 	settings["bAllowExpand"] = true
+	settings["textVerticalGap"] = 0
 
 	return settings
 end
@@ -414,7 +415,7 @@ do
 			type='range',
 			name = L["Bar vertical offset"],
 			desc = L["Adjust the vertical placement of this bar"],
-			min = -400,
+			min = -600,
 			max = 600,
 			step = 1,
 			get = function()
@@ -435,7 +436,7 @@ do
 			type='range',
 			name = L["Bar horizontal adjust"],
 			desc = L["This is a per-pixel horizontal adjustment. You should probably use the 'offset' setting above as it is designed to snap bars together. This may be used in the case of a horizontal bar needing to be positioned outside the normal bar locations."],
-			min = -400,
+			min = -600,
 			max = 600,
 			step = 1,
 			get = function()
@@ -625,7 +626,7 @@ do
 							v = DogTag:CleanCode(v)
 						end
 
-						self.moduleSettings.upperText = v
+						self.moduleSettings.upperText = strtrim(v)
 						self:RegisterFontStrings()
 						self:Redraw()
 					end,
@@ -654,7 +655,7 @@ do
 							v = DogTag:CleanCode(v)
 						end
 
-						self.moduleSettings.lowerText = v
+						self.moduleSettings.lowerText = strtrim(v)
 						self:RegisterFontStrings()
 						self:Redraw()
 					end,
@@ -724,6 +725,26 @@ do
 					order = 11.3,
 				},
 
+				textVerticalGap = {
+					type = 'range',
+					name = L["Text Vertical Gap"],
+					desc = L["Gap between Upper and Lower text vertically"],
+					min = 0,
+					max = 10,
+					step = 1,
+					get = function()
+						return self.moduleSettings.textVerticalGap
+					end,
+					set = function(info, v)
+						self.moduleSettings.textVerticalGap = v
+						self:Redraw()
+					end,
+					disabled = function()
+						return not self.moduleSettings.enabled
+					end,
+					order = 11.4,
+				},
+
 				textHeader = {
 					type = 'header',
 					name = L["Upper Text"],
@@ -946,6 +967,8 @@ function IceBarElement.prototype:CreateFrame()
 
 	if self.moduleSettings.rotateBar then
 		self:RotateHorizontal()
+	else
+		self:ResetRotation()
 	end
 end
 
@@ -1017,7 +1040,7 @@ end
 
 -- Creates the actual bar
 function IceBarElement.prototype:CreateBar()
-	self.barFrame = self:BarFactory(self.barFrame, "LOW", "ARTWORK")
+	self.barFrame = self:BarFactory(self.barFrame, "LOW", "ARTWORK", "Bar")
 	self:SetBarCoord(self.barFrame)
 
 	self.barFrame.bar:SetBlendMode(self.settings.barBlendMode)
@@ -1027,9 +1050,9 @@ end
 
 -- Returns a barFrame & barFrame.bar
 -- Rokiyo: Currently keeping old behaviour of running through bar creation on every Redraw, but I'm not convinced we need to.
-function IceBarElement.prototype:BarFactory(barFrame, frameStrata, textureLayer)
+function IceBarElement.prototype:BarFactory(barFrame, frameStrata, textureLayer, nameSuffix)
 	if not (barFrame) then
-		barFrame = CreateFrame("Frame", nil, self.frame)
+		barFrame = CreateFrame("Frame", "IceHUD_"..self.elementName.."_"..(nameSuffix or "Bar"), self.frame)
 	end
 
 	barFrame:SetFrameStrata(frameStrata and frameStrata or "LOW")
@@ -1114,8 +1137,13 @@ function IceBarElement.prototype:CreateTexts()
 		offy = self.moduleSettings.textVerticalOffset
 	end
 
+	local offgap = 0
+	if self.moduleSettings.textVerticalGap ~= nil then
+		offgap = self.moduleSettings.textVerticalGap
+	end
+
 	self.frame.bottomUpperText:SetPoint("TOP"..ownPoint , self.frame, "BOTTOM"..parentPoint, offx, offy)
-	self.frame.bottomLowerText:SetPoint("TOP"..ownPoint , self.frame, "BOTTOM"..parentPoint, offx, offy - 14)
+	self.frame.bottomLowerText:SetPoint("TOP"..ownPoint , self.frame, "BOTTOM"..parentPoint, offx, offy - (14 + offgap))
 
 	if (self.moduleSettings.textVisible["upper"]) then
 		self.frame.bottomUpperText:Show()
@@ -1431,6 +1459,16 @@ function IceBarElement.prototype:SetScaledColor(colorVar, percent, maxColor, min
 	colorVar.b = ((maxColor.b - minColor.b) * percent) + minColor.b
 end
 
+function IceBarElement.prototype:Round(num)
+	if (num > 1000000) then
+		return IceHUD:MathRound(num/1000000, 1) .. "M"
+	end
+	if (num > 1000) then
+		return IceHUD:MathRound(num/1000, 1) .. "k"
+	end
+	return num
+end
+
 -- To be overridden
 function IceBarElement.prototype:Update()
 end
@@ -1546,7 +1584,7 @@ function IceBarElement.prototype:CreateMarker(idx)
 		self.Markers[idx] = nil
 	end
 
-	self.Markers[idx] = self:BarFactory(self.Markers[idx], "MEDIUM", "OVERLAY")
+	self.Markers[idx] = self:BarFactory(self.Markers[idx], "MEDIUM", "OVERLAY", "Marker"..idx)
 
 	local color = self.moduleSettings.markers[idx].color
 	self.Markers[idx].bar:SetVertexColor(color.r, color.g, color.b, self.alpha)

IceCore.lua

@@ -41,6 +41,26 @@ IceCore.TextDecorationStyle = {
 	NoDecoration = L["No decoration"],
 }
 
+local ZM_MAP_ID = 1970
+IceCore.zmPuzzleIds = {
+	--Fugueal Protolock
+	366046,
+	366108,
+	359488,
+	--Mezzonic Protolock
+	366042,
+	366106,
+	351405,
+	--Cantaric Protolock
+	365840,
+	366107,
+	348792,
+}
+IceCore.zmPuzzleMap = {}
+for i=1, #IceCore.zmPuzzleIds do
+	IceCore.zmPuzzleMap[IceCore.zmPuzzleIds[i]] = true
+end
+
 local SUNDER_SPELL_ID = 7386
 local LACERATE_SPELL_ID = 33745
 local MAELSTROM_SPELL_ID = 53817
@@ -94,6 +114,7 @@ function IceCore.prototype:SetupDefaults()
 
 			bHideDuringPetBattles = true,
 			bHideInBarberShop = true,
+			bHideDuringShellGame = true,
 		},
 		global = {
 			lastRunVersion = 0,
@@ -173,6 +194,13 @@ function IceCore.prototype:CheckDisplayUpdateMessage()
 				self.settings.modules["DruidMana"] = nil
 			end
 		end
+		if self.accountSettings.lastRunVersion <= 20180720033008 then
+			if self.settings.modules["HarmonyPower"] ~= nil then
+				self.settings.modules["Chi"] = self.settings.modules["HarmonyPower"]
+				self.settings.modules["HarmonyPower"] = nil
+				self.settings.colors["ChiNumeric"] = self.settings.colors["HarmonyPowerNumeric"]
+			end
+		end
 		self.accountSettings.lastRunVersion = thisVersion
 	end
 end
@@ -243,10 +271,21 @@ function IceCore.prototype:Enable(userToggle)
 		IceHUD_Options:GenerateModuleOptions()
 	end
 
-	self.IceHUDFrame:RegisterEvent("PET_BATTLE_OPENING_START")
-	self.IceHUDFrame:RegisterEvent("PET_BATTLE_OVER")
-	self.IceHUDFrame:RegisterEvent("BARBER_SHOP_OPEN")
-	self.IceHUDFrame:RegisterEvent("BARBER_SHOP_CLOSE")
+	if UnitCanPetBattle then
+		self.IceHUDFrame:RegisterEvent("PET_BATTLE_OPENING_START")
+		self.IceHUDFrame:RegisterEvent("PET_BATTLE_OVER")
+	end
+	if GetBarberShopStyleInfo then
+		self.IceHUDFrame:RegisterEvent("BARBER_SHOP_OPEN")
+		self.IceHUDFrame:RegisterEvent("BARBER_SHOP_CLOSE")
+	end
+	if C_Map then
+		self.IceHUDFrame:RegisterEvent("PLAYER_ENTERING_WORLD")
+		self.IceHUDFrame:RegisterEvent("ZONE_CHANGED")
+	end
+	self.IceHUDFrame:RegisterEvent("UNIT_AURA")
+	self.IceHUDFrame:RegisterEvent("PLAYER_REGEN_ENABLED", IceHUD.PLAYER_REGEN_ENABLED)
+	self.IceHUDFrame:RegisterEvent("PLAYER_REGEN_DISABLED", IceHUD.PLAYER_REGEN_DISABLED)
 	self.IceHUDFrame:SetScript("OnEvent", function(self, event, ...)
 		if (event == "PET_BATTLE_OPENING_START") then
 			if IceHUD.IceCore.settings.bHideDuringPetBattles then
@@ -264,6 +303,50 @@ function IceCore.prototype:Enable(userToggle)
 			if IceHUD.IceCore.settings.bHideInBarberShop then
 				self:Show()
 			end
+		elseif (event == "UNIT_AURA") then
+			local unit = ...
+			if unit ~= "player" then
+				return
+			end
+
+			if IceHUD.IceCore.settings.bHideDuringShellGame and IceHUD:HasAnyDebuff("player", {IceHUD.ShellGameSpellID}) and UnitInVehicle("player") then
+				self:RegisterEvent("UNIT_EXITED_VEHICLE")
+				self:Hide()
+			elseif C_Map then
+				local bestMapID = C_Map.GetBestMapForUnit("player")
+				if bestMapID ~= ZM_MAP_ID then
+					return
+				end
+
+				if IceHUD:HasAnyBuff("player", IceCore.zmPuzzleIds) then
+					self:RegisterEvent("COMBAT_LOG_EVENT_UNFILTERED")
+					self:Hide()
+				end
+			end
+		elseif (event == "UNIT_EXITED_VEHICLE") then
+			self:UnregisterEvent("UNIT_EXITED_VEHICLE")
+			self:Show()
+		elseif (event == "PLAYER_ENTERING_WORLD" or event == "ZONE_CHANGED") then
+			if C_Map then
+				local bestMapID = C_Map.GetBestMapForUnit("player")
+				if bestMapID == ZM_MAP_ID then
+					if IceHUD:HasAnyBuff("player", IceCore.zmPuzzleIds) then
+						self:RegisterEvent("COMBAT_LOG_EVENT_UNFILTERED")
+						self:Hide()
+					end
+				end
+			end
+		elseif (event == "COMBAT_LOG_EVENT_UNFILTERED") then
+			local _,subevent,_,_,_,_,_,_,destName,_,_,spellId = CombatLogGetCurrentEventInfo()
+
+			if subevent == "SPELL_AURA_REMOVED" then
+				if destName == UnitName("player") then
+					if IceCore.zmPuzzleMap[spellId] then
+						self:Show()
+						self:UnregisterEvent("COMBAT_LOG_EVENT_UNFILTERED")
+					end
+				end
+			end
 		end
 	end)
 
@@ -272,7 +355,7 @@ end
 
 function IceCore.prototype:RedirectRemovedModules()
 	local _, class = UnitClass("player")
-	if class == "WARRIOR" and self.settings.modules["SunderCount"] and IceHUD.WowVer < 60000 then
+	if class == "WARRIOR" and self.settings.modules["SunderCount"] and GetSpellInfo(SUNDER_SPELL_ID) and IceHUD.WowVer < 60000 then
 		if self.settings.modules["SunderCount"].enabled or self.settings.modules["SunderCount"].enabled == nil then
 			local bFound = false
 
@@ -309,7 +392,7 @@ function IceCore.prototype:RedirectRemovedModules()
 		self.settings.modules["SunderCount"] = nil
 	end
 
-	if class == "DRUID" and self.settings.modules["LacerateCount"] then
+	if class == "DRUID" and self.settings.modules["LacerateCount"] and GetSpellInfo(LACERATE_SPELL_ID) then
 		if self.settings.modules["LacerateCount"].enabled or self.settings.modules["LacerateCount"].enabled == nil then
 			local bFound = false
 			for k,v in pairs(self.elements) do
@@ -346,7 +429,7 @@ function IceCore.prototype:RedirectRemovedModules()
 		self.settings.modules["LacerateCount"] = nil
 	end
 
-	if class == "SHAMAN" and self.settings.modules["MaelstromCount"] then
+	if class == "SHAMAN" and self.settings.modules["MaelstromCount"] and GetSpellInfo(MAELSTROM_SPELL_ID) then
 		if self.settings.modules["MaelstromCount"].enabled or self.settings.modules["MaelstromCount"].enabled == nil then
 			local bFound = false
 			for k,v in pairs(self.elements) do
@@ -498,10 +581,14 @@ function IceCore.prototype:Disable(userToggle)
 		end
 	end
 
-	self.IceHUDFrame:UnregisterEvent("PET_BATTLE_OPENING_START")
-	self.IceHUDFrame:UnregisterEvent("PET_BATTLE_OVER")
-	self.IceHUDFrame:UnregisterEvent("BARBER_SHOP_OPEN")
-	self.IceHUDFrame:UnregisterEvent("BARBER_SHOP_CLOSE")
+	if UnitCanPetBattle then
+		self.IceHUDFrame:UnregisterEvent("PET_BATTLE_OPENING_START")
+		self.IceHUDFrame:UnregisterEvent("PET_BATTLE_OVER")
+	end
+	if GetBarberShopStyleInfo then
+		self.IceHUDFrame:UnregisterEvent("BARBER_SHOP_OPEN")
+		self.IceHUDFrame:UnregisterEvent("BARBER_SHOP_CLOSE")
+	end
 	self.IceHUDFrame:SetScript("OnEvent", nil)
 
 	self.enabled = false

IceElement.lua

@@ -69,7 +69,7 @@ function IceElement.prototype:Create(parent)
 
 	self.parent = parent
 	if not self.masterFrame then
-		self.masterFrame = CreateFrame("Frame", nil, self.parent)
+		self.masterFrame = CreateFrame("Frame", "IceHUD_Element_"..self.elementName, self.parent)
 		self.masterFrame:SetFrameStrata("MEDIUM")
 	end
 	self:CreateFrame()

IceHUD.lua

@@ -1,14 +1,12 @@
 local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
-IceHUD = LibStub("AceAddon-3.0"):NewAddon("IceHUD", "AceConsole-3.0")
+IceHUD = LibStub("AceAddon-3.0"):NewAddon("IceHUD", "AceConsole-3.0", "AceHook-3.0")
 
 local IceHUD = IceHUD
 
 local SML = LibStub("LibSharedMedia-3.0")
 local ACR = LibStub("AceConfigRegistry-3.0")
 local ConfigDialog = LibStub("AceConfigDialog-3.0")
-local icon = LibStub("LibDBIcon-1.0")
-local AceGUI = LibStub("AceGUI-3.0")
-local AceSerializer = LibStub("AceSerializer-3.0", 1)
+local icon = LibStub("LibDBIcon-1.0", true)
 
 local pendingModuleLoads = {}
 local bReadyToRegisterModules = false
@@ -17,11 +15,60 @@ IceHUD.CurrTagVersion = 3
 IceHUD.debugging = false
 
 IceHUD.WowVer = select(4, GetBuildInfo())
+IceHUD.WowMain = not WOW_PROJECT_ID or WOW_PROJECT_ID == WOW_PROJECT_MAINLINE
+if GetClassicExpansionLevel then
+	IceHUD.WowClassic = GetClassicExpansionLevel() == 0
+	IceHUD.WowClassicBC = GetClassicExpansionLevel() == 1
+	IceHUD.WowClassicWrath = GetClassicExpansionLevel() == 2
+else
+	IceHUD.WowClassic = WOW_PROJECT_ID and WOW_PROJECT_ID == WOW_PROJECT_CLASSIC
+	IceHUD.WowClassicBC = false
+	IceHUD.WowClassicWrath = false
+	if WOW_PROJECT_ID and WOW_PROJECT_ID == WOW_PROJECT_BURNING_CRUSADE_CLASSIC then
+		if not LE_EXPANSION_LEVEL_CURRENT or LE_EXPANSION_LEVEL_CURRENT == LE_EXPANSION_BURNING_CRUSADE then
+			IceHUD.WowClassicBC = true
+		elseif LE_EXPANSION_LEVEL_CURRENT == LE_EXPANSION_WRATH_OF_THE_LICH_KING then
+			IceHUD.WowClassicWrath = true
+		end
+	elseif WOW_PROJECT_WRATH_CLASSIC and WOW_PROJECT_ID == WOW_PROJECT_WRATH_CLASSIC then
+		IceHUD.WowClassicWrath = true
+	end
+end
+
+-- compatibility/feature flags
+IceHUD.GetPlayerAuraBySpellID = _G["C_UnitAuras"] and C_UnitAuras.GetPlayerAuraBySpellID
+IceHUD.SpellFunctionsReturnRank = IceHUD.WowMain and IceHUD.WowVer < 80000
+IceHUD.EventExistsPlayerPetChanged = IceHUD.WowMain and IceHUD.WowVer < 80000
+IceHUD.EventExistsPetBarChanged = IceHUD.WowMain and IceHUD.WowVer < 80000
+IceHUD.EventExistsPlayerComboPoints = IceHUD.WowMain and IceHUD.WowVer < 30000
+IceHUD.EventExistsUnitComboPoints = IceHUD.WowMain and IceHUD.WowVer < 70000
+IceHUD.EventExistsUnitMaxPower = IceHUD.WowMain and IceHUD.WowVer >= 40000
+IceHUD.EventExistsGroupRosterUpdate = IceHUD.WowVer >= 50000 or not IceHUD.WowMain
+IceHUD.EventExistsUnitDynamicFlags = IceHUD.WowMain and IceHUD.WowVer < 80000
+IceHUD.EventExistsUnitHealthFrequent = not IceHUD.WowMain or (IceHUD.WowVer >= 40000 and IceHUD.WowVer < 90000)
+IceHUD.PerPowerEventsExist = IceHUD.WowMain and IceHUD.WowVer < 40000
+IceHUD.PerTargetComboPoints = IceHUD.WowVer < 60000
+IceHUD.CanTrackOtherUnitBuffs = not IceHUD.WowClassic
+IceHUD.CanTrackGCD = not IceHUD.WowClassic
+IceHUD.GetSpellInfoReturnsFunnel = IceHUD.WowMain and IceHUD.WowVer < 60000
+IceHUD.CanHookDestroyTotem = IceHUD.WowClassic or IceHUD.WowClassicBC or IceHUD.WowClassicWrath
+IceHUD.ShouldUpdateTargetHealthEveryTick = (IceHUD.WowClassic or IceHUD.WowClassicBC) and GetCVarBool("predictedHealth")
+IceHUD.UsesUIPanelButtonTemplate = IceHUD.WowVer >= 50000 or not IceHUD.WowMain
+IceHUD.EventExistsSpellcastInterruptible = IceHUD.WowVer >= 30200 and not IceHUD.WowClassicWrath
+IceHUD.DeathKnightUnholyFrostRunesSwapped = IceHUD.WowVer < 70300 and not IceHUD.WowClassicWrath
+IceHUD.SupportsHealPrediction = IceHUD.WowVer >= 40000 or IceHUD.WowClassicWrath
+IceHUD.UnitGroupRolesReturnsRoleString = IceHUD.WowVer >= 40000 or IceHUD.WowClassicWrath
+IceHUD.ShellGameSpellID = 271571
+IceHUD.HasShellGame = GetSpellInfo(IceHUD.ShellGameSpellID)
+
+IceHUD.UnitPowerEvent = "UNIT_POWER_UPDATE"
 
 IceHUD.validBarList = { "Bar", "HiBar", "RoundBar", "ColorBar", "RivetBar", "RivetBar2", "CleanCurves", "GlowArc",
 	"BloodGlaives", "ArcHUD", "FangRune", "DHUD", "CleanCurvesOut", "CleanTank", "PillTank", "GemTank" }
 IceHUD.validCustomModules = {Bar="Buff/Debuff watcher", Counter="Buff/Debuff stack counter", CD="Cooldown bar", Health="Health bar", Mana="Mana bar", CounterBar="Stack count bar"}
 
+IceHUD_UnitFrame_DropDown = CreateFrame("Frame", "IceHUD_UnitFrame_DropDown", UIParent, "UIDropDownMenuTemplate")
+
 --@debug@
 IceHUD.optionsLoaded = true
 --@end-debug@
@@ -46,6 +93,43 @@ end
 
 IceHUD.deepcopy = deepcopy
 
+function IceHUD:removeDefaults(db, defaults, blocker)
+	-- remove all metatables from the db, so we don't accidentally create new sub-tables through them
+	setmetatable(db, nil)
+	-- loop through the defaults and remove their content
+	for k,v in pairs(defaults) do
+		if type(v) == "table" and type(db[k]) == "table" then
+			-- if a blocker was set, dive into it, to allow multi-level defaults
+			self:removeDefaults(db[k], v, blocker and blocker[k])
+			if next(db[k]) == nil then
+				db[k] = nil
+			end
+		else
+			-- check if the current value matches the default, and that its not blocked by another defaults table
+			if db[k] == defaults[k] and (not blocker or blocker[k] == nil) then
+				db[k] = nil
+			end
+		end
+	end
+end
+
+function IceHUD:populateDefaults(db, defaults, blocker)
+	-- remove all metatables from the db, so we don't accidentally create new sub-tables through them
+	setmetatable(db, nil)
+	-- loop through the defaults and add their content
+	for k,v in pairs(defaults) do
+		if type(v) == "table" and type(db[k]) == "table" then
+			-- if a blocker was set, dive into it, to allow multi-level defaults
+			self:populateDefaults(db[k], v, blocker and blocker[k])
+		else
+			-- check if the current value matches the default, and that its not blocked by another defaults table
+			if db[k] == nil then
+				db[k] = defaults[k]
+			end
+		end
+	end
+end
+
 IceHUD.Location = "Interface\\AddOns\\IceHUD"
 
 StaticPopupDialogs["ICEHUD_CUSTOM_BAR_CREATED"] =
@@ -256,6 +340,10 @@ function IceHUD:NotifyOptionsChange()
 end
 
 function IceHUD:OnEnable(isFirst)
+--	if isFirst then
+		self:SetDebugging(self.IceCore:GetDebug())
+		self.debugFrame = ChatFrame1
+--	end
 	self:Debug("IceHUD:OnEnable()")
 
 	if self.db.profile.enable then
@@ -271,11 +359,6 @@ function IceHUD:OnEnable(isFirst)
 	--@debug@
 	IceHUD_Options:OnLoad()
 	--@end-debug@
-
---	if isFirst then
-		self:SetDebugging(self.IceCore:GetDebug())
-		self.debugFrame = ChatFrame1
---	end
 end
 
 -- add settings changes/updates here so that existing users don't lose their settings
@@ -322,7 +405,7 @@ end
 -- blizzard interface options
 local blizOptionsPanel = CreateFrame("FRAME", "IceHUDConfigPanel", UIParent)
 blizOptionsPanel.name = "IceHUD"
-blizOptionsPanel.button = CreateFrame("BUTTON", "IceHUDOpenConfigButton", blizOptionsPanel, IceHUD.WowVer >= 50000 and "UIPanelButtonTemplate" or "UIPanelButtonTemplate2")
+blizOptionsPanel.button = CreateFrame("BUTTON", "IceHUDOpenConfigButton", blizOptionsPanel, IceHUD.UsesUIPanelButtonTemplate and "UIPanelButtonTemplate" or "UIPanelButtonTemplate2")
 blizOptionsPanel.button:SetText("Open IceHUD configuration")
 blizOptionsPanel.button:SetWidth(240)
 blizOptionsPanel.button:SetHeight(30)
@@ -364,7 +447,11 @@ function IceHUD:Debug(...)
 		for n=1,select('#', ...) do
 			msg = msg .. tostring(select(n, ...)) .. " "
 		end
-		self.debugFrame:AddMessage(msg)
+		if self.debugFrame then
+			self.debugFrame:AddMessage(msg)
+		else
+			print(msg)
+		end
 	end
 end
 
@@ -408,8 +495,23 @@ function IceHUD:GetAuraCount(auraType, unit, ability, onlyMine, matchByName)
 		return 0
 	end
 
+	-- Support for Spell IDs
+	if (IceHUD.GetPlayerAuraBySpellID and tonumber(ability) ~= nil) then
+		local aura = C_UnitAuras.GetPlayerAuraBySpellID(ability)
+		if aura ~= nil then
+			return aura.applications
+		else
+			return 0
+		end
+	end
+
 	local i = 1
-	local name, _, texture, applications = UnitAura(unit, i, auraType..(onlyMine and "|PLAYER" or ""))
+	local name, _, texture, applications
+	if IceHUD.SpellFunctionsReturnRank then
+		name, _, texture, applications = UnitAura(unit, i, auraType..(onlyMine and "|PLAYER" or ""))
+	else
+		name, texture, applications = UnitAura(unit, i, auraType..(onlyMine and "|PLAYER" or ""))
+	end
 	while name do
 		if (not matchByName and string.match(texture:upper(), ability:upper()))
 			or (matchByName and string.match(name:upper(), ability:upper())) then
@@ -417,7 +519,11 @@ function IceHUD:GetAuraCount(auraType, unit, ability, onlyMine, matchByName)
 		end
 
 		i = i + 1
-		name, _, texture, applications = UnitAura(unit, i, auraType..(onlyMine and "|PLAYER" or ""))
+		if IceHUD.SpellFunctionsReturnRank then
+			name, _, texture, applications = UnitAura(unit, i, auraType..(onlyMine and "|PLAYER" or ""))
+		else
+			name, texture, applications = UnitAura(unit, i, auraType..(onlyMine and "|PLAYER" or ""))
+		end
 	end
 
 	return 0
@@ -426,13 +532,18 @@ end
 do
 	local retval = {}
 
-	function IceHUD:HasBuffs(unit, spellIDs)
+	function IceHUD:HasBuffs(unit, spellIDs, filter)
 		for i=1, #spellIDs do
 			retval[i] = false
 		end
 
 		local i = 1
-		local name, _, texture, applications, _, _, _, _, _, _, auraID = UnitAura(unit, i)
+		local name, _, texture, applications, _, _, _, _, _, _, auraID
+		if IceHUD.SpellFunctionsReturnRank then
+			name, _, texture, applications, _, _, _, _, _, _, auraID = UnitAura(unit, i, filter)
+		else
+			name, texture, applications, _, _, _, _, _, _, auraID = UnitAura(unit, i, filter)
+		end
 		while name do
 			for i=1, #spellIDs do
 				if spellIDs[i] == auraID then
@@ -442,11 +553,43 @@ do
 			end
 
 			i = i + 1
-			name, _, texture, applications, _, _, _, _, _, _, auraID = UnitAura(unit, i)
+			if IceHUD.SpellFunctionsReturnRank then
+				name, _, texture, applications, _, _, _, _, _, _, auraID = UnitAura(unit, i, filter)
+			else
+				name, texture, applications, _, _, _, _, _, _, auraID = UnitAura(unit, i, filter)
+			end
 		end
 
 		return retval
 	end
+
+	function IceHUD:HasDebuffs(unit, spellIDs, filter)
+		return IceHUD:HasBuffs(unit, spellIDs, filter and filter.."|HARMFUL" or "HARMFUL")
+	end
+
+	function IceHUD:HasAnyBuff(unit, spellIDs, filter)
+		local buffs = IceHUD:HasBuffs(unit, spellIDs, filter)
+
+		for i=1, #buffs do
+			if buffs[i] then
+				return true
+			end
+		end
+
+		return false
+	end
+
+	function IceHUD:HasAnyDebuff(unit, spellIDs, filter)
+		local debuffs = IceHUD:HasDebuffs(unit, spellIDs, filter)
+
+		for i=1, #debuffs do
+			if debuffs[i] then
+				return true
+			end
+		end
+
+		return false
+	end
 end
 
 function IceHUD:OnDisable()
@@ -581,15 +724,19 @@ local function CheckLFGMode(mode)
 end
 
 function IceHUD:GetIsInLFGGroup()
+	if not GetLFGMode then
+		return false
+	end
+
 	local mode, submode
-	if IceHUD.WowVer >= 50000 then
+	if LE_LFG_CATEGORY_LFD then
 		mode, submode = GetLFGMode(LE_LFG_CATEGORY_LFD)
 	else
 		mode, submode = GetLFGMode()
 	end
 	local IsInLFGGroup = CheckLFGMode(mode)
 
-	if IceHUD.WowVer < 50000 then
+	if not LE_LFG_CATEGORY_LFD then
 		return IsInLFGGroup
 	end
 
@@ -609,31 +756,69 @@ function IceHUD:GetIsInLFGGroup()
 	return IsInLFGGroup
 end
 
-local BLACKLISTED_UNIT_MENU_OPTIONS = {
-	SET_FOCUS = "ICEHUD_SET_FOCUS",
-	CLEAR_FOCUS = "ICEHUD_CLEAR_FOCUS",
-    PET_DISMISS = "ICEHUD_PET_DISMISS",
-	LOCK_FOCUS_FRAME = true,
-	UNLOCK_FOCUS_FRAME = true,
-}
+local BLACKLISTED_UNIT_MENU_OPTIONS = {}
+if UnitPopupButtons then
+	BLACKLISTED_UNIT_MENU_OPTIONS = {
+		SET_FOCUS = "ICEHUD_SET_FOCUS",
+		CLEAR_FOCUS = "ICEHUD_CLEAR_FOCUS",
+		LOCK_FOCUS_FRAME = true,
+		UNLOCK_FOCUS_FRAME = true,
+	}
+	if select(2, UnitClass("player")) ~= "WARLOCK" then
+		BLACKLISTED_UNIT_MENU_OPTIONS[PET_DISMISS] = "ICEHUD_PET_DISMISS"
+	end
 
-UnitPopupButtons["ICEHUD_SET_FOCUS"] = {
-	text = L["Type %s to set focus"]:format(SLASH_FOCUS1),
-	tooltipText = L["Blizzard currently does not provide a proper way to right-click focus with custom unit frames."],
-	dist = 0,
-}
+	UnitPopupButtons["ICEHUD_SET_FOCUS"] = {
+		text = L["Type %s to set focus"]:format(SLASH_FOCUS1),
+		tooltipText = L["Blizzard currently does not provide a proper way to right-click focus with custom unit frames."],
+		dist = 0,
+	}
 
-UnitPopupButtons["ICEHUD_CLEAR_FOCUS"] = {
-	text = L["Type %s to clear focus"]:format(SLASH_CLEARFOCUS1),
-	tooltipText = L["Blizzard currently does not provide a proper way to right-click focus with custom unit frames."],
-	dist = 0,
-}
+	UnitPopupButtons["ICEHUD_CLEAR_FOCUS"] = {
+		text = L["Type %s to clear focus"]:format(SLASH_CLEARFOCUS1),
+		tooltipText = L["Blizzard currently does not provide a proper way to right-click focus with custom unit frames."],
+		dist = 0,
+	}
 
-UnitPopupButtons["ICEHUD_PET_DISMISS"] = {
-	text = L["Use your Dismiss Pet spell to dismiss a pet"],
-	tooltipText = L["Blizzard currently does not provide a proper way to right-click dismiss a pet with custom unit frames."],
-	dist = 0,
-}
+	UnitPopupButtons["ICEHUD_PET_DISMISS"] = {
+		text = L["Use your Dismiss Pet spell to dismiss a pet"],
+		tooltipText = L["Blizzard currently does not provide a proper way to right-click dismiss a pet with custom unit frames."],
+		dist = 0,
+	}
+elseif UnitPopupSetFocusButtonMixin then
+	IceHUDUnitPopupSetFocusButtonMixin = CreateFromMixins(UnitPopupButtonBaseMixin)
+	function IceHUDUnitPopupSetFocusButtonMixin:GetText()
+		return L["Type %s to set focus"]:format(SLASH_FOCUS1)
+	end
+	function IceHUDUnitPopupSetFocusButtonMixin:OnClick()
+	end
+
+	IceHUDUnitPopupClearFocusButtonMixin = CreateFromMixins(UnitPopupButtonBaseMixin)
+	function IceHUDUnitPopupClearFocusButtonMixin:GetText()
+		return L["Type %s to clear focus"]:format(SLASH_CLEARFOCUS1)
+	end
+	function IceHUDUnitPopupClearFocusButtonMixin:OnClick()
+	end
+
+	IceHUDUnitPopupPetDismissButtonMixin = CreateFromMixins(UnitPopupButtonBaseMixin)
+	function IceHUDUnitPopupPetDismissButtonMixin:GetText()
+		return L["Use your Dismiss Pet spell to dismiss a pet"]
+	end
+	function IceHUDUnitPopupPetDismissButtonMixin:CanShow()
+		return UnitPopupPetDismissButtonMixin:CanShow()
+	end
+	function IceHUDUnitPopupPetDismissButtonMixin:OnClick()
+	end
+
+	BLACKLISTED_UNIT_MENU_OPTIONS[SET_FOCUS] = IceHUDUnitPopupSetFocusButtonMixin
+	BLACKLISTED_UNIT_MENU_OPTIONS[CLEAR_FOCUS] = IceHUDUnitPopupClearFocusButtonMixin
+	BLACKLISTED_UNIT_MENU_OPTIONS[LOCK_FOCUS_FRAME] = true
+	BLACKLISTED_UNIT_MENU_OPTIONS[UNLOCK_FOCUS_FRAME] = true
+
+	if select(2, UnitClass("player")) ~= "WARLOCK" then
+		BLACKLISTED_UNIT_MENU_OPTIONS[PET_DISMISS] = IceHUDUnitPopupPetDismissButtonMixin
+	end
+end
 
 local munged_unit_menus = {}
 local function munge_unit_menu(menu)
@@ -654,11 +839,34 @@ local function munge_unit_menu(menu)
 	end
 
 	local found = false
-	local _, v
-	for _, v in ipairs(data) do
-		if BLACKLISTED_UNIT_MENU_OPTIONS[v] then
-			found = true
-			break
+	if data.GetMenuButtons then
+		local btns = data.GetMenuButtons()
+		for i=1, #btns do
+			if btns[i].IsMenu() then
+				local subbtns = btns[i].GetMenuButtons()
+				for j=1, #subbtns do
+					if BLACKLISTED_UNIT_MENU_OPTIONS[subbtns[j]:GetText()] then
+						found = true
+						break
+					end
+				end
+			else
+				if BLACKLISTED_UNIT_MENU_OPTIONS[btns[i]:GetText()] then
+					found = true
+					break
+				end
+			end
+
+			if found then
+				break
+			end
+		end
+	else
+		for _, v in ipairs(data) do
+			if BLACKLISTED_UNIT_MENU_OPTIONS[v] then
+				found = true
+				break
+			end
 		end
 	end
 
@@ -669,15 +877,42 @@ local function munge_unit_menu(menu)
 	end
 
 	local new_data = {}
-	for _, v in ipairs(data) do
-		local blacklisted = BLACKLISTED_UNIT_MENU_OPTIONS[v]
-		if v == "PET_DISMISS" and select(2, UnitClass("player")) == "WARLOCK" then
-			blacklisted = false
+	if data.GetMenuButtons then
+		local new_buttons_list = {}
+		local btns = data.GetMenuButtons()
+		for i=1, #btns do
+			if btns[i].IsMenu() then
+				local subbtns = btns[i].GetMenuButtons()
+				for j=1, #subbtns do
+					local blacklisted = BLACKLISTED_UNIT_MENU_OPTIONS[subbtns[j]:GetText()]
+					if not blacklisted then
+						new_buttons_list[#new_buttons_list+1] = subbtns[j]
+					elseif blacklisted ~= true then
+						new_buttons_list[#new_buttons_list+1] = blacklisted
+					end
+				end
+			else
+				local blacklisted = BLACKLISTED_UNIT_MENU_OPTIONS[btns[i]:GetText()]
+				if not blacklisted then
+					new_buttons_list[#new_buttons_list+1] = btns[i]
+				elseif blacklisted ~= true then
+					new_buttons_list[#new_buttons_list+1] = blacklisted
+				end
+			end
 		end
-		if not blacklisted then
-			new_data[#new_data+1] = v
-		elseif blacklisted ~= true then
-			new_data[#new_data+1] = blacklisted
+
+		new_data = data
+		function new_data:GetMenuButtons()
+			return new_buttons_list
+		end
+	else
+		for _, v in ipairs(data) do
+			local blacklisted = BLACKLISTED_UNIT_MENU_OPTIONS[v]
+			if not blacklisted then
+				new_data[#new_data+1] = v
+			elseif blacklisted ~= true then
+				new_data[#new_data+1] = blacklisted
+			end
 		end
 	end
 	local new_menu_name = "ICEHUD_" .. menu
@@ -723,8 +958,9 @@ local function figure_unit_menu(unit)
 	return "PLAYER"
 end
 
-IceHUD_UnitFrame_DropDown = CreateFrame("Frame", "IceHUD_UnitFrame_DropDown", UIParent, "UIDropDownMenuTemplate")
-UnitPopupFrames[#UnitPopupFrames+1] = "IceHUD_UnitFrame_DropDown"
+if UnitPopupFrames then
+	UnitPopupFrames[#UnitPopupFrames+1] = "IceHUD_UnitFrame_DropDown"
+end
 
 IceHUD.DropdownUnit = nil
 UIDropDownMenu_Initialize(IceHUD_UnitFrame_DropDown, function()
@@ -738,3 +974,53 @@ UIDropDownMenu_Initialize(IceHUD_UnitFrame_DropDown, function()
 		UnitPopup_ShowMenu(IceHUD_UnitFrame_DropDown, menu, IceHUD.DropdownUnit, nil, id)
 	end
 end, "MENU", nil)
+
+function IceHUD:OutOfCombatWrapper(func)
+	return function(...)
+		return IceHUD:RunOnLeaveCombat(func, ...)
+	end
+end
+
+do
+	local in_combat = false
+	local in_lockdown = false
+	local actions_to_perform = {}
+	local pool = setmetatable({}, {__mode='k'})
+	function IceHUD:PLAYER_REGEN_ENABLED()
+		in_combat = false
+		in_lockdown = false
+		for i, t in ipairs(actions_to_perform) do
+			t.f(unpack(t, 1, t.n))
+			actions_to_perform[i] = nil
+			wipe(t)
+			pool[t] = true
+		end
+	end
+	function IceHUD:PLAYER_REGEN_DISABLED()
+		in_combat = true
+	end
+	function IceHUD:RunOnLeaveCombat(func, ...)
+		if not in_combat then
+			-- out of combat, call right away and return
+			func(...)
+			return
+		end
+		if not in_lockdown then
+			in_lockdown = InCombatLockdown() -- still in PLAYER_REGEN_DISABLED
+			if not in_lockdown then
+				func(...)
+				return
+			end
+		end
+		local t = next(pool) or {}
+		pool[t] = nil
+
+		t.f = func
+		local n = select('#', ...)
+		t.n = n
+		for i = 1, n do
+			t[i] = select(i, ...)
+		end
+		actions_to_perform[#actions_to_perform+1] = t
+	end
+end

IceHUD.toc

@@ -1,15 +1,25 @@
-## Interface: 60200
+## Interface: 100002
+## Interface-Retail: 100002
+## Interface-Classic: 11403
+## Interface-BCC: 20504
+## Interface-Wrath: 30400
 ## Author: Parnic, originally created by Iceroth
 ## Name: IceHUD
 ## Title: IceHUD |cff7fff7f-Ace3-|r
 ## Notes: Another HUD addon
-## Version: @project-version@
+#@debug@
+## Version: development
+#@end-debug@
+#@non-debug@
+# ## Version: @project-version@
+#@end-non-debug@
 ## SavedVariables: IceCoreDB
 ## OptionalDeps: Ace3, LibSharedMedia-3.0, LibDogTag-3.0, LibDogTag-Unit-3.0, LibRangeCheck-2.0, LibDualSpec-1.0, LibDBIcon-1.0, AceGUI-3.0-SharedMediaWidgets
-## X-Compatible-With: 70000
 ## X-Category: HUDs
-## X-Website: http://www.wowace.com/projects/ice-hud/
+## X-Website: https://www.wowace.com/projects/ice-hud
+## X-Curse-Project-ID: 5394
 ## X-WoWI-ID: 8149
+## X-Wago-ID: 5bGolJN0
 
 #@no-lib-strip@
 # Libraries
@@ -29,7 +39,6 @@ IceCastBar.lua
 IceStackCounter.lua
 
 # IceHUD modules
-# - Feel free to comment these out if you like
 modules\PlayerHealth.lua
 modules\PlayerMana.lua
 modules\TargetHealth.lua
@@ -89,7 +98,12 @@ modules\FocusAbsorb.lua
 modules\Stagger.lua
 modules\PlayerAltMana.lua
 modules\ArcaneCharges.lua
+modules\RollTheBones.lua
+modules\EssencePower.lua
 
 #@do-not-package@
+IceHUD_Options\Json.lua
+IceHUD_Options\JsonDecode.lua
+IceHUD_Options\JsonEncode.lua
 IceHUD_Options\Options.lua
 #@end-do-not-package@

IceHUD_Options/IceHUD_Options.toc

@@ -1,4 +1,8 @@
-## Interface: 60200
+## Interface: 100002
+## Interface-Retail: 100002
+## Interface-Classic: 11403
+## Interface-BCC: 20504
+## Interface-Wrath: 30400
 ## Title: IceHUD |cff7fff7f-Options-|r
 ## Author: Parnic
 ## Version: @project-version@
@@ -7,4 +11,7 @@
 ## Dependencies: IceHUD
 ## LoadOnDemand: 1
 
+Json.lua
+JsonDecode.lua
+JsonEncode.lua
 Options.lua

IceHUD_Options/Json.lua

@@ -0,0 +1 @@
+IceHUD.json = {}

IceHUD_Options/JsonDecode.lua

@@ -0,0 +1,241 @@
+local parse
+
+local function create_set(...)
+    local res = {}
+    for i = 1, select("#", ...) do
+        res[select(i, ...)] = true
+    end
+    return res
+end
+
+local space_chars  = create_set(" ", "\t", "\r", "\n")
+local delim_chars  = create_set(" ", "\t", "\r", "\n", "]", "}", ",")
+local escape_chars = create_set("\\", "/", '"', "b", "f", "n", "r", "t", "u")
+local literals     = create_set("true", "false", "null")
+
+local literal_map = {
+    ["true"] = true,
+    ["false"] = false,
+    ["null"] = nil,
+}
+
+
+local function next_char(str, idx, set, negate)
+    for i = idx, #str do
+        if set[str:sub(i, i)] ~= negate then
+            return i
+        end
+    end
+    return #str + 1
+end
+
+local function decode_error(str, idx, msg)
+    local line_count = 1
+    local col_count = 1
+    for i = 1, idx - 1 do
+        col_count = col_count + 1
+        if str:sub(i, i) == "\n" then
+            line_count = line_count + 1
+            col_count = 1
+        end
+    end
+
+    return string.format("%s at line %d col %d", msg, line_count, col_count)
+end
+
+local function codepoint_to_utf8(n)
+    -- http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=iws-appendixa
+    local f = math.floor
+    if n <= 0x7f then
+        return string.char(n)
+    elseif n <= 0x7ff then
+        return string.char(f(n / 64) + 192, n % 64 + 128)
+    elseif n <= 0xffff then
+        return string.char(f(n / 4096) + 224, f(n % 4096 / 64) + 128, n % 64 + 128)
+    elseif n <= 0x10ffff then
+        return string.char(f(n / 262144) + 240, f(n % 262144 / 4096) + 128,
+            f(n % 4096 / 64) + 128, n % 64 + 128)
+    end
+    return "", string.format("invalid unicode codepoint '%x'", n)
+end
+
+local function parse_unicode_escape(s)
+    local n1 = tonumber(s:sub(1, 4), 16)
+    local n2 = tonumber(s:sub(7, 10), 16)
+    -- Surrogate pair?
+    if n2 then
+        return codepoint_to_utf8((n1 - 0xd800) * 0x400 + (n2 - 0xdc00) + 0x10000)
+    else
+        return codepoint_to_utf8(n1)
+    end
+end
+
+local function parse_string(str, i)
+    local res = ""
+    local j = i + 1
+    local k = j
+
+    while j <= #str do
+        local x = str:byte(j)
+
+        if x < 32 then
+            return str, j, decode_error(str, j, "control character in string")
+
+        elseif x == 92 then -- `\`: Escape
+            res = res .. str:sub(k, j - 1)
+            j = j + 1
+            local c = str:sub(j, j)
+            if c == "u" then
+                local hex = str:match("^[dD][89aAbB]%x%x\\u%x%x%x%x", j + 1)
+                    or str:match("^%x%x%x%x", j + 1)
+                    or false
+                if hex == false then
+                    return str, j-1, decode_error(str, j - 1, "invalid unicode escape in string")
+                end
+                res = res .. parse_unicode_escape(hex)
+                j = j + #hex
+            else
+                if not escape_chars[c] then
+                    return str, j-1, decode_error(str, j - 1, "invalid escape char '" .. c .. "' in string")
+                end
+                res = res .. escape_char_map_inv[c]
+            end
+            k = j + 1
+
+        elseif x == 34 then -- `"`: End of string
+            res = res .. str:sub(k, j - 1)
+            return res, j + 1
+        end
+
+        j = j + 1
+    end
+
+    return str, i, decode_error(str, i, "expected closing quote for string")
+end
+
+local function parse_number(str, i)
+    local x = next_char(str, i, delim_chars)
+    local s = str:sub(i, x - 1)
+    local n = tonumber(s)
+    if not n then
+        return -1, -1, decode_error(str, i, "invalid number '" .. s .. "'")
+    end
+    return n, x
+end
+
+local function parse_literal(str, i)
+    local x = next_char(str, i, delim_chars)
+    local word = str:sub(i, x - 1)
+    if not literals[word] then
+        return false, -1, decode_error(str, i, "invalid literal '" .. word .. "'")
+    end
+    return literal_map[word], x
+end
+
+local function parse_array(str, i)
+    local res = {}
+    local n = 1
+    i = i + 1
+    while 1 do
+        local x
+        i = next_char(str, i, space_chars, true)
+        -- Empty / end of array?
+        if str:sub(i, i) == "]" then
+            i = i + 1
+            break
+        end
+        -- Read token
+        x, i = parse(str, i)
+        res[n] = x
+        n = n + 1
+        -- Next token
+        i = next_char(str, i, space_chars, true)
+        local chr = str:sub(i, i)
+        i = i + 1
+        if chr == "]" then break end
+        if chr ~= "," then return nil, -1, decode_error(str, i, "expected ']' or ','") end
+    end
+    return res, i
+end
+
+local function parse_object(str, i)
+    local res = {}
+    i = i + 1
+    while 1 do
+        local key, val
+        i = next_char(str, i, space_chars, true)
+        -- Empty / end of object?
+        if str:sub(i, i) == "}" then
+            i = i + 1
+            break
+        end
+        -- Read key
+        if str:sub(i, i) ~= '"' then
+            return nil, -1, decode_error(str, i, "expected string for key")
+        end
+        key, i = parse(str, i)
+        -- Read ':' delimiter
+        i = next_char(str, i, space_chars, true)
+        if str:sub(i, i) ~= ":" then
+            return nil, -1, decode_error(str, i, "expected ':' after key")
+        end
+        i = next_char(str, i + 1, space_chars, true)
+        -- Read value
+        val, i = parse(str, i)
+        -- Set
+        res[key] = val
+        -- Next token
+        i = next_char(str, i, space_chars, true)
+        local chr = str:sub(i, i)
+        i = i + 1
+        if chr == "}" then break end
+        if chr ~= "," then return nil, -1, decode_error(str, i, "expected '}' or ','") end
+    end
+    return res, i
+end
+
+local char_func_map = {
+    ['"'] = parse_string,
+    ["0"] = parse_number,
+    ["1"] = parse_number,
+    ["2"] = parse_number,
+    ["3"] = parse_number,
+    ["4"] = parse_number,
+    ["5"] = parse_number,
+    ["6"] = parse_number,
+    ["7"] = parse_number,
+    ["8"] = parse_number,
+    ["9"] = parse_number,
+    ["-"] = parse_number,
+    ["t"] = parse_literal,
+    ["f"] = parse_literal,
+    ["n"] = parse_literal,
+    ["["] = parse_array,
+    ["{"] = parse_object,
+}
+
+
+parse = function(str, idx)
+    local chr = str:sub(idx, idx)
+    local f = char_func_map[chr]
+    if f then
+        return f(str, idx)
+    end
+    return false, -1, decode_error(str, idx, "unexpected character '" .. chr .. "'")
+end
+
+
+function IceHUD.json.decode(str)
+    if type(str) ~= "string" then
+        return nil, "expected argument of type string, got " .. type(str)
+    end
+    local res, idx, err = parse(str, next_char(str, 1, space_chars, true))
+    if err ~= nil then
+        return nil, err
+    end
+    idx = next_char(str, idx, space_chars, true)
+    if idx <= #str then
+        return nil, decode_error(str, idx, "trailing garbage")
+    end
+    return res, nil
+end

IceHUD_Options/JsonEncode.lua

@@ -0,0 +1,100 @@
+local encode
+
+local escape_char_map = {
+	["\\"] = "\\",
+	["\""] = "\"",
+	["\b"] = "b",
+	["\f"] = "f",
+	["\n"] = "n",
+	["\r"] = "r",
+	["\t"] = "t",
+}
+
+local escape_char_map_inv = { ["/"] = "/" }
+for k, v in pairs(escape_char_map) do
+	escape_char_map_inv[v] = k
+end
+
+
+local function escape_char(c)
+	return "\\" .. (escape_char_map[c] or string.format("u%04x", c:byte()))
+end
+
+local function encode_nil(val)
+	return "null"
+end
+
+local function encode_table(val, stack)
+	local res = {}
+	stack = stack or {}
+
+	-- Circular reference?
+	if stack[val] then error("circular reference") end
+
+	stack[val] = true
+
+	if rawget(val, 1) ~= nil or next(val) == nil then
+		-- Treat as array -- check keys are valid and it is not sparse
+		local n = 0
+		for k in pairs(val) do
+			if type(k) ~= "number" then
+				error("invalid table: mixed or invalid key types")
+			end
+			n = n + 1
+		end
+		if n ~= #val then
+			error("invalid table: sparse array")
+		end
+		-- Encode
+		for i, v in ipairs(val) do
+			table.insert(res, encode(v, stack))
+		end
+		stack[val] = nil
+		return "[" .. table.concat(res, ",") .. "]"
+
+	else
+		-- Treat as an object
+		for k, v in pairs(val) do
+			if type(k) ~= "string" then
+				error("invalid table: mixed or invalid key types")
+			end
+			table.insert(res, encode(k, stack) .. ":" .. encode(v, stack))
+		end
+		stack[val] = nil
+		return "{" .. table.concat(res, ",") .. "}"
+	end
+end
+
+local function encode_string(val)
+	return '"' .. val:gsub('[%z\1-\31\\"]', escape_char) .. '"'
+end
+
+local function encode_number(val)
+	-- Check for NaN, -inf and inf
+	if val ~= val or val <= -math.huge or val >= math.huge then
+		error("unexpected number value '" .. tostring(val) .. "'")
+	end
+	return string.format("%.14g", val)
+end
+
+local type_func_map = {
+	["nil"] = encode_nil,
+	["table"] = encode_table,
+	["string"] = encode_string,
+	["number"] = encode_number,
+	["boolean"] = tostring,
+}
+
+
+encode = function(val, stack)
+	local t = type(val)
+	local f = type_func_map[t]
+	if f then
+		return f(val, stack)
+	end
+	error("unexpected type '" .. t .. "'")
+end
+
+function IceHUD.json.encode(val)
+	return (encode(val))
+end

IceHUD_Options/Options.lua

@@ -1,6 +1,8 @@
 local LibDualSpec = LibStub('LibDualSpec-1.0', true)
 local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
-local icon = LibStub("LibDBIcon-1.0")
+local icon = LibStub("LibDBIcon-1.0", true)
+local AceGUI = LibStub("AceGUI-3.0")
+local AceSerializer = LibStub("AceSerializer-3.0", 1)
 local lastCustomModule = "Bar"
 
 IceHUD_Options = {}
@@ -65,19 +67,31 @@ Expand "|cffffdc42Module Settings|r", expand PlayerHealth (or TargetHealth for t
 Expand "|cffffdc42Module Settings|r", expand PlayerInfo (or TargetInfo for targets), select Buff Settings or Debuff Settings, and un-check "show buffs" (or "show debuffs").
 
 |cff9999ff12. How do I turn off these big huge bars that pulse whenever one of my abilities procs?|r
-This isn't |cff9999ffIceHUD|r - it's Blizzard's new Spell Alerts they added in 4.0.1. Interface options => Combat => "Show Spell Alerts" to turn them off or search for a mod to tweak their positioning/size/etc.
+This isn't |cff9999ffIceHUD|r - it's Blizzard's Spell Alerts they added in 4.0.1. Interface options => Combat => "Spell Alert Opacity" to turn them off or search for a mod to tweak their positioning/size/etc.
 
 |cff9999ff13. I don't like where some of the bars are placed. How do I put the health/mana on the left/right?|r
 Expand "|cffffdc42Module Settings|r", expand whatever module you want to move (e.g. PlayerHealth, PlayerMana), and adjust the "Side" and "Offset" settings. "Side" controls whether it's on the left or the right and "Offset" controls how far from center it is.
 
 |cff9999ff14. Which module displays Monk Chi power?|r
-This module is called HarmonyPower. Harmony was the original name for Chi back when 5.0 was in beta, so I used Blizzard's name for it while I was developing for Cataclysm. I feel like it's too late to change now that many people are familiar with the Harmony name.
+Prior to |cff9999ffIceHUD|r v1.11.2, this module was called |cffdcff42HarmonyPower|r. Harmony was the original name for Chi back when 5.0 was in beta, so I used Blizzard's name for it while I was developing for Cataclysm. |cff9999ffIceHUD|r v1.11.2 changed this module to be called |cffdcff42Chi|r.
 
 |cff9999ff15. How do I add commas/periods into big numbers like health?|r
-If you have DogTags enabled, you can open the Text Settings for the module in question and add SeparateDigits() around the tag you're trying to split up. To display Health/MaxHealth with commas, use: [(SeparateDigits(HP):HPColor "/" SeparateDigits(MaxHP):HPColor):Bracket]. To use periods instead of commas, use: [(SeparateDigits(HP, "."):HPColor "/" SeparateDigits(MaxHP, "."):HPColor):Bracket]. Use the /dog help menu to build your own similar tags for Mana, etc.
+If you have |cff42ffffDogTags|r enabled, you can open the Text Settings for the module in question and add SeparateDigits() around the tag you're trying to split up. To display Health/MaxHealth with commas, use: [(SeparateDigits(HP):HPColor "/" SeparateDigits(MaxHP):HPColor):Bracket]. To use periods instead of commas, use: [(SeparateDigits(HP, "."):HPColor "/" SeparateDigits(MaxHP, "."):HPColor):Bracket]. Use the /dog help menu to build your own similar tags for Mana, etc.
 
 |cff9999ff16. The countdown timers on buffs and debuffs completely obscure the icon. How do I disable the timer text?|r
-IceHUD is not responsible for this countdown text and cannot control it. The 6.0 patch added an option in the game client to display counts on top of cooldowns. Look at the Action Bars menu under the game's Interface options. You can turn the text on or off there. Mods like OmniCC or CooldownCount will generally give you the same feature but allow you to control when, where, and how the text shows up.]]
+|cff9999ffIceHUD|r is not responsible for this countdown text and cannot control it. The 6.0 patch added an option in the game client to display counts on top of cooldowns. Look at the Action Bars menu under the game's Interface options. You can turn the text on or off there. Mods like |cff42ffffOmniCC|r or |cff42ffffCooldownCount|r will generally give you the same feature but allow you to control when, where, and how the text shows up.
+
+|cff9999ff17. When I rotate some modules 90 degrees, such as the castbar, the bar appears to wiggle up and down as it fills or empties. How do I fix this?|r
+This is a side effect of the animation API that I'm co-opting to force a rotation without having to provide duplicates of every bar texture in the mod. Any bar moving sufficiently quickly and updating rapidly will cause this. |cff9999ffIceHUD|r is intended to be a vertically-oriented mod, so the rotation feature is there for people who are willing to accept the side effects that come with it. My suggestion is to use one of the many horizontally-oriented bar mods out there if you're wanting horizontal bars. |cff42ffffQuartz|r is a good castbar replacement that you can use and disable |cff9999ffIceHUD|r's built-in castbar, for example.
+
+|cff9999ff18. How do I get rid of the bars that showed up beneath the player in the 7.0 patch?|r
+Blizzard added a "Personal Resource Display" feature in the 7.0 game client. You can disable it in the Game options -> |cffffdc42Interface|r -> |cffffdc42Names|r -> |cffffdc42Personal Resource Display|r (or Options -> |cffffdc42Combat|r -> |cffffdc42Personal Resource Display|r, in 10.0+).
+
+|cff9999ff19. Why is there no target castbar for Classic?|r
+The Classic game client doesn't offer a reliable way to show castbars for anyone except the player. You can install the |cff42ffffLibCasterCasterino|r addon to enable support, but it's a best guess and not at all accurate.
+
+|cff9999ff20. Why do buff/debuff timers not work in Classic?|r
+The Classic game client doesn't provide this information to addons because it wasn't a feature when the game first released. You can install the |cff42ffffLibClassicDurations|r addon to enable support, but it's a best guess and not at all accurate.]]
 				}
 			}
 		},
@@ -146,8 +160,8 @@ IceHUD is not responsible for this countdown text and cannot control it. The 6.0
 					set = function(info, v)
 						IceHUD.IceCore:SetScale(v)
 					end,
-					min = 0.5,
-					max = 1.5,
+					min = 0.2,
+					max = 2.0,
 					step = 0.05,
 					isPercent = true,
 					order = 14,
@@ -373,6 +387,7 @@ IceHUD is not responsible for this countdown text and cannot control it. The 6.0
 							IceHUD.IceCore.IceHUDFrame:Show()
 						end
 					end,
+					hidden = not UnitCanPetBattle,
 					order = 34,
 				},
 
@@ -390,8 +405,27 @@ IceHUD is not responsible for this countdown text and cannot control it. The 6.0
 							IceHUD.IceCore.IceHUDFrame:Show()
 						end
 					end,
+					hidden = not GetBarberShopStyleInfo,
 					order = 35,
 				},
+
+				bHideDuringShellGame = {
+					type = 'toggle',
+					name = L["Hide during shell game"],
+					desc = L["This will hide the entire mod when playing the BfA Tortollan shell game world quest."],
+					width = 'double',
+					get = function()
+						return IceHUD.IceCore.settings.bHideDuringShellGame
+					end,
+					set = function(info, value)
+						IceHUD.IceCore.settings.bHideDuringShellGame = value
+						if not value then
+							IceHUD.IceCore.IceHUDFrame:Show()
+						end
+					end,
+					hidden = not IceHUD.HasShellGame,
+					order = 36,
+				},
 			}
 		},
 
@@ -725,6 +759,9 @@ function IceHUD_Options:OnLoad()
 	self:GenerateModuleOptions(true)
 	self.options.args.colors.args = IceHUD.IceCore:GetColorOptions()
 	self.options.args.profiles = LibStub("AceDBOptions-3.0"):GetOptionsTable(IceHUD.db)
+	--@debug@
+	IceHUD_Options:SetupProfileImportButtons()
+	--@end-debug@
 
 	-- Add dual-spec support
 	if IceHUD.db ~= nil and LibDualSpec then
@@ -755,14 +792,14 @@ function IceHUD_Options:SetupProfileImportButtons()
 				editbox:SetLabel("Profile")
 				editbox:SetFullWidth(true)
 				editbox:SetFullHeight(true)
-				local profileTable = deepcopy(IceHUD.db.profile)
+				local profileTable = IceHUD.deepcopy(IceHUD.db.profile)
 				IceHUD:removeDefaults(profileTable, IceHUD.IceCore.defaults.profile)
-				editbox:SetText(IceHUD:Serialize(profileTable))
+				editbox:SetText(IceHUD.json.encode(profileTable))
 				editbox:DisableButton(true)
 				frame:AddChild(editbox)
 			end,
 			hidden =
-				-- hello, snooper! this feature doesn't actually work yet, so enabling it won't help you much :)
+				-- hello, snooper! exporting works well enough, but importing is very rough, so enable this at your own peril
 				--[===[@non-debug@
 				true
 				--@end-non-debug@]===]
@@ -771,7 +808,7 @@ function IceHUD_Options:SetupProfileImportButtons()
 				--@end-debug@
 			,
 			disabled =
-				-- hello, snooper! this feature doesn't actually work yet, so enabling it won't help you much :)
+				-- hello, snooper! exporting works well enough, but importing is very rough, so enable this at your own peril
 				--[===[@non-debug@
 				true
 				--@end-non-debug@]===]
@@ -792,11 +829,14 @@ function IceHUD_Options:SetupProfileImportButtons()
 				frame:SetStatusText("Exported profile details")
 				frame:SetLayout("Flow")
 				frame:SetCallback("OnClose", function(widget)
-					local success, newTable = IceHUD:Deserialize(widget.children[1]:GetText())
-					if success then
+					local newTable, err = IceHUD.json.decode(widget.children[1]:GetText())
+					if err ~= nil then
+						print("failed to import profile: "..err)
+					else
+						print("importing profile")
 						IceHUD:PreProfileChanged()
 						IceHUD:populateDefaults(newTable, IceHUD.IceCore.defaults.profile)
-						IceHUD.db.profile = deepcopy(newTable)
+						IceHUD.db.profile = IceHUD.deepcopy(newTable)
 						IceHUD:PostProfileChanged()
 					end
 					AceGUI:Release(widget)
@@ -809,7 +849,7 @@ function IceHUD_Options:SetupProfileImportButtons()
 				frame:AddChild(editbox)
 			end,
 			hidden =
-				-- hello, snooper! this feature doesn't actually work yet, so enabling it won't help you much :)
+				-- hello, snooper! this feature is really rough, so enable it at your own peril
 				--[===[@non-debug@
 				true
 				--@end-non-debug@]===]
@@ -818,7 +858,7 @@ function IceHUD_Options:SetupProfileImportButtons()
 				--@end-debug@
 			,
 			disabled =
-				-- hello, snooper! this feature doesn't actually work yet, so enabling it won't help you much :)
+				-- hello, snooper! this feature is really rough, so enable it at your own peril
 				--[===[@non-debug@
 				true
 				--@end-non-debug@]===]
@@ -830,7 +870,3 @@ function IceHUD_Options:SetupProfileImportButtons()
 		}
 	end
 end
-
---@debug@
-IceHUD_Options:SetupProfileImportButtons()
---@end-debug@

IceHUD_Options/TablePrint.lua

@@ -0,0 +1,37 @@
+local function table_print(tt, indent, done)
+	done = done or {}
+	indent = indent or 0
+	if type(tt) == "table" then
+		local sb = {}
+		for key, value in pairs(tt) do
+			table.insert(sb, string.rep(" ", indent)) -- indent it
+			if type(value) == "table" and not done[value] then
+				done[value] = true
+				table.insert(sb, key .. " = {\n");
+				table.insert(sb, table_print(value, indent + 2, done))
+				table.insert(sb, string.rep(" ", indent)) -- indent it
+				table.insert(sb, "}\n");
+			elseif "number" == type(key) then
+				table.insert(sb, string.format("\"%s\"\n", tostring(value)))
+			else
+				table.insert(sb, string.format(
+					"%s = \"%s\"\n", tostring(key), tostring(value)))
+			end
+		end
+		return table.concat(sb)
+	else
+		return tt .. "\n"
+	end
+end
+
+local function to_string(tbl)
+	if "nil" == type(tbl) then
+		return tostring(nil)
+	elseif "table" == type(tbl) then
+		return table_print(tbl)
+	elseif "string" == type(tbl) then
+		return tbl
+	else
+		return tostring(tbl)
+	end
+end

IceStackCounter.lua

@@ -52,7 +52,13 @@ function IceStackCounter_GetOptions(frame, opts)
 	opts["auraName"] = {
 		type = 'input',
 		name = L["Aura to track"],
-		desc = L["Which buff/debuff this counter will be tracking. \n\nRemember to press ENTER after filling out this box with the name you want or it will not save."],
+		desc = function()
+			if IceHUD.GetPlayerAuraBySpellID then
+				return L["Which buff/debuff this counter will be tracking. Can use the name or spell id. \n\nRemember to press ENTER after filling out this box with the name you want or it will not save."]
+			else
+				return L["Which buff/debuff this counter will be tracking. \n\nRemember to press ENTER after filling out this box with the name you want or it will not save."]
+			end
+		end,
 		get = function()
 			return frame.moduleSettings.auraName
 		end,
@@ -112,7 +118,7 @@ function IceStackCounter_GetMaxCount(frame)
 		local _, max = GetSpellCharges(frame.moduleSettings.auraName)
 		return max or 1
 	else
-		return frame.moduleSettings.maxCount
+		return tonumber(frame.moduleSettings.maxCount)
 	end
 end
 
@@ -128,9 +134,12 @@ end
 function IceStackCounter_Enable(frame)
 	frame:RegisterEvent("UNIT_AURA", "UpdateCustomCount")
 	frame:RegisterEvent("UNIT_PET", "UpdateCustomCount")
-	frame:RegisterEvent("PLAYER_PET_CHANGED", "UpdateCustomCount")
-	frame:RegisterEvent("PLAYER_FOCUS_CHANGED", "UpdateCustomCount")
-	frame:RegisterEvent("PLAYER_TARGET_CHANGED", "UpdateCustomCount")
+	if IceHUD.EventExistsPlayerPetChanged then
+		frame:RegisterEvent("PLAYER_PET_CHANGED", "UpdateCustomCount")
+	end
+	if FocusUnit then
+		frame:RegisterEvent("PLAYER_FOCUS_CHANGED", "UpdateCustomCount")
+	end
 	frame:RegisterEvent("PLAYER_DEAD", "UpdateCustomCount")
 	frame:RegisterEvent("SPELL_UPDATE_CHARGES", "UpdateCustomCount")
 
@@ -171,5 +180,9 @@ function IceStackCounter_GetCount(frame)
 end
 
 function IceStackCounter_UseTargetAlpha(frame)
-	return frame.lastPoints ~= nil and frame.lastPoints > 0
+	if frame.moduleSettings.auraType == "charges" then
+		return IceStackCounter_GetCount(frame) ~= IceStackCounter_GetMaxCount(frame) or frame.target or frame.combat
+	else
+		return frame.lastPoints ~= nil and frame.lastPoints > 0
+	end
 end

IceUnitBar.lua

@@ -19,6 +19,12 @@ IceUnitBar.prototype.hasPet = nil
 
 IceUnitBar.prototype.noFlash = nil
 
+local SPELL_POWER_INSANITY, SPELL_POWER_RAGE = SPELL_POWER_INSANITY, SPELL_POWER_RAGE
+if Enum and Enum.PowerType then
+	SPELL_POWER_INSANITY = Enum.PowerType.Insanity
+	SPELL_POWER_RAGE = Enum.PowerType.Rage
+end
+
 -- Constructor --
 function IceUnitBar.prototype:init(name, unit)
 	IceUnitBar.super.prototype.init(self, name)
@@ -165,7 +171,7 @@ end
 -- Creates the low amount warning frame
 function IceUnitBar.prototype:CreateFlashFrame()
 	if not (self.flashFrame) then
-		self.flashFrame = CreateFrame("Frame", nil, self.frame)
+		self.flashFrame = CreateFrame("Frame", "IceHUD_"..self.elementName.."_Flash", self.frame)
 	end
 
 	self.flashFrame:SetFrameStrata("BACKGROUND")
@@ -197,13 +203,15 @@ end
 function IceUnitBar.prototype:RotateHorizontal()
 	IceUnitBar.super.prototype.RotateHorizontal(self)
 
-	self:RotateFrame(self.flashFrame)
+	if IceHUD.WowVer < 70000 then
+		self:RotateFrame(self.flashFrame)
+	end
 end
 
 function IceUnitBar.prototype:ResetRotation()
 	IceUnitBar.super.prototype.ResetRotation(self)
 
-	if self.flashFrame.anim then
+	if IceHUD.WowVer < 70000 and self.flashFrame and self.flashFrame.anim then
 		self.flashFrame.anim:Stop()
 	end
 end
@@ -213,7 +221,7 @@ end
 function IceUnitBar.prototype:Update()
 	IceUnitBar.super.prototype.Update(self)
 
-	if IceHUD.WowVer < 70000 then
+	if UnitIsTapped then
 		self.tapped = UnitIsTapped(self.unit) and (not UnitIsTappedByPlayer(self.unit))
 	else
 		self.tapped = UnitIsTapDenied(self.unit)
@@ -223,9 +231,26 @@ function IceUnitBar.prototype:Update()
 	self.maxHealth = UnitHealthMax(self.unit)
 	self.healthPercentage = self.maxHealth ~= 0 and (self.health/self.maxHealth) or 0
 
+	-- note that UnitPowerType returns 2 arguments and UnitPower[Max] accepts a third argument to get the values on a different scale
+	-- so this technically doesn't get us the answer we want most of the time. too risky to change at this point, though.
 	self.mana = UnitPower(self.unit, UnitPowerType(self.unit))
 	self.maxMana = UnitPowerMax(self.unit, UnitPowerType(self.unit))
-	self.manaPercentage = self.maxMana ~= 0 and (self.mana/self.maxMana) or 0
+	if UnitPowerType(self.unit) == SPELL_POWER_RAGE and self.maxMana == 1000 then
+		self.mana = IceHUD:MathRound(self.mana / 10)
+		self.maxMana = IceHUD:MathRound(self.maxMana / 10)
+	end
+	if IceHUD.WowVer >= 70300 and UnitPowerType(self.unit) == SPELL_POWER_INSANITY then
+		self.mana = IceHUD:MathRound(self.mana / 100)
+		self.maxMana = IceHUD:MathRound(self.maxMana / 100)
+	end
+
+	-- account for cases where maxMana is 0, perhaps briefly (during certain spells, for example)
+	-- and properly handle it as full. this allows for proper alpha handling during these times.
+	if self.maxMana == self.mana then
+		self.manaPercentage = 1
+	else
+		self.manaPercentage = self.maxMana ~= 0 and (self.mana/self.maxMana) or 0
+	end
 
 	local locClass
 	locClass, self.unitClass = UnitClass(self.unit)

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-2022 parnic
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

embeds.xml

@@ -1,4 +1,5 @@
 <Ui xmlns="http://www.blizzard.com/wow/ui/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.blizzard.com/wow/ui/..\FrameXML\UI.xsd">
+<!--@non-debug@
 	<Script file="libs\LibStub\LibStub.lua"/>
 	<Script file="libs\CallbackHandler-1.0\CallbackHandler-1.0.lua"/>
 	<Include file="libs\AceDB-3.0\AceDB-3.0.xml"/>
@@ -10,6 +11,7 @@
 	<Include file="libs\AceConsole-3.0\AceConsole-3.0.xml"/>
 	<Include file="libs\AceAddon-3.0\AceAddon-3.0.xml"/>
 	<Include file="libs\AceLocale-3.0\AceLocale-3.0.xml"/>
+	<Include file="libs\AceHook-3.0\AceHook-3.0.xml"/>
 	<Include file="libs\LibDogTag-3.0\lib.xml"/>
 	<Include file="libs\LibDogTag-Unit-3.0\lib.xml"/>
 	<Script file="libs\LibRangeCheck-2.0\LibRangeCheck-2.0.lua"/>
@@ -18,4 +20,5 @@
 	<Script file="LibDataBroker-1.1.lua"/>
 	<Script file="libs\LibDBIcon-1.0\LibDBIcon-1.0.lua"/>
 	<Script file="libs\LibDualSpec-1.0\LibDualSpec-1.0.lua"/>
+@end-non-debug@-->
 </Ui>

modules/ArcaneCharges.lua

@@ -1,6 +1,11 @@
 local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
 local ArcaneCharges = IceCore_CreateClass(IceClassPowerCounter)
 
+local SPELL_POWER_ARCANE_CHARGES = SPELL_POWER_ARCANE_CHARGES
+if Enum and Enum.PowerType then
+	SPELL_POWER_ARCANE_CHARGES = Enum.PowerType.ArcaneCharges
+end
+
 function ArcaneCharges.prototype:init()
 	ArcaneCharges.super.prototype.init(self, "ArcaneCharges")
 
@@ -56,6 +61,6 @@ end
 
 -- Load us up
 local _, unitClass = UnitClass("player")
-if (unitClass == "MAGE" and IceHUD.WowVer >= 70000) then
+if (unitClass == "MAGE" and MageArcaneChargesFrame) then
 	IceHUD.ArcaneCharges = ArcaneCharges:new()
 end

modules/ClassPowerCounter.lua

@@ -18,7 +18,7 @@ IceClassPowerCounter.prototype.requiredSpec = nil
 IceClassPowerCounter.prototype.shouldShowUnmodified = false
 IceClassPowerCounter.prototype.unmodifiedMaxPerRune = 10
 IceClassPowerCounter.prototype.unit = "player"
-
+IceClassPowerCounter.prototype.round = ceil
 IceClassPowerCounter.prototype.growModes = { width = 1, height = 2 }
 IceClassPowerCounter.prototype.currentGrowMode = nil
 
@@ -101,7 +101,7 @@ function IceClassPowerCounter.prototype:GetOptions()
 	opts["displayMode"] = {
 		type = 'select',
 		name = L["Display mode"],
-		desc = L["Choose whether you'd like a graphical or numeric representation of the runes.\n\nNOTE: The color of 'Numeric' mode can be controlled by the HolyPowerNumeric color."],
+		desc = L["Choose whether you'd like a graphical or numeric representation of the runes."],
 		get = function(info)
 			return IceHUD:GetSelectValue(info, self.moduleSettings.runeMode)
 		end,
@@ -462,12 +462,19 @@ function IceClassPowerCounter.prototype:CheckValidSpec()
 	end
 end
 
+function IceClassPowerCounter.prototype:GetPowerEvent()
+	return IceHUD.UnitPowerEvent
+end
+
 function IceClassPowerCounter.prototype:DisplayCounter()
 	self:UnregisterEvent("PLAYER_LEVEL_UP")
 
-	self:RegisterEvent("UNIT_POWER", "UpdateRunePower")
+	self:RegisterEvent(self:GetPowerEvent(), "UpdateRunePower")
 	self:RegisterEvent("UNIT_DISPLAYPOWER", "UpdateRunePower")
-	self:RegisterEvent("PLAYER_ENTERING_WORLD", "UpdateRunePower")
+	self:RegisterEvent("PLAYER_ENTERING_WORLD", "EnteringWorld")
+	if IceHUD.EventExistsUnitMaxPower then
+		self:RegisterEvent("UNIT_MAXPOWER", "UpdateRunePower")
+	end
 
 	if (self.moduleSettings.hideBlizz) then
 		self:HideBlizz()
@@ -484,16 +491,35 @@ function IceClassPowerCounter.prototype:Disable(core)
 	end
 end
 
+function IceClassPowerCounter.prototype:EnteringWorld()
+	self:TargetChanged()
+	self:UpdateRunePower()
+end
+
 function IceClassPowerCounter.prototype:UpdateRunePower(event, arg1, arg2)
-	if event and (event == "UNIT_POWER" or event == "UNIT_POWER_FREQUENT") and arg1 ~= "player" and arg1 ~= "vehicle" then
+	if event and (event == self:GetPowerEvent() or event == "UNIT_POWER_FREQUENT") and arg1 ~= "player" and arg1 ~= "vehicle" then
 		return
 	end
 
 	if IceHUD.WowVer >= 70000 then
 		local numMax = UnitPowerMax(self.unit, self.unitPower)
 		if numMax ~= self.numRunes then
+			local oldMax = self.numRunes
 			self.numRunes = numMax
 			self:CreateFrame()
+			self:SetDisplayMode()
+
+			for i=self.numRunes+1, oldMax do
+				if self.frame.graphical[i] then
+					self.frame.graphical[i]:Hide()
+				end
+			end
+			for i=oldMax+1, self.numRunes do
+				if self:GetRuneMode() ~= "Numeric" then
+					self.frame.graphical[i]:Show()
+				end
+				self:HideRune(i)
+			end
 		end
 	end
 
@@ -501,13 +527,17 @@ function IceClassPowerCounter.prototype:UpdateRunePower(event, arg1, arg2)
 	local percentReady = self.shouldShowUnmodified and (UnitPower("player", self.unitPower, true) / self.unmodifiedMaxPerRune) or numReady
 
 	if self:GetRuneMode() == "Numeric" or self.moduleSettings.alsoShowNumeric then
-		self.frame.numeric:SetText(tostring(percentReady))
+		if self.numericFormat then
+			self.frame.numeric:SetText(format(self.numericFormat, percentReady))
+		else
+			self.frame.numeric:SetText(tostring(percentReady))
+		end
 		self.frame.numeric:SetTextColor(self:GetColor(self.numericColor))
 	end
 
 	if self:GetRuneMode() ~= "Numeric" then
 		for i=1, self.numRunes do
-			if i <= ceil(percentReady) then
+			if i <= self.round(percentReady) then
 				if self:GetRuneMode() == "Graphical" then
 					self.frame.graphical[i].rune:SetVertexColor(1, 1, 1)
 				else
@@ -558,11 +588,7 @@ function IceClassPowerCounter.prototype:UpdateRunePower(event, arg1, arg2)
 					end
 				end
 			else
-				if self.moduleSettings.inactiveDisplayMode == "Darkened" then
-					self.frame.graphical[i].rune:SetVertexColor(0, 0, 0)
-				elseif self.moduleSettings.inactiveDisplayMode == "Hidden" then
-					self.frame.graphical[i]:Hide()
-				end
+				self:HideRune(i)
 			end
 		end
 	end
@@ -583,6 +609,19 @@ function IceClassPowerCounter.prototype:UpdateRunePower(event, arg1, arg2)
 	end
 end
 
+function IceClassPowerCounter.prototype:HideRune(i)
+	if self:GetRuneMode() == "Numeric" then
+		self.frame.graphical[i].Hide()
+		return
+	end
+
+	if self.moduleSettings.inactiveDisplayMode == "Darkened" then
+		self.frame.graphical[i].rune:SetVertexColor(0, 0, 0)
+	elseif self.moduleSettings.inactiveDisplayMode == "Hidden" then
+		self.frame.graphical[i]:Hide()
+	end
+end
+
 function IceClassPowerCounter.prototype:StartRunesFullAnimation()
 	if not self.AnimUpdate then
 		self.AnimUpdate = function() self:UpdateRuneAnimation() end
@@ -684,11 +723,6 @@ function IceClassPowerCounter.prototype:SetDisplayMode()
 		for i=1, self.numRunes do
 			self:SetupRuneTexture(i)
 			self.frame.graphical[i]:Show()
-			if self.moduleSettings.inactiveDisplayMode == "Darkened" then
-				self.frame.graphical[i].runebg:Show()
-			else
-				self.frame.graphical[i].runebg:Hide()
-			end
 		end
 	end
 end
@@ -713,6 +747,9 @@ function IceClassPowerCounter.prototype:CreateRuneFrame()
 	for i=1, self.numRunes do
 		self:CreateRune(i)
 	end
+	for i=self.numRunes+1, #self.frame.graphical do
+		self.frame.graphical[i]:Hide()
+	end
 end
 
 function IceClassPowerCounter.prototype:CreateRune(i)
@@ -723,8 +760,6 @@ function IceClassPowerCounter.prototype:CreateRune(i)
 
 		self.frame.graphical[i].rune = self.frame.graphical[i]:CreateTexture(nil, "ARTWORK")
 		self.frame.graphical[i].rune:SetVertexColor(0, 0, 0)
-		self.frame.graphical[i].runebg = self.frame.graphical[i]:CreateTexture(nil, "BACKGROUND")
-		self.frame.graphical[i].runebg:SetVertexColor(0, 0, 0)
 		self:SetupRuneTexture(i)
 
 		self.frame.graphical[i].shine = self.frame.graphical[i]:CreateTexture(nil, "OVERLAY")
@@ -749,18 +784,20 @@ function IceClassPowerCounter.prototype:CreateRune(i)
 	self.frame.graphical[i]:SetHeight(self.runeHeight)
 	self.frame.graphical[i].rune:SetWidth(self.runeWidth)
 	self.frame.graphical[i].rune:SetHeight(self.runeHeight)
-	self.frame.graphical[i].runebg:SetWidth(self.runeWidth)
-	self.frame.graphical[i].runebg:SetHeight(self.runeHeight)
 	if self.currentGrowMode == self.growModes["width"] then
 		self.frame.graphical[i].rune:SetPoint("LEFT", self.frame.graphical[i], "LEFT")
-		self.frame.graphical[i].runebg:SetPoint("LEFT", self.frame.graphical[i], "LEFT")
 	else
 		self.frame.graphical[i].rune:SetPoint("BOTTOM", self.frame.graphical[i], "BOTTOM")
-		self.frame.graphical[i].runebg:SetPoint("BOTTOM", self.frame.graphical[i], "BOTTOM")
 	end
 end
 
+function IceClassPowerCounter.prototype:SetupNewRune(rune)
+end
+
 function IceClassPowerCounter.prototype:SetupRuneTexture(rune)
+	if rune > #self.runeCoords then
+		self:SetupNewRune(rune)
+	end
 	if not rune or rune < 1 or rune > #self.runeCoords then
 		return
 	end
@@ -774,7 +811,6 @@ function IceClassPowerCounter.prototype:SetupRuneTexture(rune)
 
 	-- make sure any texture aside from the special one is square and has the proper coordinates
 	self.frame.graphical[rune].rune:SetTexCoord(a, b, c, d)
-	self.frame.graphical[rune].runebg:SetTexCoord(a, b, c, d)
 	self.frame.graphical[rune]:SetWidth(width)
 	self.frame:SetWidth(width*self.numRunes)
 	local runeAdjust = rune - (self.numRunes / 2) - 0.5
@@ -787,7 +823,7 @@ function IceClassPowerCounter.prototype:SetupRuneTexture(rune)
 	if self:GetRuneMode() == "Graphical" then
 		local tex = self:GetRuneTexture(rune)
 		if tex then
-			self.frame.graphical[rune].rune:SetTexture(self:GetRuneTexture(rune))
+			self.frame.graphical[rune].rune:SetTexture(tex)
 		else
 			self.frame.graphical[rune].rune:SetAtlas(self:GetRuneAtlas(rune), self:UseAtlasSize(rune))
 		end
@@ -800,11 +836,6 @@ function IceClassPowerCounter.prototype:SetupRuneTexture(rune)
 	elseif self:GetRuneMode() == "Graphical Clean Circle" then
 		self.frame.graphical[rune].rune:SetTexture(IceElement.TexturePath .. "ComboCleanCurves")
 	end
-	if tex then
-		self.frame.graphical[rune].runebg:SetTexture(self.frame.graphical[rune].rune:GetTexture())
-	else
-		self.frame.graphical[rune].runebg:SetAtlas(self.frame.graphical[rune].rune:GetAtlas())
-	end
 end
 
 function IceClassPowerCounter.prototype:GetAlphaAdd()

modules/ComboPoints.lua

@@ -4,15 +4,24 @@ local ComboPoints = IceCore_CreateClass(IceElement)
 local IceHUD = _G.IceHUD
 
 local AnticipationSpellId = 114015
+local AnticipationExists = GetSpellInfo(AnticipationSpellId) and IceHUD.WowVer < 70000
 
 ComboPoints.prototype.comboSize = 20
 
+local SPELL_POWER_COMBO_POINTS = SPELL_POWER_COMBO_POINTS
+if Enum and Enum.PowerType then
+	SPELL_POWER_COMBO_POINTS = Enum.PowerType.ComboPoints
+end
+
 -- Constructor --
 function ComboPoints.prototype:init()
 	ComboPoints.super.prototype.init(self, "ComboPoints")
 
 	self:SetDefaultColor("ComboPoints", 1, 1, 0)
-	self:SetDefaultColor("AnticipationPoints", 1, 0, 1)
+	if AnticipationExists then
+		self:SetDefaultColor("AnticipationPoints", 1, 0, 1)
+	end
+	self:SetDefaultColor("ChargedComboPoint", 0.3137254901960784, 0.3725490196078432, 1)
 	self.scalingEnabled = true
 end
 
@@ -158,7 +167,7 @@ function ComboPoints.prototype:GetOptions()
 		order = 33.2
 	}
 
-	if IceHUD.WowVer < 70000 then
+	if AnticipationExists then
 		opts["anticipation"] = {
 			type = "toggle",
 			name = L["Show Anticipation"],
@@ -210,6 +219,28 @@ function ComboPoints.prototype:GetOptions()
 		disabled = function()
 			return not self.moduleSettings.enabled
 		end,
+		order = 35
+	}
+
+	opts["bShowCharged"] = {
+		type = 'toggle',
+		width = 'double',
+		name = L["Show Charged points"],
+		desc = L["Whether or not to color a charged combo point a separate color. Set the ChargedComboPoint color to the color you would like it to be."],
+		get = function()
+			return self.moduleSettings.bShowCharged
+		end,
+		set = function(info, v)
+			self.moduleSettings.bShowCharged = v
+			self:UpdateChargedComboPoints()
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end,
+		hidden = function()
+			return not GetUnitChargedPowerPoints
+		end,
+		order = 36
 	}
 
 	return opts
@@ -230,6 +261,7 @@ function ComboPoints.prototype:GetDefaultSettings()
 	defaults["comboGap"] = 0
 	defaults["showAnticipation"] = true
 	defaults["bShowWithNoTarget"] = true
+	defaults["bShowCharged"] = true
 	return defaults
 end
 
@@ -248,16 +280,20 @@ function ComboPoints.prototype:Enable(core)
 	ComboPoints.super.prototype.Enable(self, core)
 
 	self:RegisterEvent("PLAYER_TARGET_CHANGED", "UpdateComboPoints")
-	if IceHUD.WowVer >= 30000 then
-		if IceHUD.WowVer < 70000 then
+	if not IceHUD.EventExistsPlayerComboPoints then
+		if IceHUD.EventExistsUnitComboPoints then
 			self:RegisterEvent("UNIT_COMBO_POINTS", "UpdateComboPoints")
 		else
-			self:RegisterEvent("UNIT_POWER", "UpdateComboPoints")
-			self:RegisterEvent("UNIT_MAXPOWER", "UpdateMaxComboPoints")
+			self:RegisterEvent(IceHUD.UnitPowerEvent, "UpdateComboPoints")
+			if IceHUD.EventExistsUnitMaxPower then
+				self:RegisterEvent("UNIT_MAXPOWER", "UpdateMaxComboPoints")
+			end
 		end
-		self:RegisterEvent("UNIT_ENTERED_VEHICLE", "UpdateComboPoints")
-		self:RegisterEvent("UNIT_EXITED_VEHICLE", "UpdateComboPoints")
-		if IceHUD.WowVer < 70000 then
+		if UnitHasVehicleUI then
+			self:RegisterEvent("UNIT_ENTERED_VEHICLE", "UpdateComboPoints")
+			self:RegisterEvent("UNIT_EXITED_VEHICLE", "UpdateComboPoints")
+		end
+		if AnticipationExists then
 			self:RegisterEvent("PLAYER_TALENT_UPDATE", "AddAnticipation")
 			self:AddAnticipation()
 		end
@@ -265,11 +301,16 @@ function ComboPoints.prototype:Enable(core)
 		self:RegisterEvent("PLAYER_COMBO_POINTS", "UpdateComboPoints")
 	end
 
+	if GetUnitChargedPowerPoints then
+		self:RegisterEvent("UNIT_POWER_POINT_CHARGE", "UpdateChargedComboPoints")
+	end
+
 	if self.moduleSettings.comboMode == "Graphical" then
 		self.moduleSettings.comboMode = "Graphical Bar"
 	end
 
 	self:CreateComboFrame(true)
+	self:UpdateChargedComboPoints()
 end
 
 function ComboPoints.prototype:UpdateMaxComboPoints(event, unit, powerType)
@@ -282,6 +323,14 @@ function ComboPoints.prototype:UpdateMaxComboPoints(event, unit, powerType)
 	end
 end
 
+function ComboPoints.prototype:UpdateChargedComboPoints()
+	if GetUnitChargedPowerPoints then
+		self.chargedPowerPoints = GetUnitChargedPowerPoints("player")
+		self:CreateComboFrame()
+		self:UpdateComboPoints()
+	end
+end
+
 -- 'Protected' methods --------------------------------------------------------
 
 -- OVERRIDE
@@ -332,6 +381,7 @@ function ComboPoints.prototype:CreateComboFrame(forceTextureUpdate)
 			self.frame.graphicalBG[i] = frame
 			frame.texture = frame:CreateTexture()
 			frame.texture:SetAllPoints(frame)
+			forceTextureUpdate = true
 		end
 
 		if forceTextureUpdate then
@@ -367,6 +417,7 @@ function ComboPoints.prototype:CreateComboFrame(forceTextureUpdate)
 			self.frame.graphical[i] = frame
 			frame.texture = frame:CreateTexture()
 			frame.texture:SetAllPoints(frame)
+			forceTextureUpdate = true
 		end
 
 		if forceTextureUpdate then
@@ -388,13 +439,18 @@ function ComboPoints.prototype:CreateComboFrame(forceTextureUpdate)
 		if (self.moduleSettings.gradient) then
 			g = g - ((1 / maxComboPoints)*i)
 		end
-		self.frame.graphical[i].texture:SetVertexColor(r, g, b)
+
+		if self.moduleSettings.bShowCharged and self:IsChargedPoint(i) then
+			self.frame.graphical[i].texture:SetVertexColor(self:GetColor("ChargedComboPoint"))
+		else
+			self.frame.graphical[i].texture:SetVertexColor(r, g, b)
+		end
 
 		self.frame.graphical[i]:Hide()
 	end
 
 	-- create Anticipation points
-	if IceHUD.WowVer < 70000 then
+	if AnticipationExists then
 		for i = 1, 5 do
 			if (not self.frame.graphicalAnt[i]) then
 				local frame = CreateFrame("Frame", nil, self.frame)
@@ -433,38 +489,52 @@ function ComboPoints.prototype:CreateComboFrame(forceTextureUpdate)
 	end
 end
 
+function ComboPoints.prototype:IsChargedPoint(point)
+	if not self.chargedPowerPoints then
+		return false
+	end
+
+	for i=1, #self.chargedPowerPoints do
+		if self.chargedPowerPoints[i] == point then
+			return true
+		end
+	end
+
+	return false
+end
+
 function ComboPoints.prototype:UpdateComboPoints(...)
-	if select('#', ...) >= 3 and select(1, ...) == "UNIT_POWER" and select(3, ...) ~= "COMBO_POINTS" then
+	if select('#', ...) >= 3 and select(1, ...) == IceHUD.UnitPowerEvent and select(3, ...) ~= "COMBO_POINTS" then
 		return
 	end
 
 	local points, anticipate, _
 	if IceHUD.IceCore:IsInConfigMode() then
 		points = self:GetMaxComboPoints()
-	elseif IceHUD.WowVer >= 30000 then
+	elseif UnitHasVehicleUI then
 		-- Parnic: apparently some fights have combo points while the player is in a vehicle?
-		local isInVehicle = UnitHasVehicleUI("player")
+		local isInVehicle = UnitHasVehicleUI and UnitHasVehicleUI("player")
 		local checkUnit = isInVehicle and "vehicle" or "player"
-		if IceHUD.WowVer >= 60000 then
-			points = UnitPower(checkUnit, SPELL_POWER_COMBO_POINTS)
-		else
+		if IceHUD.PerTargetComboPoints then
 			points = GetComboPoints(checkUnit, "target")
+		else
+			points = UnitPower(checkUnit, SPELL_POWER_COMBO_POINTS)
 		end
 
-		if IceHUD.WowVer < 70000 then
+		if AnticipationExists then
 			_, _, _, anticipate = UnitAura("player", GetSpellInfo(AnticipationSpellId))
 		else
 			anticipate = 0
 		end
 	else
-		points = GetComboPoints("target")
+		points = GetComboPoints("player", "target")
 	end
 
 	points = points or 0
 	anticipate = self.moduleSettings.showAnticipation and anticipate or 0
 
 	if self:GetMaxComboPoints() > #self.frame.graphical then
-		self:CreateFrame()
+		self:CreateComboFrame(true)
 	end
 
 	if (self.moduleSettings.comboMode == "Numeric") then
@@ -475,6 +545,9 @@ function ComboPoints.prototype:UpdateComboPoints(...)
 		self.frame.numeric:SetTextColor(r, g, b, 0.7)
 
 		local pointsText = tostring(points)
+		if self.moduleSettings.bShowCharged and self:IsChargedPoint(points) then
+			pointsText = pointsText.."@"
+		end
 		if anticipate > 0 then
 			pointsText = pointsText.."+"..tostring(anticipate)
 		end
@@ -518,7 +591,12 @@ do
 
 	function ComboPoints.prototype:CheckAnticipation(e, unit) -- UNIT_AURA handler
 		if UnitIsUnit(unit, "player") then
-			local _, _, _, newAntStacks = UnitAura("player", GetSpellInfo(AnticipationSpellId))
+			local _, _, _, newAntStacks
+			if IceHUD.SpellFunctionsReturnRank then
+				_, _, _, newAntStacks = UnitAura("player", GetSpellInfo(AnticipationSpellId))
+			else
+				_, _, newAntStacks = UnitAura("player", GetSpellInfo(AnticipationSpellId))
+			end
 			if newAntStacks ~= antStacks then
 				antStacks = newAntStacks
 				self:UpdateComboPoints()
@@ -537,4 +615,7 @@ end
 
 
 -- Load us up
-IceHUD.ComboPoints = ComboPoints:new()
+local _, class = UnitClass("player")
+if (not IceHUD.WowClassic and not IceHUD.WowClassicBC) or class == "ROGUE" or class == "DRUID" then
+	IceHUD.ComboPoints = ComboPoints:new()
+end

modules/ComboPointsBar.lua

@@ -1,11 +1,17 @@
 local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
 local ComboPointsBar = IceCore_CreateClass(IceBarElement)
 
+local SPELL_POWER_COMBO_POINTS = SPELL_POWER_COMBO_POINTS
+if Enum and Enum.PowerType then
+	SPELL_POWER_COMBO_POINTS = Enum.PowerType.ComboPoints
+end
+
 function ComboPointsBar.prototype:init()
 	ComboPointsBar.super.prototype.init(self, "ComboPointsBar")
 
 	self:SetDefaultColor("ComboPointsBarMin", 1, 1, 0)
 	self:SetDefaultColor("ComboPointsBarMax", 0, 1, 0)
+	self:SetDefaultColor("ChargedComboPointBar", 0.3137254901960784, 0.3725490196078432, 1)
 
 	self.bTreatEmptyAsFull = true
 end
@@ -47,17 +53,37 @@ function ComboPointsBar.prototype:GetOptions()
 		end,
 	}
 
+	opts["bShowCharged"] = {
+		type = 'toggle',
+		width = 'double',
+		name = L["Show Charged points"],
+		desc = L["Whether or not to color a charged combo point a separate color and append an @ sign to the number. Set the ChargedComboPointBar color to the color you would like it to be."],
+		get = function()
+			return self.moduleSettings.bShowCharged
+		end,
+		set = function(info, v)
+			self.moduleSettings.bShowCharged = v
+			self:UpdateComboPoints()
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end,
+		hidden = function()
+			return not GetUnitChargedPowerPoints
+		end,
+	}
+
 	return opts
 end
 
 function ComboPointsBar.prototype:GetDefaultSettings()
 	local defaults =  ComboPointsBar.super.prototype.GetDefaultSettings(self)
-	defaults.textVisible['lower'] = false
 	defaults.offset = 8
 	defaults.enabled = false
 	defaults.alwaysDisplay = false
 	defaults.desiredLerpTime = 0.05
 	defaults.bShowWithNoTarget = true
+	defaults.bShowCharged = true
 	return defaults
 end
 
@@ -65,17 +91,23 @@ function ComboPointsBar.prototype:Enable(core)
 	ComboPointsBar.super.prototype.Enable(self, core)
 
 	self:RegisterEvent("PLAYER_TARGET_CHANGED", "UpdateComboPoints")
-	if IceHUD.WowVer >= 30000 then
-		if IceHUD.WowVer < 70000 then
+	if not IceHUD.EventExistsPlayerComboPoints then
+		if IceHUD.EventExistsUnitComboPoints then
 			self:RegisterEvent("UNIT_COMBO_POINTS", "UpdateComboPoints")
 		else
-			self:RegisterEvent("UNIT_POWER", "UpdateComboPoints")
+			self:RegisterEvent(IceHUD.UnitPowerEvent, "UpdateComboPoints")
+		end
+		if UnitHasVehicleUI then
+			self:RegisterEvent("UNIT_ENTERED_VEHICLE", "UpdateComboPoints")
+			self:RegisterEvent("UNIT_EXITED_VEHICLE", "UpdateComboPoints")
 		end
-		self:RegisterEvent("UNIT_ENTERED_VEHICLE", "UpdateComboPoints")
-		self:RegisterEvent("UNIT_EXITED_VEHICLE", "UpdateComboPoints")
 	else
 		self:RegisterEvent("PLAYER_COMBO_POINTS", "UpdateComboPoints")
 	end
+
+	if GetUnitChargedPowerPoints then
+		self:RegisterEvent("UNIT_POWER_POINT_CHARGE", "UpdateComboPoints")
+	end
 end
 
 function ComboPointsBar.prototype:CreateFrame()
@@ -87,45 +119,77 @@ end
 local color = {}
 
 function ComboPointsBar.prototype:UpdateComboPoints(...)
-	if select('#', ...) >= 3 and select(1, ...) == "UNIT_POWER" and select(3, ...) ~= "COMBO_POINTS" then
+	if select('#', ...) >= 3 and select(1, ...) == IceHUD.UnitPowerEvent and select(3, ...) ~= "COMBO_POINTS" then
 		return
 	end
 
 	local points
 	if IceHUD.IceCore:IsInConfigMode() then
 		points = UnitPowerMax("player", SPELL_POWER_COMBO_POINTS)
-	elseif IceHUD.WowVer >= 30000 then
+	elseif UnitHasVehicleUI then
 		-- Parnic: apparently some fights have combo points while the player is in a vehicle?
-		local isInVehicle = UnitHasVehicleUI("player")
+		local isInVehicle = UnitHasVehicleUI and UnitHasVehicleUI("player")
 		local checkUnit = isInVehicle and "vehicle" or "player"
-		if IceHUD.WowVer >= 60000 then
-			points = UnitPower(checkUnit, SPELL_POWER_COMBO_POINTS)
-		else
+		if IceHUD.PerTargetComboPoints then
 			points = GetComboPoints(checkUnit, "target")
+		else
+			points = UnitPower(checkUnit, SPELL_POWER_COMBO_POINTS)
 		end
 	else
-		points = GetComboPoints("target")
+		points = GetComboPoints("player", "target")
 	end
 
 	if (points == 0) then
 		points = nil
 	end
 
+	local isCharged = self:IsChargedPoint(points) and self.moduleSettings.bShowCharged
+
 	if points == nil or points == 0 or (not UnitExists("target") and not self.moduleSettings.bShowWithNoTarget) then
 		self:Show(self.moduleSettings.alwaysDisplay)
 		self:UpdateBar(0, "undef")
 	else
 		self:Show(true)
-		self:SetScaledColor(color, (points - 1) / 4.0, self.settings.colors["ComboPointsBarMax"], self.settings.colors["ComboPointsBarMin"])
+		if isCharged then
+			color.r, color.g, color.b = self:GetColor("ChargedComboPointBar")
+		else
+			self:SetScaledColor(color, (points - 1) / 4.0, self.settings.colors["ComboPointsBarMax"], self.settings.colors["ComboPointsBarMin"])
+		end
 		self:UpdateBar(points / UnitPowerMax("player", SPELL_POWER_COMBO_POINTS), "undef")
 		self.barFrame.bar:SetVertexColor(color.r, color.g, color.b, self.alpha)
 	end
 
-	self:SetBottomText1(points or "0")
+	local pointsText = tostring(points or 0)
+	if isCharged then
+		pointsText = pointsText .. "@"
+	end
+	self:SetBottomText1(pointsText or "0")
+end
+
+function ComboPointsBar.prototype:IsChargedPoint(point)
+	if not GetUnitChargedPowerPoints or not point then
+		return false
+	end
+
+	local chargedPoints = GetUnitChargedPowerPoints("player")
+	if not chargedPoints then
+		return false
+	end
+
+	for i=1, #chargedPoints do
+		if chargedPoints[i] == point then
+			return true
+		end
+	end
+
+	return false
 end
 
 function ComboPointsBar.prototype:Update()
 	self:UpdateComboPoints()
 end
 
-IceHUD.ComboPointsBar = ComboPointsBar:new()
+local _, class = UnitClass("player")
+if (not IceHUD.WowClassic and not IceHUD.WowClassicBC) or class == "ROGUE" or class == "DRUID" then
+	IceHUD.ComboPointsBar = ComboPointsBar:new()
+end

modules/CustomBar.lua

@@ -19,6 +19,7 @@ IceCustomBar.prototype.bIsAura = false
 function IceCustomBar.prototype:init()
 	IceCustomBar.super.prototype.init(self, "MyCustomBar", "player")
 	self.textColorOverride = true
+	self.CustomBarUpdateFunc = function() self:UpdateCustomBar(self.unit, true) end
 end
 
 -- 'Public' methods -----------------------------------------------------------
@@ -36,8 +37,12 @@ function IceCustomBar.prototype:Enable(core)
 
 	self:RegisterEvent("UNIT_AURA", "UpdateCustomBarEvent")
 	self:RegisterEvent("UNIT_PET", "UpdateCustomBarEvent")
-	self:RegisterEvent("PLAYER_PET_CHANGED", "UpdateCustomBarEvent")
-	self:RegisterEvent("PLAYER_FOCUS_CHANGED", "UpdateCustomBarEvent")
+	if IceHUD.EventExistsPlayerPetChanged then
+		self:RegisterEvent("PLAYER_PET_CHANGED", "UpdateCustomBarEvent")
+	end
+	if FocusUnit then
+		self:RegisterEvent("PLAYER_FOCUS_CHANGED", "UpdateCustomBarEvent")
+	end
 	if self.unitClass == "SHAMAN" then
 		self:RegisterEvent("PLAYER_TOTEM_UPDATE", "UpdateTotems")
 	end
@@ -77,6 +82,10 @@ function IceCustomBar.prototype:Disable(core)
 end
 
 function IceCustomBar.prototype:GetUnitToTrack()
+	if not IceHUD.CanTrackOtherUnitBuffs then
+		return "player"
+	end
+
 	if self.moduleSettings.myUnit == "other" then
 		if self.moduleSettings.customUnit ~= nil and self.moduleSettings.customUnit ~= "" then
 			return self.moduleSettings.customUnit
@@ -99,11 +108,7 @@ end
 
 function IceCustomBar.prototype:ConditionalSubscribe()
 	if self:ShouldAlwaysSubscribe() then
-		if not IceHUD.IceCore:IsUpdateSubscribed(self) then
-			if not self.CustomBarUpdateFunc then
-				self.CustomBarUpdateFunc = function() self:UpdateCustomBar() end
-			end
-
+		if not IceHUD.IceCore:IsUpdateSubscribed(self, self.CustomBarUpdateFunc) then
 			self.handlesOwnUpdates = true
 			IceHUD.IceCore:RequestUpdates(self, self.CustomBarUpdateFunc)
 		end
@@ -114,7 +119,7 @@ function IceCustomBar.prototype:ConditionalSubscribe()
 end
 
 function IceCustomBar.prototype:ShouldAlwaysSubscribe()
-	return self.unit == "focustarget" or self.unit == "pettarget"
+	return self.unit == "focustarget" or self.unit == "pettarget" or self.unit == "targettarget"
 end
 
 function IceCustomBar.prototype:TargetChanged()
@@ -166,9 +171,7 @@ function IceCustomBar.prototype:CreateBar()
 	IceCustomBar.super.prototype.CreateBar(self)
 
 	if not self.barFrame.icon then
-		self.barFrame.icon = self.masterFrame:CreateTexture(nil, "LOW")
-		-- default texture so that 'config mode' can work without activating the bar first
-		self.barFrame.icon:SetTexture("Interface\\Icons\\Spell_Frost_Frost")
+		self.barFrame.icon = self.masterFrame:CreateTexture(nil, "BACKGROUND")
 		-- this cuts off the border around the buff icon
 		self.barFrame.icon:SetTexCoord(0.1, 0.9, 0.1, 0.9)
 		self.barFrame.icon:SetDrawLayer("OVERLAY")
@@ -256,51 +259,53 @@ function IceCustomBar.prototype:GetOptions()
 		order = 30.3,
 	}
 
-	opts["unitToTrack"] = {
-		type = 'select',
-		values = validUnits,
-		name = L["Unit to track"],
-		desc = L["Select which unit that this bar should be looking for buffs/debuffs on"],
-		get = function(info)
-			return IceHUD:GetSelectValue(info, self.moduleSettings.myUnit)
-		end,
-		set = function(info, v)
-			self.moduleSettings.myUnit = info.option.values[v]
-			self.unit = self:GetUnitToTrack()
-			self:RegisterFontStrings()
-			self:ConditionalSubscribe()
-			self:Redraw()
-			self:UpdateCustomBar(self.unit)
-			IceHUD:NotifyOptionsChange()
-		end,
-		disabled = function()
-			return not self.moduleSettings.enabled
-		end,
-		order = 30.4,
-	}
+	if IceHUD.CanTrackOtherUnitBuffs then
+		opts["unitToTrack"] = {
+			type = 'select',
+			values = validUnits,
+			name = L["Unit to track"],
+			desc = L["Select which unit that this bar should be looking for buffs/debuffs on"],
+			get = function(info)
+				return IceHUD:GetSelectValue(info, self.moduleSettings.myUnit)
+			end,
+			set = function(info, v)
+				self.moduleSettings.myUnit = info.option.values[v]
+				self.unit = self:GetUnitToTrack()
+				self:RegisterFontStrings()
+				self:ConditionalSubscribe()
+				self:Redraw()
+				self:UpdateCustomBar(self.unit)
+				IceHUD:NotifyOptionsChange()
+			end,
+			disabled = function()
+				return not self.moduleSettings.enabled
+			end,
+			order = 30.4,
+		}
 
-	opts["customUnitToTrack"] = {
-		type = 'input',
-		name = L["Custom unit"],
-		desc = L["Any valid unit id such as: party1, raid14, targettarget, etc. Not guaranteed to work with all unit ids.\n\nRemember to press ENTER after filling out this box with the name you want or it will not save."],
-		get = function()
-			return self.moduleSettings.customUnit
-		end,
-		set = function(info, v)
-			self.moduleSettings.customUnit = v
-			self.unit = self:GetUnitToTrack()
-			self:RegisterFontStrings()
-			self:ConditionalSubscribe()
-			self:Redraw()
-			self:UpdateCustomBar(self.unit)
-			IceHUD:NotifyOptionsChange()
-		end,
-		hidden = function()
-			return self.moduleSettings.myUnit ~= "other"
-		end,
-		usage = "<what custom unit to track when unitToTrack is set to 'other'>",
-		order = 30.45,
-	}
+		opts["customUnitToTrack"] = {
+			type = 'input',
+			name = L["Custom unit"],
+			desc = L["Any valid unit id such as: party1, raid14, targettarget, etc. Not guaranteed to work with all unit ids.\n\nRemember to press ENTER after filling out this box with the name you want or it will not save."],
+			get = function()
+				return self.moduleSettings.customUnit
+			end,
+			set = function(info, v)
+				self.moduleSettings.customUnit = v
+				self.unit = self:GetUnitToTrack()
+				self:RegisterFontStrings()
+				self:ConditionalSubscribe()
+				self:Redraw()
+				self:UpdateCustomBar(self.unit)
+				IceHUD:NotifyOptionsChange()
+			end,
+			hidden = function()
+				return self.moduleSettings.myUnit ~= "other"
+			end,
+			usage = "<what custom unit to track when unitToTrack is set to 'other'>",
+			order = 30.45,
+		}
+	end
 
 	opts["buffOrDebuff"] = {
 		type = 'select',
@@ -324,16 +329,18 @@ function IceCustomBar.prototype:GetOptions()
 	opts["buffToTrack"] = {
 		type = 'input',
 		name = L["Aura to track"],
-		desc = L["Which buff/debuff this bar will be tracking.\n\nRemember to press ENTER after filling out this box with the name you want or it will not save."],
+		desc = function()
+			if IceHUD.GetPlayerAuraBySpellID then
+				return L["Which buff/debuff this bar will be tracking. Can use the name or spell id. \n\nRemember to press ENTER after filling out this box with the name you want or it will not save."]
+			else
+				return L["Which buff/debuff this bar will be tracking.\n\nRemember to press ENTER after filling out this box with the name you want or it will not save."]
+			end
+		end,
 		get = function()
 			return self.moduleSettings.buffToTrack
 		end,
 		set = function(info, v)
 			local orig = v
-			--Parnic: we now allow spell IDs to be used directly
-			--if tonumber(v) ~= nil then
-			--	v = GetSpellInfo(tonumber(v))
-			--end
 			if v == nil then
 				v = orig
 			end
@@ -633,7 +640,7 @@ end
 -- 'Protected' methods --------------------------------------------------------
 
 function IceCustomBar.prototype:GetAuraDuration(unitName, buffName)
-	if not unitName or not buffName then
+	if not unitName or not buffName or buffName == "" then
 		return nil
 	end
 
@@ -664,7 +671,12 @@ function IceCustomBar.prototype:GetAuraDuration(unitName, buffName)
 	local remaining
 	local isBuff = self.moduleSettings.buffOrDebuff == "buff" and true or false
 	local buffFilter = (isBuff and "HELPFUL" or "HARMFUL") .. (self.moduleSettings.trackOnlyMine and "|PLAYER" or "")
-	local buff, rank, texture, count, type, duration, endTime, unitCaster, _, _, spellId = UnitAura(unitName, i, buffFilter)
+	local buff, rank, texture, count, type, duration, endTime, unitCaster, _, _, spellId
+	if IceHUD.SpellFunctionsReturnRank then
+		buff, rank, texture, count, type, duration, endTime, unitCaster, _, _, spellId = UnitAura(unitName, i, buffFilter)
+	else
+		buff, texture, count, type, duration, endTime, unitCaster, _, _, spellId = UnitAura(unitName, i, buffFilter)
+	end
 	local isMine = unitCaster == "player"
 	local mySpellId = tonumber(self.moduleSettings.buffToTrack)
 	local checkId = mySpellId ~= nil
@@ -690,7 +702,11 @@ function IceCustomBar.prototype:GetAuraDuration(unitName, buffName)
 
 		i = i + 1;
 
-		buff, rank, texture, count, type, duration, endTime, unitCaster, _, _, spellId = UnitAura(unitName, i, buffFilter)
+		if IceHUD.SpellFunctionsReturnRank then
+			buff, rank, texture, count, type, duration, endTime, unitCaster, _, _, spellId = UnitAura(unitName, i, buffFilter)
+		else
+			buff, texture, count, type, duration, endTime, unitCaster, _, _, spellId = UnitAura(unitName, i, buffFilter)
+		end
 		isMine = unitCaster == "player"
 	end
 
@@ -738,7 +754,7 @@ function IceCustomBar.prototype:UpdateCustomBar(unit, fromUpdate)
 	local auraIcon = nil
 	local endTime = 0
 
-	if not fromUpdate then
+	--if not fromUpdate then
 		if tonumber(self.moduleSettings.buffToTrack) == nil then
 			self.auraDuration, remaining, self.auraBuffCount, auraIcon, endTime =
 				self:GetAuraDuration(self.unit, self.moduleSettings.buffToTrack)
@@ -765,22 +781,22 @@ function IceCustomBar.prototype:UpdateCustomBar(unit, fromUpdate)
 		end
 
 		if IceHUD.IceCore:IsInConfigMode() or self.moduleSettings.displayAuraIcon then
+			if IceHUD.IceCore:IsInConfigMode() and not self.barFrame.icon:GetTexture() then
+				self.barFrame.icon:SetTexture("Interface\\Icons\\Spell_Frost_Frost")
+			end
+
 			self.barFrame.icon:Show()
 		else
 			self.barFrame.icon:Hide()
 		end
-	end
+	--end
 
 	self.auraBuffCount = self.auraBuffCount or 0
 
 	if self.auraEndTime ~= nil and (self.auraEndTime == 0 or self.auraEndTime >= now) and (not self.moduleSettings.minCount or self.auraBuffCount >= self.moduleSettings.minCount) then
-		if not self:ShouldAlwaysSubscribe() and not fromUpdate and not IceHUD.IceCore:IsUpdateSubscribed(self) then
-			if not self.UpdateCustomBarFunc then
-				self.UpdateCustomBarFunc = function() self:UpdateCustomBar(self.unit, true) end
-			end
-
+		if not self:ShouldAlwaysSubscribe() and not fromUpdate and not IceHUD.IceCore:IsUpdateSubscribed(self, self.CustomBarUpdateFunc) then
 			self.handlesOwnUpdates = true
-			IceHUD.IceCore:RequestUpdates(self, self.UpdateCustomBarFunc)
+			IceHUD.IceCore:RequestUpdates(self, self.CustomBarUpdateFunc)
 		end
 
 		self:Show(true)

modules/CustomCDBar.lua

@@ -21,11 +21,6 @@ IceCustomCDBar.prototype.cooldownDuration = 0
 IceCustomCDBar.prototype.cooldownEndTime = 0
 IceCustomCDBar.prototype.coolingDown = false
 
--- super temp...remove this when blizzard fixes these spells to work by name with GetSpellCooldown()
-local brokenSpellsNameToId = {}
-table.insert(brokenSpellsNameToId, {"Holy Word: Serenity",88684})
-table.insert(brokenSpellsNameToId, {"Holy Word: Sanctuary",88685})
-
 -- Constructor --
 function IceCustomCDBar.prototype:init()
 	IceCustomCDBar.super.prototype.init(self, "MyCustomCDBar")
@@ -136,9 +131,7 @@ function IceCustomCDBar.prototype:CreateBar()
 	IceCustomCDBar.super.prototype.CreateBar(self)
 
 	if not self.barFrame.icon then
-		self.barFrame.icon = self.masterFrame:CreateTexture(nil, "LOW")
-		-- default texture so that 'config mode' can work without activating the bar first
-		self.barFrame.icon:SetTexture("Interface\\Icons\\Spell_Frost_Frost")
+		self.barFrame.icon = self.masterFrame:CreateTexture(nil, "BACKGROUND")
 		-- this cuts off the border around the buff icon
 		self.barFrame.icon:SetTexCoord(0.1, 0.9, 0.1, 0.9)
 		self.barFrame.icon:SetDrawLayer("OVERLAY")
@@ -680,6 +673,9 @@ function IceCustomCDBar.prototype:UpdateIcon()
 		end
 
 		if IceHUD.IceCore:IsInConfigMode() or self.moduleSettings.displayAuraIcon then
+			if not self.barFrame.icon:GetTexture() and IceHUD.IceCore:IsInConfigMode() then
+				self.barFrame.icon:SetTexture("Interface\\Icons\\Spell_Frost_Frost")
+			end
 			self.barFrame.icon:Show()
 		else
 			self.barFrame.icon:Hide()
@@ -699,7 +695,10 @@ function IceCustomCDBar.prototype:UpdateItemUnitInventoryChanged(event, unit)
 	end
 end
 
-function IceCustomCDBar.prototype:UpdateCustomBarEvent()
+function IceCustomCDBar.prototype:UpdateCustomBarEvent(event, unit)
+	if unit ~= self.unit then
+		return
+	end
 	if not self.moduleSettings.cooldownType or self.moduleSettings.cooldownType == COOLDOWN_TYPE_SPELL then
 		self:UpdateCustomBar()
 	end
@@ -727,6 +726,8 @@ function IceCustomCDBar.prototype:UpdateCustomBar(fromUpdate)
 		else
 			self.cooldownEndTime = remaining + now
 		end
+
+		self:UpdateIcon()
 	end
 
 	if self.cooldownEndTime and self.cooldownEndTime >= now then
@@ -801,7 +802,9 @@ function IceCustomCDBar.prototype:IsReady()
 		local checkSpell = self:GetSpellNameOrId(self.moduleSettings.cooldownToTrack)
 
 		if (IsUsableSpell(checkSpell)) then
-			if (not self.moduleSettings.bIgnoreRange and SpellHasRange(checkSpell)) or (self.moduleSettings.bOnlyShowWithTarget) then
+			if self.moduleSettings.bIgnoreRange and self.moduleSettings.bOnlyShowWithTarget then
+				is_ready = UnitExists("target") and 1 or nil
+			elseif (not self.moduleSettings.bIgnoreRange and SpellHasRange(checkSpell)) or (self.moduleSettings.bOnlyShowWithTarget) then
 				if (UnitExists("target") and (not SpellHasRange(checkSpell) or IsSpellInRange(checkSpell, "target") == 1))
 					or (not UnitExists("target") and not self.moduleSettings.bOnlyShowWithTarget and IsSpellInRange(checkSpell, "player")) then
 					is_ready = 1
@@ -821,14 +824,6 @@ function IceCustomCDBar.prototype:IsReady()
 end
 
 function IceCustomCDBar.prototype:GetSpellNameOrId(spellName)
-	-- super temp hax. certain spells (the new 'morphing' spells) do not work by name with GetSpellCooldown(), only id.
-	for i=1,#brokenSpellsNameToId do
-		if spellName == brokenSpellsNameToId[i][1] then
-			spellName = brokenSpellsNameToId[i][2]
-			break
-		end
-	end
-
 	return spellName
 end
 

modules/CustomCount.lua

@@ -122,7 +122,7 @@ function IceCustomCount.prototype:GetOptions()
 			self.moduleSettings.vpos = v
 			self:Redraw()
 		end,
-		min = -400,
+		min = -700,
 		max = 700,
 		step = 1,
 		disabled = function()
@@ -245,6 +245,23 @@ function IceCustomCount.prototype:GetOptions()
 		order = 34
 	}
 
+	opts["showWhenZero"] = {
+		type = 'toggle',
+		name = L["Show when zero"],
+		desc = L["Whether or not to show the counter when the value is zero. This will cause a 0 to be displayed at all times for Numeric mode and faded markers for graphical mode."],
+		get = function()
+			return self.moduleSettings.showWhenZero
+		end,
+		set = function(info, v)
+			self.moduleSettings.showWhenZero = v
+			self:Redraw()
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end,
+		order = 35,
+	}
+
 	return opts
 end
 
@@ -296,6 +313,11 @@ function IceCustomCount.prototype:Enable(core)
 	self:UpdateCustomCount()
 end
 
+function IceCustomCount.prototype:TargetChanged()
+	IceCustomCount.super.prototype.TargetChanged(self)
+	self:UpdateCustomCount()
+end
+
 
 
 -- 'Protected' methods --------------------------------------------------------
@@ -324,7 +346,7 @@ end
 
 function IceCustomCount.prototype:CreateCustomFrame(doTextureUpdate)
 	-- create numeric counts
-	self.frame.numeric = self:FontFactory(self.moduleSettings.countFontSize, nil, self.frame.numeric)
+	self.frame.numeric = self:FontFactory(self.moduleSettings.countFontSize, self.frame, self.frame.numeric)
 
 	self.frame.numeric:SetWidth(50)
 	self.frame.numeric:SetJustifyH("CENTER")
@@ -421,6 +443,9 @@ function IceCustomCount.prototype:GetGradientColor(curr)
 	local r, g, b = self:GetCustomColor()
 	local mr, mg, mb = self:GetCustomMinColor()
 	local scale = max > 1 and ((curr-1)/(max-1)) or 1
+	if self.moduleSettings.countMode == "Numeric" and self.moduleSettings.showWhenZero then
+		scale = max > 1 and (curr/max) or 1
+	end
 
 	r = r * scale + mr * (1-scale)
 	g = g * scale + mg * (1-scale)
@@ -436,6 +461,15 @@ function IceCustomCount.prototype:UpdateCustomCount()
 	end
 
 	local points = IceStackCounter_GetCount(self)
+	if not points and self.moduleSettings.showWhenZero then
+		points = 0
+	end
+	local max = IceStackCounter_GetMaxCount(self)
+
+	if max > #self.frame.graphical then
+		self:Redraw()
+		return
+	end
 
 	if (self.moduleSettings.countMode == "Numeric") then
 		local r, g, b = self:GetCustomColor()

modules/CustomCounterBar.lua

@@ -250,6 +250,11 @@ function IceCustomCounterBar.prototype:Enable(core)
 	IceStackCounter_Enable(self)
 end
 
+function IceCustomCounterBar.prototype:TargetChanged()
+	IceCustomCount.super.prototype.TargetChanged(self)
+	self:UpdateCustomCount()
+end
+
 function IceCustomCounterBar.prototype:Redraw()
 	IceCustomCounterBar.super.prototype.Redraw(self)
 
@@ -272,8 +277,7 @@ function IceCustomCounterBar.prototype:CreateFrame()
 	IceCustomCounterBar.super.prototype.CreateFrame(self)
 
 	if not self.barFrame.icon then
-		self.barFrame.icon = self.masterFrame:CreateTexture(nil, "LOW")
-		self.barFrame.icon:SetTexture(DefaultAuraIcon)
+		self.barFrame.icon = self.masterFrame:CreateTexture(nil, "BACKGROUND")
 		self.barFrame.icon:SetTexCoord(0.1, 0.9, 0.1, 0.9)
 		self.barFrame.icon:SetDrawLayer("OVERLAY")
 		self.barFrame.icon:Hide()
@@ -301,10 +305,6 @@ function IceCustomCounterBar.prototype:UpdateAuraIcon()
 	local auraIcon, _
 	_, _, auraIcon = GetSpellInfo(self.moduleSettings.auraName)
 
-	if auraIcon == nil then
-		auraIcon = "Interface\\Icons\\Spell_Frost_Frost"
-	end
-
 	self.barFrame.icon:SetTexture(auraIcon)
 end
 
@@ -314,12 +314,16 @@ function IceCustomCounterBar.prototype:UpdateCustomCount()
 	local percent = IceHUD:Clamp(1.0 * points / (max > 0 and max or 1), 0, 1)
 
 	if IceHUD.IceCore:IsInConfigMode() then
+		if not self.barFrame.icon:GetTexture() then
+			self.barFrame.icon:SetTexture(DefaultAuraIcon)
+		end
+
 		points = IceStackCounter_GetMaxCount(self)
 		percent = 1
 		self.barFrame.icon:Show()
 	end
 
-	if points == nil or points == 0 then
+	if (points == nil or points == 0) and self.moduleSettings.auraType ~= "charges" then
 		self:Show(false)
 		self:UpdateBar(0, "undef")
 	else
@@ -343,3 +347,7 @@ end
 function IceCustomCounterBar.prototype:Update()
 	self:UpdateCustomCount()
 end
+
+function IceCustomCounterBar.prototype:UseTargetAlpha(scale)
+	return IceStackCounter_UseTargetAlpha(self)
+end

modules/EclipseBar.lua

@@ -107,7 +107,7 @@ function EclipseBar.prototype:CreateFrame()
 end
 
 function EclipseBar.prototype:CreateSolarBar()
-	self.solarBar = self:BarFactory(self.solarBar,"BACKGROUND", "ARTWORK")
+	self.solarBar = self:BarFactory(self.solarBar,"BACKGROUND", "ARTWORK", "Solar")
 	self:SetBarCoord(self.solarBar, 0.5, true)
 
 	self.solarBar.bar:SetVertexColor(self:GetColor("EclipseSolar", 1))
@@ -119,7 +119,7 @@ function EclipseBar.prototype:UpdateShown()
 
 	if form == MOONKIN_FORM or not form then
 		local PrimaryTalentTree = 0
-		if IceHUD.WowVer >= 50000 then
+		if GetSpecialization then
 			PrimaryTalentTree = GetSpecialization()
 		else
 			PrimaryTalentTree = GetPrimaryTalentTree()
@@ -190,6 +190,6 @@ function EclipseBar.prototype:MyOnUpdate()
 end
 
 local _, unitClass = UnitClass("player")
-if (unitClass == "DRUID" and IceHUD.WowVer >= 40000 and IceHUD.WowVer < 70000) then
+if (unitClass == "DRUID" and GetEclipseDirection) then
 	IceHUD.EclipseBar = EclipseBar:new()
 end

modules/EssencePower.lua

@@ -0,0 +1,74 @@
+local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
+local EssencePower = IceCore_CreateClass(IceClassPowerCounter)
+
+local SPELL_POWER_ESSENCE = SPELL_POWER_ESSENCE
+if Enum and Enum.PowerType then
+	SPELL_POWER_ESSENCE = Enum.PowerType.Essence
+end
+
+function EssencePower.prototype:init()
+	EssencePower.super.prototype.init(self, "EssencePower")
+
+	self:SetDefaultColor("EssencePowerNumeric", 150, 150, 255)
+
+	self.unit = "player"
+	self.numericColor = "EssencePowerNumeric"
+	self.unitPower = SPELL_POWER_ESSENCE
+	self.minLevel = 0
+	self.bTreatEmptyAsFull = false
+	self.runeWidth = self.runeHeight
+end
+
+function EssencePower.prototype:Enable(core)
+	self.numRunes = UnitPowerMax(self.unit, SPELL_POWER_ESSENCE)
+	self.runeCoords = { }
+	for i = 1, self.numRunes do
+		self:SetupNewRune(i)
+	end
+
+	EssencePower.super.prototype.Enable(self, core)
+end
+
+function EssencePower.prototype:SetupNewRune(rune)
+    self.runeCoords[rune] = {0, 1, 0, 1}
+end
+
+function EssencePower.prototype:GetPowerEvent()
+	return "UNIT_POWER_FREQUENT"
+end
+
+function EssencePower.prototype:GetDefaultSettings()
+	local defaults =  EssencePower.super.prototype.GetDefaultSettings(self)
+
+	defaults["pulseWhenFull"] = false
+
+	return defaults
+end
+
+function EssencePower.prototype:GetOptions()
+	local opts = EssencePower.super.prototype.GetOptions(self)
+
+	opts.hideBlizz.hidden = function() return true end
+
+	return opts
+end
+
+function EssencePower.prototype:GetRuneAtlas(rune)
+	return "UF-Essence-Icon"
+end
+
+function EssencePower.prototype:GetShineAtlas(rune)
+	return "Mage-ArcaneCharge-SmallSpark"
+end
+
+function EssencePower.prototype:ShowBlizz()
+end
+
+function EssencePower.prototype:HideBlizz()
+end
+
+-- Load us up
+local _, unitClass = UnitClass("player")
+if unitClass == "EVOKER" then
+	IceHUD.EssencePower = EssencePower:new()
+end

modules/FocusAbsorb.lua

@@ -26,4 +26,6 @@ function FocusAbsorb.prototype:MyUnregisterCustomEvents()
 end
 
 -- Load us up
-IceHUD.FocusAbsorb = FocusAbsorb:new()
+if UnitGetTotalAbsorbs ~= nil then
+	IceHUD.FocusAbsorb = FocusAbsorb:new()
+end

modules/FocusCC.lua

@@ -23,4 +23,6 @@ end
 -- 'Protected' methods --------------------------------------------------------
 
 -- Load us up
-IceHUD.FocusCC = FocusCC:new()
+if FocusUnit then
+	IceHUD.FocusCC = FocusCC:new()
+end

modules/FocusCast.lua

@@ -112,4 +112,6 @@ end
 
 
 -- Load us up
-IceHUD.FocusCast = FocusCast:new()
+if FocusUnit then
+	IceHUD.FocusCast = FocusCast:new()
+end

modules/FocusHealth.lua

@@ -471,4 +471,6 @@ function FocusHealth.prototype:HideBlizz()
 end
 
 -- Load us up
-IceHUD.FocusHealth = FocusHealth:new()
+if FocusUnit then
+	IceHUD.FocusHealth = FocusHealth:new()
+end

modules/FocusMana.lua

@@ -1,6 +1,14 @@
 local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
 local FocusMana = IceCore_CreateClass(IceUnitBar)
 
+local SPELL_POWER_RAGE = SPELL_POWER_RAGE
+local SPELL_POWER_FOCUS = SPELL_POWER_FOCUS
+local SPELL_POWER_ENERGY = SPELL_POWER_ENERGY
+if Enum and Enum.PowerType then
+	SPELL_POWER_RAGE = Enum.PowerType.Rage
+	SPELL_POWER_FOCUS = Enum.PowerType.Focus
+	SPELL_POWER_ENERGY = Enum.PowerType.Energy
+end
 
 -- Constructor --
 function FocusMana.prototype:init()
@@ -31,9 +39,11 @@ end
 function FocusMana.prototype:Enable(core)
 	FocusMana.super.prototype.Enable(self, core)
 
-	if IceHUD.WowVer >= 40000 then
-		self:RegisterEvent("UNIT_POWER", "UpdateEvent")
-		self:RegisterEvent("UNIT_MAXPOWER", "UpdateEvent")
+	if not IceHUD.PerPowerEventsExist then
+		self:RegisterEvent(IceHUD.UnitPowerEvent, "UpdateEvent")
+		if IceHUD.EventExistsUnitMaxPower then
+			self:RegisterEvent("UNIT_MAXPOWER", "UpdateEvent")
+		end
 	else
 		self:RegisterEvent("UNIT_MANA", "UpdateEvent")
 		self:RegisterEvent("UNIT_MAXMANA", "UpdateEvent")
@@ -126,4 +136,6 @@ end
 
 
 -- Load us up
-IceHUD.FocusMana = FocusMana:new()
+if FocusUnit then
+	IceHUD.FocusMana = FocusMana:new()
+end

modules/FocusThreat.lua

@@ -16,4 +16,6 @@ function IceFocusThreat.prototype:GetDefaultSettings()
 end
 
 -- Load us up
-IceHUD.IceFocusThreat = IceFocusThreat:new()
+if FocusUnit then
+	IceHUD.IceFocusThreat = IceFocusThreat:new()
+end

modules/GlobalCoolDown.lua

@@ -20,7 +20,7 @@ function GlobalCoolDown.prototype:Enable(core)
 		self.moduleSettings.inverse = "NORMAL"
 	end
 
-	self:RegisterEvent("UNIT_SPELLCAST_SENT","SpellCastSent")
+	self:RegisterEvent("CURRENT_SPELL_CAST_CHANGED", "SpellCastChanged")
 
 	--self:RegisterEvent("ACTIONBAR_UPDATE_COOLDOWN", "CooldownStateChanged")
 	self:RegisterEvent("UNIT_SPELLCAST_START","CooldownStateChanged")
@@ -45,7 +45,10 @@ end
 
 function GlobalCoolDown.prototype:CVarUpdate()
 	self.useFixedLatency = self.moduleSettings.respectLagTolerance and GetCVar("reducedLagTolerance") == "1"
-	self.fixedLatency = tonumber(GetCVar("maxSpellStartRecoveryoffset")) / 1000.0
+	local recoveryOffset = GetCVar("maxSpellStartRecoveryoffset")
+	if recoveryOffset ~= nil then
+		self.fixedLatency = tonumber(recoveryOffset) / 1000.0
+	end
 end
 
 -- OVERRIDE
@@ -140,20 +143,16 @@ function GlobalCoolDown.prototype:IsFull(scale)
 	return false
 end
 
-function GlobalCoolDown.prototype:SpellCastSent(event, unit, spell)
-	if unit ~= "player" or not spell then
-		return
-	end
-
+function GlobalCoolDown.prototype:SpellCastChanged(event, cancelled)
 	self.spellCastSent = GetTime()
 end
 
-function GlobalCoolDown.prototype:SpellCastStop(event, unit, spell, _, _, spellId)
-	if unit ~= "player" or not spellId or not self.CurrSpellId or self.CurrSpellId ~= spellId then
+function GlobalCoolDown.prototype:SpellCastStop(event, unit, castGuid, spellId)
+	if unit ~= "player" or not spellId or not self.CurrSpellGuid or self.CurrSpellGuid ~= castGuid then
 		return
 	end
 
-	self.CurrSpellId = nil
+	self.CurrSpellGuid = nil
 
 	if event == "UNIT_SPELLCAST_INTERRUPTED" or event == "UNIT_SPELLCAST_FAILED" then
 		self.CurrLerpTime = self.moduleSettings.desiredLerpTime
@@ -166,7 +165,7 @@ function GlobalCoolDown.prototype:GetSpellCastTime(spell)
 	end
 
 	local spellname, castTime, _
-	if IceHUD.WowVer < 60000 then
+	if IceHUD.GetSpellInfoReturnsFunnel then
 		spellName, _, _, _, _, _, castTime = GetSpellInfo(spell)
 	else
 		spellName, _, _, castTime = GetSpellInfo(spell)
@@ -179,19 +178,19 @@ function GlobalCoolDown.prototype:GetSpellCastTime(spell)
 	end
 end
 
-function GlobalCoolDown.prototype:CooldownStateChanged(event, unit, spell, _, _, spellId)
+function GlobalCoolDown.prototype:CooldownStateChanged(event, unit, castGuid, spellId)
 	if unit ~= "player" or not spellId then
 		return
 	end
 
 	-- Ignore all events unrelated to the spell currently being cast
-	if self.CurrSpellId and self.CurrSpellId ~= spellId then
+	if self.CurrSpellGuid and self.CurrSpellGuid ~= castGuid then
 		return
 	end
 
 	-- Update the current spell ID for all events indicating a spellcast is starting
 	if event ~= "UNIT_SPELLCAST_SUCCEEDED" then
-		self.CurrSpellId = spellId
+		self.CurrSpellGuid = castGuid
 	end
 
 	local start, dur = GetSpellCooldown(self.CDSpellId)
@@ -256,7 +255,7 @@ function GlobalCoolDown.prototype:CreateFrame()
 end
 
 function GlobalCoolDown.prototype:CreateLagBar()
-	self.lagBar = self:BarFactory(self.lagBar, "LOW", "OVERLAY")
+	self.lagBar = self:BarFactory(self.lagBar, "LOW", "OVERLAY", "Lag")
 
 	local r, g, b = self:GetColor("CastLag")
 	if (self.settings.backgroundToggle) then
@@ -268,28 +267,35 @@ function GlobalCoolDown.prototype:CreateLagBar()
 end
 
 function GlobalCoolDown.prototype:GetSpellId()
-	return 61304
---[[
-	local defaultSpells
+	if GetSpellInfo(61304) then
+		return 61304
+	else
+		local defaultSpells
 
-	defaultSpells = {
-		ROGUE=1752, -- sinister strike
-		PRIEST=585, -- smite
-		DRUID=5176, -- wrath
-		WARRIOR=34428, -- victory rush (not available until 5, sadly)
-		MAGE=44614, -- frostfire bolt
-		WARLOCK=686, -- shadow bolt
-		PALADIN=105361, -- seal of command (level 3)
-		SHAMAN=403, -- lightning bolt
-		HUNTER=3044, -- arcane shot
-		DEATHKNIGHT=47541, -- death coil
-		MONK=100780, -- jab
-	}
+		defaultSpells = {
+			ROGUE=1752, -- sinister strike
+			PRIEST=585, -- smite
+			DRUID=5176, -- wrath
+			WARRIOR=34428, -- victory rush (not available until 5, sadly)
+			MAGE=44614, -- frostfire bolt
+			WARLOCK=686, -- shadow bolt
+			PALADIN=105361, -- seal of command (level 3)
+			SHAMAN=403, -- lightning bolt
+			HUNTER=3044, -- arcane shot
+			DEATHKNIGHT=47541, -- death coil
+			MONK=100780, -- jab
+		}
 
-	local _, unitClass = UnitClass("player")
-	return defaultSpells[unitClass]
-]]
+		if not GetSpellInfo(defaultSpells["PALADIN"]) then
+			defaultSpells["PALADIN"] = 635
+		end
+
+		local _, unitClass = UnitClass("player")
+		return defaultSpells[unitClass]
+	end
 end
 
 -- Load us up
-IceHUD.GlobalCoolDown = GlobalCoolDown:new()
+if IceHUD.CanTrackGCD then
+	IceHUD.GlobalCoolDown = GlobalCoolDown:new()
+end

modules/HarmonyPower.lua

@@ -1,10 +1,18 @@
 local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
 local HarmonyPower = IceCore_CreateClass(IceClassPowerCounter)
 
-function HarmonyPower.prototype:init()
-	HarmonyPower.super.prototype.init(self, "HarmonyPower")
+local SPELL_POWER_CHI = SPELL_POWER_CHI
+if not SPELL_POWER_CHI then
+	SPELL_POWER_CHI = SPELL_POWER_LIGHT_FORCE
+end
+if Enum and Enum.PowerType then
+	SPELL_POWER_CHI = Enum.PowerType.Chi
+end
 
-	self:SetDefaultColor("HarmonyPowerNumeric", 218, 231, 31)
+function HarmonyPower.prototype:init()
+	HarmonyPower.super.prototype.init(self, "Chi")
+
+	self:SetDefaultColor("ChiNumeric", 218, 231, 31)
 
 	-- pulled from MonkHarmonyBar.xml in Blizzard's UI source
 	self.runeCoords =
@@ -17,12 +25,8 @@ function HarmonyPower.prototype:init()
 		{0.00390625, 0.08593750, 0.71093750, 0.87500000},
 	}
 	self.numRunes = 4
-	self.numericColor = "HarmonyPowerNumeric"
-	if IceHUD.WowVer >= 50100 then
-		self.unitPower = SPELL_POWER_CHI
-	else
-		self.unitPower = SPELL_POWER_LIGHT_FORCE
-	end
+	self.numericColor = "ChiNumeric"
+	self.unitPower = SPELL_POWER_CHI
 	if IceHUD.WowVer >= 70000 then
 		self.requiredSpec = SPEC_MONK_WINDWALKER
 	end
@@ -91,19 +95,27 @@ function HarmonyPower.prototype:GetRuneTexture(rune)
 end
 
 function HarmonyPower.prototype:ShowBlizz()
-	MonkHarmonyBar:Show()
+	local frame = MonkHarmonyBarFrame
+	if frame == nil then
+		frame = MonkHarmonyBar
+	end
 
-	MonkHarmonyBar:GetScript("OnLoad")(MonkHarmonyBar)
+	frame:Show()
+	frame:GetScript("OnLoad")(frame)
 end
 
 function HarmonyPower.prototype:HideBlizz()
-	MonkHarmonyBar:Hide()
+	local frame = MonkHarmonyBarFrame
+	if frame == nil then
+		frame = MonkHarmonyBar
+	end
 
-	MonkHarmonyBar:UnregisterAllEvents()
+	frame:Hide()
+	frame:UnregisterAllEvents()
 end
 
 -- Load us up
 local _, unitClass = UnitClass("player")
-if (unitClass == "MONK" and IceHUD.WowVer >= 50000) then
+if unitClass == "MONK" then
 	IceHUD.HarmonyPower = HarmonyPower:new()
 end

modules/HolyPower.lua

@@ -1,6 +1,11 @@
 local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
 local HolyPower = IceCore_CreateClass(IceClassPowerCounter)
 
+local SPELL_POWER_HOLY_POWER = SPELL_POWER_HOLY_POWER
+if Enum and Enum.PowerType then
+	SPELL_POWER_HOLY_POWER = Enum.PowerType.HolyPower
+end
+
 function HolyPower.prototype:init()
 	HolyPower.super.prototype.init(self, "HolyPower")
 
@@ -27,13 +32,13 @@ function HolyPower.prototype:init()
 	self.numericColor = "HolyPowerNumeric"
 	self.unitPower = SPELL_POWER_HOLY_POWER
 	self.minLevel = PALADINPOWERBAR_SHOW_LEVEL
-	if IceHUD.WowVer >= 70000 then
+	if IceHUD.WowVer >= 70000 and IceHUD.WowVer < 90000 then
 		self.requiredSpec = SPEC_PALADIN_RETRIBUTION
 	end
 	self.bTreatEmptyAsFull = true
 	self.unit = "player"
 	self.numRunes = 5
-	if IceHUD.WowVer >= 50000 then
+	if HOLY_POWER_FULL then
 		self.numConsideredFull = HOLY_POWER_FULL
 	else
 		self.numConsideredFull = 3
@@ -78,15 +83,23 @@ function HolyPower.prototype:GetRuneTexture(rune)
 end
 
 function HolyPower.prototype:ShowBlizz()
-	PaladinPowerBar:Show()
+	local frame = PaladinPowerBarFrame
+	if frame == nil then
+		frame = PaladinPowerBar
+	end
 
-	PaladinPowerBar:GetScript("OnLoad")(PaladinPowerBar)
+	frame:Show()
+	frame:GetScript("OnLoad")(frame)
 end
 
 function HolyPower.prototype:HideBlizz()
-	PaladinPowerBar:Hide()
+	local frame = PaladinPowerBarFrame
+	if frame == nil then
+		frame = PaladinPowerBar
+	end
 
-	PaladinPowerBar:UnregisterAllEvents()
+	frame:Hide()
+	frame:UnregisterAllEvents()
 end
 
 function HolyPower.prototype:UpdateRunePower(event)
@@ -121,7 +134,7 @@ end
 
 -- Load us up
 local _, unitClass = UnitClass("player")
-if (unitClass == "PALADIN" and IceHUD.WowVer >= 40000) then
+if (unitClass == "PALADIN" and (PaladinPowerBar or PaladinPowerBarFrame)) then
 	IceHUD.HolyPower = HolyPower:new()
 end
 

modules/MirrorBar.lua

@@ -165,6 +165,8 @@ function MirrorBarHandler.prototype:init()
 	self:SetDefaultColor("BREATH", 0, 0.5, 1)
 	self:SetDefaultColor("DEATH", 1, 0.7, 0)
 	self:SetDefaultColor("FEIGNDEATH", 1, 0.9, 0)
+
+	self.scalingEnabled = true
 end
 
 
@@ -278,8 +280,8 @@ function MirrorBarHandler.prototype:GetOptions()
 		type='range',
 		name = L["Bar vertical offset"],
 		desc = L["Adjust the vertical placement of this bar"],
-		min = -400,
-		max = 400,
+		min = -600,
+		max = 600,
 		step = 1,
 		get = function()
 			return self.moduleSettings.barVerticalOffset
@@ -540,6 +542,7 @@ function MirrorBarHandler.prototype:SetSettings(bar)
 	bar.moduleSettings.barVerticalOffset = self.moduleSettings.barVerticalOffset
 	bar.moduleSettings.alwaysFullAlpha = self.moduleSettings.alwaysFullAlpha
 	bar.moduleSettings.rotateBar = self.moduleSettings.rotateBar
+	bar.moduleSettings.scale = self.moduleSettings.scale
 end
 
 

modules/PetHealth.lua

@@ -42,16 +42,23 @@ function PetHealth.prototype:Enable(core)
 	PetHealth.super.prototype.Enable(self, core)
 
 	self:RegisterEvent("PET_UI_UPDATE",	 "CheckPet");
-	self:RegisterEvent("PLAYER_PET_CHANGED", "CheckPet");
-	self:RegisterEvent("PET_BAR_CHANGED", "CheckPet");
+	if IceHUD.EventExistsPlayerPetChanged then
+		self:RegisterEvent("PLAYER_PET_CHANGED", "CheckPet");
+	end
+	self:RegisterEvent("PET_BAR_UPDATE_USABLE", "CheckPet");
 	self:RegisterEvent("UNIT_PET", "CheckPet");
 
 	self:RegisterEvent("UNIT_HEALTH", "UpdateEvent")
+	if IceHUD.EventExistsUnitHealthFrequent then
+		self:RegisterEvent("UNIT_HEALTH_FREQUENT", "UpdateEvent")
+	end
 	self:RegisterEvent("UNIT_MAXHEALTH", "UpdateEvent")
 
-	self:RegisterEvent("UNIT_ENTERED_VEHICLE", "EnteringVehicle")
-	self:RegisterEvent("UNIT_EXITED_VEHICLE", "ExitingVehicle")
-	self:RegisterEvent("PLAYER_ENTERING_WORLD", "CheckVehicle")
+	if UnitHasVehicleUI then
+		self:RegisterEvent("UNIT_ENTERED_VEHICLE", "EnteringVehicle")
+		self:RegisterEvent("UNIT_EXITED_VEHICLE", "ExitingVehicle")
+	end
+	self:RegisterEvent("PLAYER_ENTERING_WORLD", "EnteringWorld")
 
 	self.frame:SetAttribute("unit", self.unit)
 	RegisterUnitWatch(self.frame)
@@ -217,11 +224,16 @@ function PetHealth.prototype:ExitingVehicle(event, unit)
 	end
 end
 
-function PetHealth.prototype:CheckVehicle()
-	if UnitHasVehicleUI("player") then
-		self:EnteringVehicle(nil, "player", true)
-	else
-		self:ExitingVehicle(nil, "player")
+function PetHealth.prototype:EnteringWorld()
+	self:TargetChanged()
+	self:Update(self.unit)
+
+	if UnitHasVehicleUI then
+		if UnitHasVehicleUI("player") then
+			self:EnteringVehicle(nil, "player", true)
+		else
+			self:ExitingVehicle(nil, "player")
+		end
 	end
 end
 

modules/PetMana.lua

@@ -1,6 +1,17 @@
 local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
 local PetMana = IceCore_CreateClass(IceUnitBar)
 
+local SPELL_POWER_RAGE = SPELL_POWER_RAGE
+local SPELL_POWER_FOCUS = SPELL_POWER_FOCUS
+local SPELL_POWER_ENERGY = SPELL_POWER_ENERGY
+local SPELL_POWER_RUNIC_POWER = SPELL_POWER_RUNIC_POWER
+if Enum and Enum.PowerType then
+	SPELL_POWER_RAGE = Enum.PowerType.Rage
+	SPELL_POWER_FOCUS = Enum.PowerType.Focus
+	SPELL_POWER_ENERGY = Enum.PowerType.Energy
+	SPELL_POWER_RUNIC_POWER = Enum.PowerType.RunicPower
+end
+
 -- Constructor --
 function PetMana.prototype:init()
 	PetMana.super.prototype.init(self, "PetMana", "pet")
@@ -51,13 +62,17 @@ function PetMana.prototype:Enable(core)
 	PetMana.super.prototype.Enable(self, core)
 
 	self:RegisterEvent("PET_UI_UPDATE",	 "CheckPet")
-	self:RegisterEvent("PLAYER_PET_CHANGED", "CheckPet")
-	self:RegisterEvent("PET_BAR_CHANGED", "CheckPet")
+	if IceHUD.EventExistsPlayerPetChanged then
+		self:RegisterEvent("PLAYER_PET_CHANGED", "CheckPet")
+	end
+	self:RegisterEvent(IceHUD.EventExistsPetBarChanged and "PET_BAR_CHANGED" or "PET_BAR_UPDATE_USABLE", "CheckPet")
 	self:RegisterEvent("UNIT_PET", "CheckPet")
 
-	if IceHUD.WowVer >= 40000 then
-		self:RegisterEvent("UNIT_POWER", "UpdateEvent")
-		self:RegisterEvent("UNIT_MAXPOWER", "UpdateEvent")
+	if not IceHUD.PerPowerEventsExist then
+		self:RegisterEvent(IceHUD.UnitPowerEvent, "UpdateEvent")
+		if IceHUD.EventExistsUnitMaxPower then
+			self:RegisterEvent("UNIT_MAXPOWER", "UpdateEvent")
+		end
 	else
 		self:RegisterEvent("UNIT_MANA", "UpdateEvent")
 		self:RegisterEvent("UNIT_MAXMANA", "UpdateEvent")
@@ -71,9 +86,11 @@ function PetMana.prototype:Enable(core)
 
 	self:RegisterEvent("UNIT_DISPLAYPOWER", "ManaType")
 
-	self:RegisterEvent("UNIT_ENTERED_VEHICLE", "EnteringVehicle")
-	self:RegisterEvent("UNIT_EXITED_VEHICLE", "ExitingVehicle")
-	self:RegisterEvent("PLAYER_ENTERING_WORLD", "CheckVehicle")
+	if UnitHasVehicleUI then
+		self:RegisterEvent("UNIT_ENTERED_VEHICLE", "EnteringVehicle")
+		self:RegisterEvent("UNIT_EXITED_VEHICLE", "ExitingVehicle")
+	end
+	self:RegisterEvent("PLAYER_ENTERING_WORLD", "EnteringWorld")
 
 	self:CheckPet()
 	self:ManaType(nil, self.unit)
@@ -224,11 +241,16 @@ function PetMana.prototype:ExitingVehicle(event, unit)
 	end
 end
 
-function PetMana.prototype:CheckVehicle()
-	if UnitHasVehicleUI("player") then
-		self:EnteringVehicle(nil, "player", true)
-	else
-		self:ExitingVehicle(nil, "player")
+function PetMana.prototype:EnteringWorld()
+	self:TargetChanged()
+	self:Update(self.unit)
+
+	if UnitHasVehicleUI then
+		if UnitHasVehicleUI("player") then
+			self:EnteringVehicle(nil, "player", true)
+		else
+			self:ExitingVehicle(nil, "player")
+		end
 	end
 end
 

modules/PlayerAbsorb.lua

@@ -13,15 +13,12 @@ function PlayerAbsorb.prototype:GetDefaultSettings()
 
 	settings["side"] = IceCore.Side.Left
 	settings["offset"] = 3
+	settings["enabled"] = true
 
 	return settings
 end
 
-function PlayerAbsorb.prototype:MyRegisterCustomEvents()
-end
-
-function PlayerAbsorb.prototype:MyUnregisterCustomEvents()
-end
-
 -- Load us up
-IceHUD.PlayerAbsorb = PlayerAbsorb:new()
+if UnitGetTotalAbsorbs ~= nil then
+	IceHUD.PlayerAbsorb = PlayerAbsorb:new()
+end

modules/PlayerAltMana.lua

@@ -6,6 +6,13 @@ PlayerAltMana.prototype.PlayerAltManaMax = nil
 
 local _, unitClass = UnitClass("player")
 
+local SPELL_POWER_MANA = SPELL_POWER_MANA
+local SPELL_POWER_INSANITY = SPELL_POWER_INSANITY
+if Enum and Enum.PowerType then
+	SPELL_POWER_MANA = Enum.PowerType.Mana
+	SPELL_POWER_INSANITY = Enum.PowerType.Insanity
+end
+
 -- Constructor --
 function PlayerAltMana.prototype:init()
 	PlayerAltMana.super.prototype.init(self, "PlayerAltMana", "player")
@@ -76,6 +83,7 @@ function PlayerAltMana.prototype:Update()
 
 	self.PlayerAltMana = UnitPower(self.unit, SPELL_POWER_MANA)
 	self.PlayerAltManaMax = UnitPowerMax(self.unit, SPELL_POWER_MANA)
+	self.PlayerAltManaPercentage = self.PlayerAltManaMax ~= 0 and (self.PlayerAltMana/self.PlayerAltManaMax) or 0
 
 	if (not self.alive or not ShouldShow(self.unit) or not self.PlayerAltMana or not self.PlayerAltManaMax or self.PlayerAltManaMax == 0) then
 		self:Show(false)
@@ -84,6 +92,16 @@ function PlayerAltMana.prototype:Update()
 		self:Show(true)
 	end
 
+	if not IceHUD.IceCore:ShouldUseDogTags() and self.frame:IsVisible() then
+		self:SetBottomText1(math.floor(self.PlayerAltManaPercentage * 100))
+
+		if (self.PlayerAltManaMax ~= 100) then
+			self:SetBottomText2(self:GetFormattedText(self:Round(self.PlayerAltMana), self:Round(self.PlayerAltManaMax)), "PlayerMana")
+		else
+			self:SetBottomText2()
+		end
+	end
+
 	self:UpdateBar(self.PlayerAltManaMax ~= 0 and self.PlayerAltMana / self.PlayerAltManaMax or 0, "PlayerAltMana")
 end
 

modules/PlayerAlternatePower.lua

@@ -28,8 +28,10 @@ end
 function IceHUDPlayerAlternatePower.prototype:Enable(core)
 	IceHUDPlayerAlternatePower.super.prototype.Enable(self, core)
 
-	self:RegisterEvent("UNIT_POWER", "UpdateEvent")
-	self:RegisterEvent("UNIT_MAXPOWER", "UpdateEvent")
+	self:RegisterEvent(IceHUD.UnitPowerEvent, "UpdateEvent")
+	if IceHUD.EventExistsUnitMaxPower then
+		self:RegisterEvent("UNIT_MAXPOWER", "UpdateEvent")
+	end
 	self:RegisterEvent("UNIT_POWER_BAR_SHOW", "PowerBarShow")
 	self:RegisterEvent("UNIT_POWER_BAR_HIDE", "PowerBarHide")
 
@@ -130,4 +132,6 @@ function IceHUDPlayerAlternatePower.prototype:HideBlizz()
 end
 
 -- Load us up
-IceHUD.PlayerAlternatePower = IceHUDPlayerAlternatePower:new()
+if ALTERNATE_POWER_INDEX then
+	IceHUD.PlayerAlternatePower = IceHUDPlayerAlternatePower:new()
+end

modules/PlayerHealth.lua

@@ -5,10 +5,12 @@ local IceHUD = _G.IceHUD
 
 PlayerHealth.prototype.resting = nil
 PlayerHealth.prototype.pendingBlizzardPartyHide = false
+PlayerHealth.prototype.absorbAmount = 0
 
 local configMode = false
 local HealComm
 local incomingHealAmt = 0
+local groupEvent = IceHUD.EventExistsGroupRosterUpdate and "GROUP_ROSTER_UPDATE" or "PARTY_MEMBERS_CHANGED"
 
 -- Constructor --
 function PlayerHealth.prototype:init()
@@ -16,6 +18,7 @@ function PlayerHealth.prototype:init()
 
 	self:SetDefaultColor("PlayerHealth", 37, 164, 30)
 	self:SetDefaultColor("PlayerHealthHealAmount", 37, 164, 30)
+	self:SetDefaultColor("PlayerHealthAbsorbAmount", 220, 220, 220)
 end
 
 
@@ -27,12 +30,14 @@ function PlayerHealth.prototype:GetDefaultSettings()
 	settings["hideBlizz"] = false
 	settings["hideBlizzParty"] = false
 	settings["upperText"] = "[PercentHP:Round]"
-	settings["lowerText"] = "[FractionalHP:HPColor:Bracket]"
+	settings["lowerText"] = "[FractionalHP:Short:HPColor:Bracket]"
 	settings["allowMouseInteraction"] = false
 	settings["allowMouseInteractionCombat"] = false
 	settings["healAlpha"] = 0.6
+	settings["absorbAlpha"] = 0.6
 	settings["lockIconAlpha"] = false
 	settings["showIncomingHeals"] = true
+	settings["showAbsorbs"] = true
 
 	settings["showStatusIcon"] = true
 	settings["statusIconOffset"] = {x=110, y=0}
@@ -64,6 +69,9 @@ function PlayerHealth.prototype:Enable(core)
 	PlayerHealth.super.prototype.Enable(self, core)
 
 	self:RegisterEvent("UNIT_HEALTH", "UpdateEvent")
+	if IceHUD.EventExistsUnitHealthFrequent then
+		self:RegisterEvent("UNIT_HEALTH_FREQUENT", "UpdateEvent")
+	end
 	self:RegisterEvent("UNIT_MAXHEALTH", "UpdateEvent")
 
 	self:RegisterEvent("PLAYER_ENTERING_WORLD", "EnteringWorld")
@@ -74,14 +82,12 @@ function PlayerHealth.prototype:Enable(core)
 	self:RegisterEvent("PLAYER_REGEN_DISABLED", "CheckCombat")
 
 	self:RegisterEvent("PARTY_LEADER_CHANGED", "CheckLeader")
-	if IceHUD.WowVer >= 50000 then
-		self:RegisterEvent("GROUP_ROSTER_UPDATE", "CheckLeader")
-	else
-		self:RegisterEvent("PARTY_MEMBERS_CHANGED", "CheckLeader")
+	self:RegisterEvent(groupEvent, "CheckLeader")
+	if GetLFGProposal then
+		self:RegisterEvent("LFG_PROPOSAL_UPDATE", "CheckPartyRole")
+		self:RegisterEvent("LFG_PROPOSAL_FAILED", "CheckPartyRole")
+		self:RegisterEvent("LFG_ROLE_UPDATE", "CheckPartyRole")
 	end
-	self:RegisterEvent("LFG_PROPOSAL_UPDATE", "CheckPartyRole")
-	self:RegisterEvent("LFG_PROPOSAL_FAILED", "CheckPartyRole")
-	self:RegisterEvent("LFG_ROLE_UPDATE", "CheckPartyRole")
 
 	--self:RegisterEvent("PARTY_MEMBERS_CHANGED", "CheckPartyFrameStatus")
 
@@ -91,10 +97,12 @@ function PlayerHealth.prototype:Enable(core)
 	self:RegisterEvent("PLAYER_FLAGS_CHANGED", "CheckPvP")
 	self:RegisterEvent("UNIT_FACTION", "CheckPvP")
 
-	self:RegisterEvent("UNIT_ENTERED_VEHICLE", "EnteringVehicle")
-	self:RegisterEvent("UNIT_EXITED_VEHICLE", "ExitingVehicle")
+	if UnitHasVehicleUI then
+		self:RegisterEvent("UNIT_ENTERED_VEHICLE", "EnteringVehicle")
+		self:RegisterEvent("UNIT_EXITED_VEHICLE", "ExitingVehicle")
+	end
 
-	if IceHUD.WowVer < 40000 then
+	if not IceHUD.SupportsHealPrediction then
 		HealComm = LibStub("LibHealComm-4.0", true)
 		if HealComm then
 			HealComm.RegisterCallback(self, "HealComm_HealStarted", function(event, casterGUID, spellID, spellType, endTime, ...) self:HealComm_HealEvent(event, casterGUID, spellID, spellType, endTime, ...) end)
@@ -107,6 +115,10 @@ function PlayerHealth.prototype:Enable(core)
 		self:RegisterEvent("UNIT_HEAL_PREDICTION", "IncomingHealPrediction")
 	end
 
+	if UnitGetTotalAbsorbs then
+		self:RegisterEvent("UNIT_ABSORB_AMOUNT_CHANGED", "UpdateAbsorbAmount")
+	end
+
 	if (self.moduleSettings.hideBlizz) then
 		self:HideBlizz()
 	end
@@ -154,7 +166,7 @@ function PlayerHealth.prototype:HealComm_ModifierChanged(event, guid)
 end
 
 function PlayerHealth.prototype:IncomingHealPrediction(event, unit)
-	if IceHUD.WowVer >= 40000 then
+	if IceHUD.SupportsHealPrediction then
 		if unit and unit ~= self.unit then
 			return
 		end
@@ -164,6 +176,11 @@ function PlayerHealth.prototype:IncomingHealPrediction(event, unit)
 	end
 end
 
+function PlayerHealth.prototype:UpdateAbsorbAmount()
+	self.absorbAmount = UnitGetTotalAbsorbs(self.unit) or 0
+	self:Update()
+end
+
 
 -- OVERRIDE
 function PlayerHealth.prototype:GetOptions()
@@ -301,7 +318,7 @@ function PlayerHealth.prototype:GetOptions()
 			self:Update()
 		end,
 		disabled = function()
-			return not (self.moduleSettings.enabled and (IceHUD.WowVer >= 40000 or HealComm))
+			return not (self.moduleSettings.enabled and (IceHUD.SupportsHealPrediction or HealComm))
 		end,
 		order = 43.6
 	}
@@ -327,6 +344,52 @@ function PlayerHealth.prototype:GetOptions()
 		order = 43.7
 	}
 
+	opts["showAbsorbs"] =
+	{
+		type = 'toggle',
+		name = L["Show absorbs"],
+		desc = L["Whether or not to show absorb amounts as a lighter-colored bar on top of your current health."],
+		get = function()
+			return self.moduleSettings.showAbsorbs
+		end,
+		set = function(info, v)
+			if not v then
+				self.absorbFrame.bar:Hide()
+			else
+				self.absorbFrame.bar:Show()
+			end
+
+			self.moduleSettings.showAbsorbs = v
+
+			self:Update()
+		end,
+		disabled = function()
+			return not (self.moduleSettings.enabled and UnitGetTotalAbsorbs)
+		end,
+		order = 43.8
+	}
+
+	opts["absorbAlpha"] =
+	{
+		type = "range",
+		name = L["Absorb bar alpha"],
+		desc = L["What alpha value to use for the bar that displays how much effective health you have including absorbs (This gets multiplied by the bar's current alpha to stay in line with the bar on top of it)"],
+		min = 0,
+		max = 100,
+		step = 5,
+		get = function()
+			return self.moduleSettings.absorbAlpha * 100
+		end,
+		set = function(info, v)
+			self.moduleSettings.absorbAlpha = v / 100.0
+			self:Redraw()
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled or not self.moduleSettings.showAbsorbs
+		end,
+		order = 43.9
+	}
+
 	opts["iconSettings"] =
 	{
 		type = 'group',
@@ -824,6 +887,7 @@ function PlayerHealth.prototype:CreateFrame()
 	PlayerHealth.super.prototype.CreateFrame(self)
 
 	self:CreateHealBar()
+	self:CreateAbsorbBar()
 end
 
 
@@ -869,17 +933,29 @@ function PlayerHealth.prototype:CreateBackground(redraw)
 end
 
 function PlayerHealth.prototype:CreateHealBar()
-	self.healFrame = self:BarFactory(self.healFrame, "LOW","BACKGROUND")
+	self.healFrame = self:BarFactory(self.healFrame, "LOW","BACKGROUND", "Heal")
 
 	self.healFrame.bar:SetVertexColor(self:GetColor("PlayerHealthHealAmount", self.alpha * self.moduleSettings.healAlpha))
 
 	self:UpdateBar(1, "undef")
 
-	if not self.moduleSettings.showIncomingHeals or (IceHUD.WowVer < 40000 and not HealComm) then
+	if not self.moduleSettings.showIncomingHeals or (not IceHUD.SupportsHealPrediction and not HealComm) then
 		self.healFrame.bar:Hide()
 	end
 end
 
+function PlayerHealth.prototype:CreateAbsorbBar()
+	self.absorbFrame = self:BarFactory(self.absorbFrame, "LOW","BACKGROUND", "Absorb")
+
+	self.absorbFrame.bar:SetVertexColor(self:GetColor("PlayerHealthAbsorbAmount", self.alpha * self.moduleSettings.absorbAlpha))
+
+	self:UpdateBar(1, "undef")
+
+	if not self.moduleSettings.showAbsorbs or not UnitGetTotalAbsorbs then
+		self.absorbFrame.bar:Hide()
+	end
+end
+
 
 function PlayerHealth.prototype:EnableClickTargeting(bEnable)
 	if bEnable then
@@ -924,10 +1000,12 @@ function PlayerHealth.prototype:EnteringWorld()
 end
 
 function PlayerHealth.prototype:CheckVehicle()
-	if UnitHasVehicleUI("player") then
-		self:EnteringVehicle(nil, "player", true)
-	else
-		self:ExitingVehicle(nil, "player")
+	if UnitHasVehicleUI then
+		if UnitHasVehicleUI("player") then
+			self:EnteringVehicle(nil, "player", true)
+		else
+			self:ExitingVehicle(nil, "player")
+		end
 	end
 end
 
@@ -1008,12 +1086,12 @@ function PlayerHealth.prototype:CheckPartyRole()
 	if configMode or IceHUD:GetIsInLFGGroup() then
 		if (configMode or self.moduleSettings.showPartyRoleIcon) and not self.frame.PartyRoleIcon then
 			local isTank, isHeal, isDPS
-			local proposalExists, typeID, id, name
+			local proposalExists, typeID, id, subtypeID, name
 			local texture, role, hasResponded, totalEncounters, completedEncounters, numMembers, isleader
-			proposalExists, typeID, id, name, texture, role, hasResponded, totalEncounters, completedEncounters, numMembers, isleader = GetLFGProposal()
+			proposalExists, id, typeID, subtypeID, name, texture, role, hasResponded, totalEncounters, completedEncounters, numMembers, isleader = GetLFGProposal()
 
 			local p = self.unit
-			if IceHUD.WowVer < 40000 then
+			if not IceHUD.UnitGroupRolesReturnsRoleString then
 				isTank, isHeal, isDPS = UnitGroupRolesAssigned(p)
 			else
 				local grpRole = UnitGroupRolesAssigned(p)
@@ -1026,7 +1104,7 @@ function PlayerHealth.prototype:CheckPartyRole()
 			IceHUD:Debug( tostring(proposalExists) .."**".. tostring(typeID) .."**".. tostring(id) .."**".. tostring(name) .."**".. tostring(texture) .."**".. tostring(role) .."**".. tostring(hasResponded) .."**".. tostring(totalEncounters) .."**".. tostring(completedEncounters) .."**".. tostring(numMembers) .."**".. tostring(isleader) )
 
 			if proposalExists == true then
-				IceHUD:Debug(tostring(typeID).." "..role)
+				IceHUD:Debug(tostring(typeID).." "..(role or ""))
 				isTank = (role == "TANK")
 				isHeal = (role == "HEALER")
 				isDPS = (role == "DAMAGER")
@@ -1090,7 +1168,7 @@ end
 
 function PlayerHealth.prototype:CheckLeader()
 	local isLeader
-	if IceHUD.WowVer >= 50000 then
+	if UnitIsGroupLeader then
 		isLeader = UnitIsGroupLeader("player")
 	else
 		isLeader = IsPartyLeader()
@@ -1151,7 +1229,7 @@ function PlayerHealth.prototype:CheckPvP()
 		minx, maxx, miny, maxy = 0.05, 0.605, 0.015, 0.57
 	elseif UnitIsPVP(self.unit) then
 		pvpMode = UnitFactionGroup(self.unit)
-		
+
 		if pvpMode == "Neutral" then
 			pvpMode = "FFA"
 		end
@@ -1216,7 +1294,7 @@ function PlayerHealth.prototype:Update(unit)
 		local percent
 
 		if incomingHealAmt > 0 then
-			percent = self.maxHealth ~= 0 and ((self.health + incomingHealAmt) / self.maxHealth) or 0
+			percent = self.maxHealth ~= 0 and ((self.health + (self.absorbAmount or 0) + incomingHealAmt) / self.maxHealth) or 0
 			if self.moduleSettings.reverse then
 				percent = 1 - percent
 				-- Rokiyo: I'm thinking the frama strata should also to be set to medium if we're in reverse.
@@ -1230,6 +1308,23 @@ function PlayerHealth.prototype:Update(unit)
 		self:SetBarCoord(self.healFrame, percent)
 	end
 
+	if self.moduleSettings.showAbsorbs and self.absorbFrame and self.absorbFrame.bar and self.absorbAmount then
+		local percent
+
+		if self.absorbAmount > 0 then
+			percent = self.maxHealth ~= 0 and ((self.health + self.absorbAmount) / self.maxHealth) or 0
+			if self.moduleSettings.reverse then
+				percent = 1 - percent
+			end
+		else
+			percent = 0
+		end
+
+		percent = IceHUD:Clamp(percent, 0, 1)
+
+		self:SetBarCoord(self.absorbFrame, percent)
+	end
+
 	if not IceHUD.IceCore:ShouldUseDogTags() then
 		self:SetBottomText1(math.floor(self.healthPercentage * 100))
 		self:SetBottomText2(self:GetFormattedText(self.health, self.maxHealth), textColor)
@@ -1309,15 +1404,56 @@ end
 
 
 function PlayerHealth.prototype:ShowBlizz()
-	PlayerFrame:Show()
-	PlayerFrame:GetScript("OnLoad")(PlayerFrame)
+	PlayerFrame:SetParent(self.OriginalPlayerFrameParent or UIParent)
 end
 
 
 function PlayerHealth.prototype:HideBlizz()
-	PlayerFrame:Hide()
+	if not self.PlayerFrameParent then
+		self.PlayerFrameParent = CreateFrame("Frame")
+		self.PlayerFrameParent:Hide()
+	end
 
-	PlayerFrame:UnregisterAllEvents()
+	self.OriginalPlayerFrameParent = PlayerFrame:GetParent()
+	PlayerFrame:SetParent(self.PlayerFrameParent)
+end
+
+local parents = {}
+local hide_frame = IceHUD:OutOfCombatWrapper(function(self) self:Hide() end)
+
+local function hook_frames(...)
+	for i = 1, select("#", ...) do
+		local frame = select(i, ...)
+		frame:UnregisterAllEvents()
+		if not IceHUD:IsHooked(frame, "OnShow") then
+			IceHUD:SecureHookScript(frame, "OnShow", hide_frame)
+		end
+		frame:Hide()
+	end
+end
+
+local function unhook_frame(frame)
+	if IceHUD:IsHooked(frame, "OnShow") then
+		IceHUD:Unhook(frame, "OnShow")
+		local parent = parents[frame]
+		if parent then
+			frame:SetParent(parent)
+		end
+	elseif IceHUD:IsHooked(frame, "Show") then
+		IceHUD:Unhook(frame, "Show")
+		IceHUD:Unhook(frame, "SetPoint")
+	end
+end
+
+local function unhook_frames(...)
+	for i = 1, select("#", ...) do
+		local frame = select(i, ...)
+		unhook_frame(frame)
+		local handler = frame:GetScript("OnLoad")
+		if handler then
+			handler(frame)
+		end
+	end
 end
 
 function PlayerHealth.prototype:HideBlizzardParty()
@@ -1326,37 +1462,34 @@ function PlayerHealth.prototype:HideBlizzardParty()
 		return
 	end
 
-	-- Both Pitbull 4 and Xperl use these exact code, so we use it too.
-	for i = 1, MAX_PARTY_MEMBERS do
-		local party = _G['PartyMemberFrame'..i]
-		party:UnregisterAllEvents()
-		party:Hide()
-		party.Show = function() end
+	if PartyFrame then
+		PartyFrame:Hide()
+		PartyFrame:UnregisterEvent(groupEvent)
+	else
+		for i = 1, MAX_PARTY_MEMBERS do
+			local frame = _G["PartyMemberFrame" .. i]
+			frame:SetAttribute("statehidden", true)
+			hook_frames(frame)
+		end
+		UIParent:UnregisterEvent(groupEvent)
 	end
-
-	UIParent:UnregisterEvent('RAID_ROSTER_UPDATE')
-
 end
 
 
 function PlayerHealth.prototype:ShowBlizzardParty()
-	-- Both Pitbull 4 and Xperl use these exact code, so we use it too.
-	for i = 1, MAX_PARTY_MEMBERS do
-		local frame = _G["PartyMemberFrame"..i]
-		if frame then
-			frame.Show = nil
-			frame:GetScript("OnLoad")(frame)
-			if IceHUD.WowVer >= 50000 then
-				frame:GetScript("OnEvent")(frame, "GROUP_ROSTER_UPDATE")
-			else
-				frame:GetScript("OnEvent")(frame, "PARTY_MEMBERS_CHANGED")
-			end
-
-			PartyMemberFrame_UpdateMember(frame)
+	if PartyFrame then
+		PartyFrame:Show()
+		PartyFrame:Layout()
+		PartyFrame:RegisterEvent(groupEvent)
+	else
+		for i = 1, MAX_PARTY_MEMBERS do
+			local frame = _G["PartyMemberFrame" .. i]
+			frame:SetAttribute("statehidden", nil)
+			unhook_frames(frame)
+			frame:GetScript("OnEvent")(frame, groupEvent)
 		end
+		UIParent:RegisterEvent(groupEvent)
 	end
-
-	UIParent:RegisterEvent("RAID_ROSTER_UPDATE")
 end
 
 --function PlayerHealth.prototype:ShowBlizzParty()
@@ -1399,6 +1532,9 @@ function PlayerHealth.prototype:UpdateBar(scale, color, alpha)
 	if self.healFrame and self.healFrame.bar then
 		self.healFrame.bar:SetVertexColor(self:GetColor("PlayerHealthHealAmount", self.alpha * self.moduleSettings.healAlpha))
 	end
+	if self.absorbFrame and self.absorbFrame.bar then
+		self.absorbFrame.bar:SetVertexColor(self:GetColor("PlayerHealthAbsorbAmount", self.alpha * self.moduleSettings.absorbAlpha))
+	end
 --[[ seems to be causing taint. oh well
 	if self.frame.button then
 		if self.alpha == 0 then

modules/PlayerInfo.lua

@@ -115,7 +115,9 @@ end
 
 function PlayerInfo.prototype:ShowBlizz()
 	BuffFrame:Show()
-	TemporaryEnchantFrame:Show()
+	if TemporaryEnchantFrame then
+		TemporaryEnchantFrame:Show()
+	end
 
 	BuffFrame:GetScript("OnLoad")(BuffFrame)
 end
@@ -123,7 +125,9 @@ end
 
 function PlayerInfo.prototype:HideBlizz()
 	BuffFrame:Hide()
-	TemporaryEnchantFrame:Hide()
+	if TemporaryEnchantFrame then
+		TemporaryEnchantFrame:Hide()
+	end
 
 	BuffFrame:UnregisterAllEvents()
 end

modules/PlayerMana.lua

@@ -3,6 +3,29 @@ local PlayerMana = IceCore_CreateClass(IceUnitBar)
 
 local IceHUD = _G.IceHUD
 
+local SPELL_POWER_MANA = SPELL_POWER_MANA
+local SPELL_POWER_RAGE = SPELL_POWER_RAGE
+local SPELL_POWER_FOCUS = SPELL_POWER_FOCUS
+local SPELL_POWER_ENERGY = SPELL_POWER_ENERGY
+local SPELL_POWER_RUNIC_POWER = SPELL_POWER_RUNIC_POWER
+local SPELL_POWER_INSANITY = SPELL_POWER_INSANITY
+local SPELL_POWER_FURY = SPELL_POWER_FURY
+local SPELL_POWER_MAELSTROM = SPELL_POWER_MAELSTROM
+local SPELL_POWER_PAIN = SPELL_POWER_PAIN
+local SPELL_POWER_LUNAR_POWER = SPELL_POWER_LUNAR_POWER
+if Enum and Enum.PowerType then
+	SPELL_POWER_MANA = Enum.PowerType.Mana
+	SPELL_POWER_RAGE = Enum.PowerType.Rage
+	SPELL_POWER_FOCUS = Enum.PowerType.Focus
+	SPELL_POWER_ENERGY = Enum.PowerType.Energy
+	SPELL_POWER_RUNIC_POWER = Enum.PowerType.RunicPower
+	SPELL_POWER_INSANITY = Enum.PowerType.Insanity
+	SPELL_POWER_FURY = Enum.PowerType.Fury
+	SPELL_POWER_MAELSTROM = Enum.PowerType.Maelstrom
+	SPELL_POWER_PAIN = Enum.PowerType.Pain
+	SPELL_POWER_LUNAR_POWER = Enum.PowerType.LunarPower
+end
+
 PlayerMana.prototype.manaType = nil
 PlayerMana.prototype.tickStart = nil
 PlayerMana.prototype.previousEnergy = nil
@@ -18,7 +41,9 @@ function PlayerMana.prototype:init()
 	self:SetDefaultColor("PlayerRunicPower", 62, 54, 152)
 	if IceHUD.WowVer >= 70000 then
 		self:SetDefaultColor("PlayerInsanity", 150, 50, 255)
-		self:SetDefaultColor("PlayerFury", 255, 50, 255)
+		self:SetDefaultColor("PlayerFury", 201, 66, 253)
+		self:SetDefaultColor("PlayerMaelstrom", 62, 54, 152)
+		self:SetDefaultColor("PlayerPain", 255, 156, 0)
 	end
 end
 
@@ -32,7 +57,7 @@ function PlayerMana.prototype:GetDefaultSettings()
 	settings["tickerEnabled"] = true
 	settings["tickerAlpha"] = 0.5
 	settings["upperText"] = "[PercentMP:Round]"
-	settings["lowerText"] = "[FractionalMP:PowerColor]"
+	settings["lowerText"] = "[FractionalMP:Short:PowerColor]"
 
 	return settings
 end
@@ -98,6 +123,27 @@ end
 		order = 53
 	}
 
+	opts["scaleManaColorForAll"] = {
+		type = "toggle",
+		name = L["Scale for non-mana users"],
+		desc = L["Uses the 'color bar by mana %' setting/colors even for classes that don't use Mana"],
+		width = 'double',
+		get = function()
+			return self.moduleSettings.scaleManaColorForAll
+		end,
+		set = function(info, value)
+			self.moduleSettings.scaleManaColorForAll = value
+			self:Redraw()
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end,
+		hidden = function()
+			return not self.moduleSettings.scaleManaColor
+		end,
+		order = 53.1
+	}
+
 	return opts
 end
 
@@ -107,9 +153,11 @@ function PlayerMana.prototype:Enable(core)
 
 	self:CreateTickerFrame()
 
-	if IceHUD.WowVer >= 40000 then
-		self:RegisterEvent("UNIT_POWER", "UpdateEvent")
-		self:RegisterEvent("UNIT_MAXPOWER", "UpdateEvent")
+	if not IceHUD.PerPowerEventsExist then
+		self:RegisterEvent(IceHUD.UnitPowerEvent, "UpdateEvent")
+		if IceHUD.EventExistsUnitMaxPower then
+			self:RegisterEvent("UNIT_MAXPOWER", "UpdateEvent")
+		end
 	else
 		self:RegisterEvent("UNIT_MAXMANA", "UpdateEvent")
 		self:RegisterEvent("UNIT_MAXRAGE", "UpdateEvent")
@@ -122,8 +170,10 @@ function PlayerMana.prototype:Enable(core)
 		self:RegisterEvent("UNIT_RUNIC_POWER", "UpdateEvent")
 	end
 
-	self:RegisterEvent("UNIT_ENTERED_VEHICLE", "EnteringVehicle")
-	self:RegisterEvent("UNIT_EXITED_VEHICLE", "ExitingVehicle")
+	if UnitHasVehicleUI then
+		self:RegisterEvent("UNIT_ENTERED_VEHICLE", "EnteringVehicle")
+		self:RegisterEvent("UNIT_EXITED_VEHICLE", "ExitingVehicle")
+	end
 	self:RegisterEvent("PLAYER_ENTERING_WORLD", "EnteringWorld")
 
 	if not self.CustomOnUpdate then
@@ -143,15 +193,17 @@ function PlayerMana.prototype:EnteringWorld()
 end
 
 function PlayerMana.prototype:CheckVehicle()
-	if UnitHasVehicleUI("player") then
-		self:EnteringVehicle(nil, "player", true)
-	else
-		self:ExitingVehicle(nil, "player")
+	if UnitHasVehicleUI then
+		if UnitHasVehicleUI("player") then
+			self:EnteringVehicle(nil, "player", true)
+		else
+			self:ExitingVehicle(nil, "player")
+		end
 	end
 end
 
 function PlayerMana.prototype:ShouldUseTicker()
-	return IceHUD.WowVer < 30000 or not GetCVarBool("predictedPower")
+	return IceHUD.WowVer < 30000 or (IceHUD.WowVer < 70100 and not GetCVarBool("predictedPower") and not IceHUD.WowClassicWrath)
 end
 
 function PlayerMana.prototype:SetupOnUpdate(enable)
@@ -228,7 +280,7 @@ function PlayerMana.prototype:ManaType(event, unit)
 
 	if self:ShouldUseTicker() then
 		-- register ticker for rogue energy
-		if (self.moduleSettings.tickerEnabled and (self.manaType == SPELL_POWER_ENERGY) and self.alive) then
+		if self.moduleSettings.tickerEnabled and self.manaType == SPELL_POWER_ENERGY then
 			self.tickerFrame:Show()
 			self.tickerFrame:SetScript("OnUpdate", function() self:EnergyTick() end)
 		else
@@ -237,15 +289,24 @@ function PlayerMana.prototype:ManaType(event, unit)
 		end
 	end
 
-	if self.manaType == SPELL_POWER_RAGE or self.manaType == SPELL_POWER_RUNIC_POWER then
-		self.bTreatEmptyAsFull = true
-	else
-		self.bTreatEmptyAsFull = false
-	end
+	self.bTreatEmptyAsFull = self:TreatEmptyAsFull()
 
 	self:Update(self.unit)
 end
 
+function PlayerMana.prototype:TreatEmptyAsFull()
+	return self.manaType == SPELL_POWER_RAGE or self.manaType == SPELL_POWER_RUNIC_POWER
+		or (IceHUD.WowVer >= 70000 and (self.manaType == SPELL_POWER_LUNAR_POWER or self.manaType == SPELL_POWER_INSANITY
+		or self.manaType == SPELL_POWER_FURY or self.manaType == SPELL_POWER_PAIN or self.manaType == SPELL_POWER_MAELSTROM))
+end
+
+function PlayerMana.prototype:IsFull(scale)
+	if IceHUD.WowVer >= 80000 and self.manaType == SPELL_POWER_LUNAR_POWER and IsPlayerSpell(202430) then
+		return scale - 0.5 >= 0
+	end
+
+	return PlayerMana.super.prototype.IsFull(self, scale)
+end
 
 function PlayerMana.prototype:UpdateEvent(event, unit, powertype)
 	self:Update(unit, powertype)
@@ -279,11 +340,10 @@ function PlayerMana.prototype:Update(unit, powertype)
 	end
 
 	local color = "PlayerMana"
-	if (self.moduleSettings.scaleManaColor) then
-		color = "ScaledManaColor"
-	end
 	if not (self.alive) then
 		color = "Dead"
+	elseif (self.moduleSettings.scaleManaColor and (UnitPowerType(self.unit) == SPELL_POWER_MANA or self.moduleSettings.scaleManaColorForAll)) then
+		color = "ScaledManaColor"
 	else
 		if (self.manaType == SPELL_POWER_RAGE) then
 			color = "PlayerRage"
@@ -293,10 +353,14 @@ function PlayerMana.prototype:Update(unit, powertype)
 			color = "PlayerRunicPower"
 		elseif (self.manaType == SPELL_POWER_FOCUS) then
 			color = "PlayerFocus"
-		elseif (IceHUD.WowVer >= 70000 and self.manaType == SPELL_POWER_INSANITY) then
+		elseif (self.manaType == SPELL_POWER_INSANITY) then
 			color = "PlayerInsanity"
-		elseif (IceHUD.WowVer >= 70000 and self.manaType == SPELL_POWER_FURY) then
+		elseif (self.manaType == SPELL_POWER_FURY) then
 			color = "PlayerFury"
+		elseif (self.manaType == SPELL_POWER_MAELSTROM) then
+			color = "PlayerMaelstrom"
+		elseif (self.manaType == SPELL_POWER_PAIN) then
+			color = "PlayerPain"
 		end
 	end
 
@@ -304,8 +368,8 @@ function PlayerMana.prototype:Update(unit, powertype)
 
 	self:ConditionalUpdateFlash()
 
-	if (self.manaPercentage == 1 and self.manaType ~= SPELL_POWER_RAGE and self.manaType ~= SPELL_POWER_RUNIC_POWER)
-		or (self.manaPercentage == 0 and (self.manaType == SPELL_POWER_RAGE or self.manaType == SPELL_POWER_RUNIC_POWER)) then
+	if (self.manaPercentage == 1 and not self:TreatEmptyAsFull())
+		or (self.manaPercentage == 0 and self:TreatEmptyAsFull()) then
 		self:SetupOnUpdate(false)
 	else
 		self:SetupOnUpdate(true)
@@ -323,7 +387,7 @@ function PlayerMana.prototype:Update(unit, powertype)
 	if not IceHUD.IceCore:ShouldUseDogTags() then
 		-- extra hack for whiny rogues (are there other kind?)
 		local displayPercentage = self.manaPercentage
-		if (self.manaType == SPELL_POWER_ENERGY) then
+		if self.manaType == SPELL_POWER_ENERGY or self.manaType == SPELL_POWER_FOCUS or self.manaType == SPELL_POWER_FURY then
 			displayPercentage = self.mana
 		else
 			displayPercentage = math.floor(displayPercentage * 100)
@@ -355,17 +419,17 @@ function PlayerMana.prototype:UpdateEnergy(event, unit)
 		return
 	end
 
-	self.previousEnergy = UnitPower(self.unit, UnitPowerType(self.unit))
-	if IceHUD.WowVer < 40000 then
-		self:Update(unit)
-	end
-
 	if self:ShouldUseTicker() and
-		((not (self.previousEnergy) or (self.previousEnergy <= UnitPower(self.unit, UnitPowerType(self.unit)))) and
+		((not (self.previousEnergy) or (self.previousEnergy < UnitPower(self.unit, UnitPowerType(self.unit)))) and
 		(self.moduleSettings.tickerEnabled) and self.manaType == SPELL_POWER_ENERGY) then
 			self.tickStart = GetTime()
 			self.tickerFrame:Show()
 	end
+
+	self.previousEnergy = UnitPower(self.unit, UnitPowerType(self.unit))
+	if IceHUD.WowVer < 40000 then
+		self:Update(unit)
+	end
 end
 
 
@@ -374,7 +438,7 @@ function PlayerMana.prototype:EnergyTick()
 		return
 	end
 
-	if not (self.tickStart) then
+	if not self.tickStart or not self.alive then
 		self.tickerFrame:Hide()
 		return
 	end

modules/Resolve.lua

@@ -56,7 +56,7 @@ do
 			return
 		end
 
-		self.current = select(15, UnitAura(self.unit, spellName)) or 0
+		self.current = select(IceHUD.SpellFunctionsReturnRank and 15 or 14, UnitAura(self.unit, spellName)) or 0
 
 		self:Update()
 	end
@@ -79,7 +79,7 @@ end
 
 -- Load for tanks only
 local _, unitClass = UnitClass("player")
-if ((unitClass == "DEATHKNIGHT" or unitClass == "DRUID" or unitClass == "PALADIN" or unitClass == "WARRIOR" or unitClass == "MONK")
-	and IceHUD.WowVer >= 60000) then
+if (unitClass == "DEATHKNIGHT" or unitClass == "DRUID" or unitClass == "PALADIN" or unitClass == "WARRIOR" or unitClass == "MONK")
+	and GetSpellInfo(RESOLVE_SPELL_ID) then
   IceHUD.Resolve = Resolve:new()
 end

modules/RollTheBones.lua

@@ -0,0 +1,475 @@
+local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
+local RollTheBones = IceCore_CreateClass(IceUnitBar)
+
+local IceHUD = _G.IceHUD
+
+local baseTime = 12
+local gapPerComboPoint = 6
+local maxComboPoints = 5
+local rtbEndTime = 0
+local rtbDuration = 0
+local rtbCount = 0
+local sixComboPointsTalentID = 19240
+local behaviorDependsOnComboPoints = IceHUD.WowVer < 90000
+
+local CurrMaxRtBDuration = 0
+local PotentialRtBDuration = 0
+
+local RtBBuffs = {199603, 193358, 193357, 193359, 199600, 193356}
+local RtBSet = {}
+for _, v in ipairs(RtBBuffs) do
+  RtBSet[v] = true
+end
+
+local SPELL_POWER_COMBO_POINTS = SPELL_POWER_COMBO_POINTS
+if Enum and Enum.PowerType then
+  SPELL_POWER_COMBO_POINTS = Enum.PowerType.ComboPoints
+end
+
+-- Constructor --
+function RollTheBones.prototype:init()
+  RollTheBones.super.prototype.init(self, "RollTheBones", "player")
+
+  self.moduleSettings = {}
+  self.moduleSettings.desiredLerpTime = 0
+  self.moduleSettings.shouldAnimate = false
+
+  self:SetDefaultColor("RollTheBones", 1, 0.6, 0.2)
+  if behaviorDependsOnComboPoints then
+    self:SetDefaultColor("RollTheBones2", 0.75, 1, 0.2)
+    self:SetDefaultColor("RollTheBones3", 0.4, 1, 0.2)
+    self:SetDefaultColor("RollTheBones4", 0.4, 1, 0.2)
+    self:SetDefaultColor("RollTheBones5", 0.1, 1, 0.7)
+    self:SetDefaultColor("RollTheBones6", 0.1, 1, 0.7)
+    self:SetDefaultColor("RollTheBonesPotential", 1, 1, 1)
+  end
+
+  self.bTreatEmptyAsFull = true
+end
+
+-- 'Public' methods -----------------------------------------------------------
+
+-- OVERRIDE
+function RollTheBones.prototype:Enable(core)
+  RollTheBones.super.prototype.Enable(self, core)
+
+  self:RegisterEvent("UNIT_AURA", "UpdateRollTheBones")
+
+  if behaviorDependsOnComboPoints then
+    self:RegisterEvent(IceHUD.UnitPowerEvent, "ComboPointsChanged")
+  end
+
+  if not self.moduleSettings.alwaysFullAlpha then
+    self:Show(false)
+  else
+    self:UpdateRollTheBones()
+  end
+
+  self:SetBottomText1("")
+end
+
+function RollTheBones.prototype:Disable(core)
+  RollTheBones.super.prototype.Disable(self, core)
+end
+
+function RollTheBones.prototype:ComboPointsChanged(...)
+  if select('#', ...) >= 3 and select(1, ...) == IceHUD.UnitPowerEvent and select(3, ...) ~= "COMBO_POINTS" then
+    return
+  end
+
+  self:TargetChanged()
+  self:UpdateDurationBar()
+end
+
+-- OVERRIDE
+function RollTheBones.prototype:GetDefaultSettings()
+  local settings = RollTheBones.super.prototype.GetDefaultSettings(self)
+
+  settings["enabled"] = false
+  settings["shouldAnimate"] = false
+  settings["desiredLerpTime"] = nil
+  settings["lowThreshold"] = 0
+  settings["side"] = IceCore.Side.Right
+  settings["offset"] = 6
+  settings["upperText"]="RtB:"
+  settings["showAsPercentOfMax"] = true
+  settings["durationAlpha"] = 0.6
+  settings["usesDogTagStrings"] = false
+  settings["lockLowerFontAlpha"] = false
+  settings["lowerTextString"] = ""
+  settings["lowerTextVisible"] = false
+  settings["hideAnimationSettings"] = true
+  settings["bAllowExpand"] = true
+  settings["bShowWithNoTarget"] = true
+  settings["bUseMultipleBuffColors"] = true
+
+  return settings
+end
+
+-- OVERRIDE
+function RollTheBones.prototype:GetOptions()
+  local opts = RollTheBones.super.prototype.GetOptions(self)
+
+  opts["textSettings"].args["upperTextString"]["desc"] = "The text to display under this bar. # will be replaced with the number of Roll the Bones seconds remaining."
+  opts["textSettings"].args["upperTextString"].hidden = false
+
+  if behaviorDependsOnComboPoints then
+    opts["showAsPercentOfMax"] =
+    {
+      type = 'toggle',
+      name = L["Show bar as % of maximum"],
+      desc = L["If this is checked, then the RtB buff time shows as a percent of the maximum attainable (taking set bonuses and talents into account). Otherwise, the bar always goes from full to empty when applying RtB no matter the duration."],
+      get = function()
+        return self.moduleSettings.showAsPercentOfMax
+      end,
+      set = function(info, v)
+        self.moduleSettings.showAsPercentOfMax = v
+      end,
+      disabled = function()
+        return not self.moduleSettings.enabled
+      end
+    }
+
+    opts["durationAlpha"] =
+    {
+      type = "range",
+      name = L["Potential RtB time bar alpha"],
+      desc = L["What alpha value to use for the bar that displays how long your RtB will last if you activate it. (This gets multiplied by the bar's current alpha to stay in line with the bar on top of it)"],
+      min = 0,
+      max = 100,
+      step = 5,
+      get = function()
+        return self.moduleSettings.durationAlpha * 100
+      end,
+      set = function(info, v)
+        self.moduleSettings.durationAlpha = v / 100.0
+        self:Redraw()
+      end,
+      disabled = function()
+        return not self.moduleSettings.enabled
+      end
+    }
+
+    opts["bUseMultipleBuffColors"] =
+    {
+      type = 'toggle',
+      name = L["Use multiple buff colors"],
+      desc = L["If this is checked, then the bar uses different colors depending on how many RtB buffs you have"],
+      get = function()
+        return self.moduleSettings.bUseMultipleBuffColors
+      end,
+      set = function(info, v)
+        self.moduleSettings.bUseMultipleBuffColors = v
+        self:Redraw()
+      end,
+      disabled = function()
+        return not self.moduleSettings.enabled
+      end,
+    }
+  end
+
+  opts["bShowWithNoTarget"] =
+  {
+    type = 'toggle',
+    name = L["Show with no target"],
+    desc = L["Whether or not to display when you have no target selected but have combo points available"],
+    get = function()
+      return self.moduleSettings.bShowWithNoTarget
+    end,
+    set = function(info, v)
+      self.moduleSettings.bShowWithNoTarget = v
+      self:ComboPointsChanged()
+    end,
+    disabled = function()
+      return not self.moduleSettings.enabled
+    end,
+  }
+
+  return opts
+end
+
+function RollTheBones.prototype:CreateFrame()
+  RollTheBones.super.prototype.CreateFrame(self)
+
+  self:CreateDurationBar()
+end
+
+function RollTheBones.prototype:CreateDurationBar()
+  if not behaviorDependsOnComboPoints then
+    return
+  end
+
+  self.durationFrame = self:BarFactory(self.durationFrame, "BACKGROUND","ARTWORK", "Duration")
+
+  -- Rokiyo: Do we need to call this here?
+  self.CurrScale = 0
+
+  self.durationFrame.bar:SetVertexColor(self:GetColor("RollTheBonesPotential", self.moduleSettings.durationAlpha))
+  self.durationFrame.bar:SetHeight(0)
+
+  self:UpdateBar(1, "undef")
+
+  -- force update the bar...if we're in here, then either the UI was just loaded or the player is jacking with the options.
+  -- either way, make sure the duration bar matches accordingly
+  self:UpdateDurationBar()
+end
+
+function RollTheBones.prototype:RotateHorizontal()
+  RollTheBones.super.prototype.RotateHorizontal(self)
+
+  if self.durationFrame then
+    self:RotateFrame(self.durationFrame)
+  end
+end
+
+function RollTheBones.prototype:ResetRotation()
+  RollTheBones.super.prototype.ResetRotation(self)
+
+  if self.durationFrame and self.durationFrame.anim then
+    self.durationFrame.anim:Stop()
+  end
+end
+
+-- 'Protected' methods --------------------------------------------------------
+
+function RollTheBones.prototype:GetBuffDuration(unitName, ids)
+  local i = 1
+  local buff, _, type, duration, endTime, spellId
+  if IceHUD.SpellFunctionsReturnRank then
+    buff, _, _, _, type, duration, endTime, _, _, _, spellId = UnitBuff(unitName, i)
+  else
+    buff, _, _, type, duration, endTime, _, _, _, spellId = UnitBuff(unitName, i)
+  end
+
+  local realDuration, remaining, count
+  local now = GetTime()
+
+  count = 0
+  while buff do
+    if (spellId and ids[spellId]) then
+      if endTime then
+        realDuration = duration
+        remaining = endTime - now
+        count = count + 1
+      end
+    end
+
+    i = i + 1;
+
+    if IceHUD.SpellFunctionsReturnRank then
+      buff, _, _, _, type, duration, endTime, _, _, _, spellId = UnitBuff(unitName, i)
+    else
+      buff, _, _, type, duration, endTime, _, _, _, spellId = UnitBuff(unitName, i)
+    end
+
+  end
+
+  if count > 0 then
+    return realDuration, remaining, count
+  else
+    return nil, nil, 0
+  end
+end
+
+function RollTheBones.prototype:MyOnUpdate()
+  RollTheBones.super.prototype.MyOnUpdate(self)
+  if self.bUpdateRtb then
+    self:UpdateRollTheBones("internal", self.unit)
+  end
+  if self.target or self.moduleSettings.bShowWithNoTarget then
+    self:UpdateDurationBar()
+  end
+end
+
+local function RTBGetComboPoints(unit)
+  return UnitPower(unit, SPELL_POWER_COMBO_POINTS)
+end
+
+-- use this to figure out if Roll the Bones is available or not. neither IsSpellKnown nor IsPlayerSpell are correct for it
+-- when SnD is known, but this is.
+local function HasSpell(id)
+    local spell = GetSpellInfo(id)
+    return spell == GetSpellInfo(spell)
+end
+
+local function ShouldHide()
+  return not HasSpell(193316)
+end
+
+function RollTheBones.prototype:UpdateRollTheBones(event, unit)
+  if unit and unit ~= self.unit then
+    return
+  end
+
+  local now = GetTime()
+  local remaining = nil
+  local fromUpdate = event == "internal"
+
+  if not fromUpdate then
+    rtbDuration, remaining, rtbCount = self:GetBuffDuration(self.unit, RtBSet)
+
+    if not remaining then
+      rtbEndTime = 0
+    else
+      rtbEndTime = remaining + now
+    end
+  end
+
+  if rtbEndTime and rtbEndTime >= now then
+    if not fromUpdate then
+      self.bUpdateRtb = true
+    end
+
+    self:Show(true)
+    if not remaining then
+      remaining = rtbEndTime - now
+    end
+    local denominator = ((self.moduleSettings.showAsPercentOfMax and behaviorDependsOnComboPoints) and CurrMaxRtBDuration or rtbDuration)
+    self:UpdateBar(denominator ~= 0 and remaining / denominator or 0, self:GetColorName(rtbCount))
+  else
+    self:UpdateBar(0, "RollTheBones")
+
+    if RTBGetComboPoints(self.unit) == 0 or (not UnitExists("target") and not self.moduleSettings.bShowWithNoTarget) or ShouldHide() then
+      if self.bIsVisible then
+        self.bUpdateRtb = nil
+      end
+
+      if not self.moduleSettings.alwaysFullAlpha or ShouldHide() then
+        self:Show(false)
+      end
+    end
+  end
+
+  -- somewhat redundant, but we also need to check potential remaining time
+  if (remaining ~= nil) or PotentialRtBDuration > 0 then
+    local potText = behaviorDependsOnComboPoints and " (" .. PotentialRtBDuration .. ")" or ""
+    self:SetBottomText1(self.moduleSettings.upperText .. tostring(floor(remaining or 0)) .. (self.moduleSettings.durationAlpha ~= 0 and potText or ""))
+  end
+end
+
+function RollTheBones.prototype:GetColorName(count)
+  if behaviorDependsOnComboPoints and self.moduleSettings.bUseMultipleBuffColors and count >= 2 then
+    return "RollTheBones"..count
+  else
+    return "RollTheBones"
+  end
+end
+
+function RollTheBones.prototype:TargetChanged()
+  if self.moduleSettings.bShowWithNoTarget and RTBGetComboPoints(self.unit) > 0 then
+    self.target = true
+  else
+    self.target = UnitExists("target")
+  end
+  self:Update(self.unit)
+
+  self:UpdateDurationBar()
+  self:UpdateRollTheBones()
+end
+
+function RollTheBones.prototype:UpdateDurationBar(event, unit)
+  if not self.durationFrame then
+    return
+  end
+
+  if unit and unit ~= self.unit then
+    return
+  end
+
+  local points = RTBGetComboPoints(self.unit)
+  if UnitPowerMax then
+    CurrMaxRtBDuration = self:GetMaxBuffTime(UnitPowerMax(self.unit, SPELL_POWER_COMBO_POINTS))
+  else
+    -- check for Deeper Stratagem
+    local _, _, _, DeeperStratagem = GetTalentInfoByID(sixComboPointsTalentID, GetActiveSpecGroup())
+    
+    if DeeperStratagem then
+      -- first, set the cached upper limit of RtB duration
+      CurrMaxRtBDuration = self:GetMaxBuffTime(maxComboPoints + 1)
+    else
+      CurrMaxRtBDuration = self:GetMaxBuffTime(maxComboPoints)
+    end
+  end
+
+  if event then
+    self:UpdateRollTheBones()
+  end
+
+  -- player doesn't want to show the percent of max or the alpha is zeroed out, so don't bother with the duration bar
+  if not self.moduleSettings.showAsPercentOfMax or self.moduleSettings.durationAlpha == 0 or (points == 0 and not self:IsVisible())
+    or ShouldHide() then
+    self.durationFrame:Hide()
+    return
+  end
+  self.durationFrame:Show()
+
+  -- if we have combo points and a target selected, go ahead and show the bar so the duration bar can be seen
+  if points > 0 and (UnitExists("target") or self.moduleSettings.bShowWithNoTarget) then
+    self:Show(true)
+  end
+
+  if self.moduleSettings.durationAlpha > 0 then
+    PotentialRtBDuration = self:GetMaxBuffTime(points)
+
+    -- compute the scale from the current number of combo points
+    local scale = IceHUD:Clamp(PotentialRtBDuration / CurrMaxRtBDuration, 0, 1)
+
+    -- sadly, animation uses bar-local variables so we can't use the animation for 2 bar textures on the same bar element
+    if (self.moduleSettings.reverse) then
+      scale = 1 - scale
+    end
+
+    self.durationFrame.bar:SetVertexColor(self:GetColor("RollTheBonesPotential", self.moduleSettings.durationAlpha))
+    self:SetBarCoord(self.durationFrame, scale)
+  end
+
+  if rtbEndTime < GetTime() then
+    local potText = " (" .. PotentialRtBDuration .. ")"
+    self:SetBottomText1(self.moduleSettings.upperText .. "0" .. (self.moduleSettings.durationAlpha > 0 and potText or ""))
+  end
+end
+
+function RollTheBones.prototype:GetMaxBuffTime(numComboPoints)
+  local maxduration
+
+  if numComboPoints == 0 then
+    return 0
+  end
+
+  maxduration = baseTime + ((numComboPoints - 1) * gapPerComboPoint)
+
+  return maxduration
+end
+
+function RollTheBones.prototype:GetItemIdFromItemLink(linkStr)
+  local itemId
+  local _
+
+  if linkStr then
+    _, itemId, _, _, _, _, _, _, _ = strsplit(":", linkStr)
+  end
+
+  return itemId or 0
+end
+
+function RollTheBones.prototype:IsItemIdInList(itemId, list)
+  for i=1,#list do
+    if string.match(itemId, list[i]) then
+      return true
+    end
+  end
+
+  return false
+end
+
+function RollTheBones.prototype:OutCombat()
+  RollTheBones.super.prototype.OutCombat(self)
+
+  self:UpdateRollTheBones()
+end
+
+local _, unitClass = UnitClass("player")
+-- Load us up
+if unitClass == "ROGUE" and IceHUD.WowVer >= 70000 then
+  IceHUD.RollTheBones = RollTheBones:new()
+end

modules/Runes.lua

@@ -3,24 +3,33 @@ local Runes = IceCore_CreateClass(IceElement)
 
 local IceHUD = _G.IceHUD
 
+local RunesReturnedByMaxPower = IceHUD.WowVer >= 70000
+
 local CooldownFrame_SetTimer = CooldownFrame_SetTimer
-if IceHUD.WowVer >= 70000 then
+if CooldownFrame_Set then
 	CooldownFrame_SetTimer = CooldownFrame_Set
 end
 
--- blizzard cracks me up. the below block is copied verbatim from RuneFrame.lua ;)
---Readability == win
 local RUNETYPE_BLOOD = 1;
-local RUNETYPE_DEATH = 2;
-local RUNETYPE_FROST = 3;
+local RUNETYPE_DEATH = IceHUD.DeathKnightUnholyFrostRunesSwapped and 2 or 3;
+local RUNETYPE_FROST = IceHUD.DeathKnightUnholyFrostRunesSwapped and 3 or 2;
 local RUNETYPE_CHROMATIC = 4;
 local RUNETYPE_LEGION = 5; -- not real, but makes for an easy update
 
 local GetRuneType = GetRuneType
-if IceHUD.WowVer >= 70000 then
+if IceHUD.WowVer >= 70000 and IceHUD.WowVer < 70300 then
 	GetRuneType = function() return RUNETYPE_LEGION end
+elseif IceHUD.WowVer >= 70300 and GetSpecialization then
+	GetRuneType = function() return GetSpecialization() end
 end
 
+local RUNEMODE_DEFAULT = "Blizzard"
+local RUNEMODE_NUMERIC = "Numeric"
+local RUNEMODE_BAR = "Graphical Bar"
+local RUNEMODE_CIRCLE = "Graphical Circle"
+local RUNEMODE_GLOW = "Graphical Glow"
+local RUNEMODE_CLEANCIRCLE = "Graphical Clean Circle"
+
 -- setup the names to be more easily readable
 Runes.prototype.runeNames = {
 	[RUNETYPE_BLOOD] = "Blood",
@@ -34,15 +43,24 @@ Runes.prototype.runeSize = 25
 -- blizzard has hardcoded 6 runes right now, so i'll do the same...see RuneFrame.xml
 Runes.prototype.numRunes = 6
 
+Runes.prototype.lastRuneState = {}
+
+local SPELL_POWER_RUNES = SPELL_POWER_RUNES
+if Enum and Enum.PowerType then
+	SPELL_POWER_RUNES = Enum.PowerType.Runes
+end
+
 -- Constructor --
 function Runes.prototype:init()
 	Runes.super.prototype.init(self, "Runes")
 
-	if IceHUD.WowVer < 70000 then
+	if IceHUD.WowVer < 70000 or IceHUD.WowVer >= 70300 then
 		self:SetDefaultColor("Runes"..self.runeNames[RUNETYPE_BLOOD], 255, 0, 0)
 		self:SetDefaultColor("Runes"..self.runeNames[RUNETYPE_DEATH], 0, 207, 0)
 		self:SetDefaultColor("Runes"..self.runeNames[RUNETYPE_FROST], 0, 255, 255)
-		self:SetDefaultColor("Runes"..self.runeNames[RUNETYPE_CHROMATIC], 204, 26, 255)
+		if IceHUD.WowVer < 70300 then
+			self:SetDefaultColor("Runes"..self.runeNames[RUNETYPE_CHROMATIC], 204, 26, 255)
+		end
 	else
 		self:SetDefaultColor("Runes"..self.runeNames[RUNETYPE_LEGION], 204, 204, 255)
 	end
@@ -116,6 +134,9 @@ function Runes.prototype:GetOptions()
 		disabled = function()
 			return not self.moduleSettings.enabled
 		end,
+		hidden = function()
+			return not PlayerFrame_HideVehicleTexture
+		end,
 		order = 32
 	}
 
@@ -152,6 +173,9 @@ function Runes.prototype:GetOptions()
 		disabled = function()
 			return not self.moduleSettings.enabled
 		end,
+		hidden = function()
+			return self.moduleSettings.runeMode ~= RUNEMODE_DEFAULT
+		end,
 		order = 36
 	}
 
@@ -175,6 +199,42 @@ function Runes.prototype:GetOptions()
 		order = 34.1
 	}
 
+	opts["runeMode"] = {
+		type = 'select',
+		name = L["Rune display mode"],
+		desc = L["What graphical representation each rune should have. When setting to anything other than 'graphical', the module will behave more like combo points and simply show how many are active."],
+		get = function(info)
+			return IceHUD:GetSelectValue(info, self.moduleSettings.runeMode)
+		end,
+		set = function(info, v)
+			self.moduleSettings.runeMode = info.option.values[v]
+			self:ResetRuneAvailability()
+			self:Redraw()
+		end,
+		values = { RUNEMODE_DEFAULT, RUNEMODE_NUMERIC, RUNEMODE_BAR, RUNEMODE_CIRCLE, RUNEMODE_GLOW, RUNEMODE_CLEANCIRCLE },
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end,
+		order = 35.5,
+	}
+
+	opts["showWhenNotFull"] = {
+		type = 'toggle',
+		name = L["Show when not full"],
+		desc = L["Whether to show the Runes module any time the player has fewer than max runes available (regardless of combat/target status)."],
+		get = function()
+			return self.moduleSettings.showWhenNotFull
+		end,
+		set = function(info, v)
+			self.moduleSettings.showWhenNotFull = v
+			self:Redraw()
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end,
+		order = 38,
+	}
+
 	return opts
 end
 
@@ -192,7 +252,9 @@ function Runes.prototype:GetDefaultSettings()
 	defaults["alwaysFullAlpha"] = false
 	defaults["displayMode"] = "Horizontal"
 	defaults["cooldownMode"] = "Cooldown"
+	defaults["runeMode"] = RUNEMODE_DEFAULT
 	defaults["runeGap"] = 0
+	defaults["showWhenNotFull"] = false
 
 	return defaults
 end
@@ -208,22 +270,38 @@ end
 
 -- OVERRIDE
 function Runes.prototype:Enable(core)
-	if IceHUD.WowVer >= 70000 then
+	if RunesReturnedByMaxPower then
 		self.numRunes = UnitPowerMax("player", SPELL_POWER_RUNES)
 	end
 
+	for i=1,self.numRunes do
+		self.lastRuneState[i] = select(3, GetRuneCooldown(i))
+	end
+
 	Runes.super.prototype.Enable(self, core)
 
-	self:RegisterEvent("RUNE_POWER_UPDATE", "UpdateRunePower")
-	self:RegisterEvent("RUNE_TYPE_UPDATE", "UpdateRuneType")
-	self:RegisterEvent("PLAYER_ENTERING_WORLD", "ResetRuneAvailability")
-	self:RegisterEvent("UNIT_MAXPOWER", "CheckMaxNumRunes")
+	self:RegisterEvent("RUNE_POWER_UPDATE", "ResetRuneAvailability")
+	if IceHUD.WowVer < 80000 then
+		self:RegisterEvent("RUNE_TYPE_UPDATE", "UpdateRuneType")
+	end
+	if IceHUD.WowVer >= 70300 then
+		self:RegisterEvent("PLAYER_SPECIALIZATION_CHANGED", "UpdateRuneColors")
+	end
+	self:RegisterEvent("PLAYER_ENTERING_WORLD", "EnteringWorld")
+	if RunesReturnedByMaxPower then
+		self:RegisterEvent("UNIT_MAXPOWER", "CheckMaxNumRunes")
+	end
 
 	if (self.moduleSettings.hideBlizz) then
 		self:HideBlizz()
 	end
 end
 
+function Runes.prototype:EnteringWorld()
+	self:TargetChanged()
+	self:ResetRuneAvailability()
+end
+
 function Runes.prototype:Disable(core)
 	Runes.super.prototype.Disable(self, core)
 
@@ -246,44 +324,60 @@ function Runes.prototype:CheckMaxNumRunes(event, unit, powerType)
 	end
 end
 
-function Runes.prototype:ResetRuneAvailability()
+function Runes.prototype:ResetRuneAvailability(event)
 	for i=1, self.numRunes do
-		self:UpdateRunePower(nil, i, true)
+		self:UpdateRunePower(event, i, not event)
 	end
+
 	self:Redraw()
 end
 
 -- simply shows/hides the foreground rune when it becomes usable/unusable. this allows the background transparent rune to show only
 function Runes.prototype:UpdateRunePower(event, rune, dontFlash)
-	if not rune or not self.frame.graphical or #self.frame.graphical < rune then
+	if rune and (not self.frame.graphical or #self.frame.graphical < rune) then
+		return
+	end
+
+	if self.moduleSettings.runeMode == RUNEMODE_NUMERIC then
+		self.frame.numeric:SetText(tostring(self:GetNumRunesAvailable()))
 		return
 	end
 
 	local start, duration, usable = GetRuneCooldown(rune)
 
+	local lastState = self.lastRuneState[rune]
+	self.lastRuneState[rune] = usable
+
+--	if lastState == usable then
+--		return
+--	end
+
 --	print("Runes.prototype:UpdateRunePower: rune="..rune.." usable="..(usable and "yes" or "no").." GetRuneType(rune)="..GetRuneType(rune));
 
 	if usable then
-		if self.moduleSettings.cooldownMode == "Cooldown" then
-			self.frame.graphical[rune].cd:Hide()
-		elseif self.moduleSettings.cooldownMode == "Alpha" then
+		if self.moduleSettings.cooldownMode == "Alpha" or self.moduleSettings.runeMode ~= RUNEMODE_DEFAULT then
 			self.frame.graphical[rune]:SetAlpha(1)
+		elseif self.moduleSettings.cooldownMode == "Cooldown" then
+			self.frame.graphical[rune].cd:Hide()
 		elseif self.moduleSettings.cooldownMode == "Both" then
 			self.frame.graphical[rune].cd:Hide()
 			self.frame.graphical[rune]:SetAlpha(1)
 		end
 
-		if not dontFlash then
+		if not dontFlash and lastState ~= usable then
 			local fadeInfo={
 				mode = "IN",
-				timeToFade = 0.5,
-				finishedFunc = function(rune) self:ShineFinished(rune) end,
-				finishedArg1 = rune
+				timeToFade = 0.25,
+				finishedFunc = Runes.prototype.ShineFinished,
+				finishedArg1 = self,
+				finishedArg2 = rune
 			}
 			UIFrameFade(self.frame.graphical[rune].shine, fadeInfo);
 		end
 	elseif start ~= nil and duration ~= nil then
-		if self.moduleSettings.cooldownMode == "Cooldown" then
+		if self.moduleSettings.runeMode ~= RUNEMODE_DEFAULT then
+			self.frame.graphical[rune]:SetAlpha(0)
+		elseif self.moduleSettings.cooldownMode == "Cooldown" then
 			CooldownFrame_SetTimer(self.frame.graphical[rune].cd, start, duration, true)
 			self.frame.graphical[rune].cd:Show()
 		elseif self.moduleSettings.cooldownMode == "Alpha" then
@@ -296,6 +390,18 @@ function Runes.prototype:UpdateRunePower(event, rune, dontFlash)
 	end
 end
 
+function Runes.prototype:GetNumRunesAvailable()
+	local available = 0
+
+	for i=1,self.numRunes do
+		if select(3, GetRuneCooldown(i)) then
+			available = available + 1
+		end
+	end
+
+	return available
+end
+
 function Runes.prototype:ShineFinished(rune)
 	UIFrameFadeOut(self.frame.graphical[rune].shine, 0.5);
 end
@@ -318,11 +424,30 @@ function Runes.prototype:UpdateRuneType(event, rune)
 	self.frame.graphical[rune].rune:SetVertexColor(self:GetColor("Runes"..thisRuneName))
 end
 
-function Runes.prototype:GetRuneTexture(runeName)
-	if not runeName then
-		return ""
+function Runes.prototype:UpdateRuneColors()
+	for i=1,self.numRunes do
+		self:UpdateRuneType(nil, i)
 	end
-	return "Interface\\PlayerFrame\\UI-PlayerFrame-DeathKnight-"..runeName
+end
+
+function Runes.prototype:GetRuneTexture(runeName)
+	if IceHUD.WowVer >= 70300 then
+		runeName = self.runeNames[RUNETYPE_LEGION]
+	end
+
+	if self.moduleSettings.runeMode == RUNEMODE_DEFAULT and runeName then
+		return "Interface\\PlayerFrame\\UI-PlayerFrame-DeathKnight-"..runeName
+	elseif self.moduleSettings.runeMode == RUNEMODE_BAR then
+		return IceElement.TexturePath .. "Combo"
+	elseif self.moduleSettings.runeMode == RUNEMODE_CIRCLE then
+		return IceElement.TexturePath .. "ComboRound"
+	elseif self.moduleSettings.runeMode == RUNEMODE_GLOW then
+		return IceElement.TexturePath .. "ComboGlow"
+	elseif self.moduleSettings.runeMode == RUNEMODE_CLEANCIRCLE then
+		return IceElement.TexturePath .. "ComboCleanCurves"
+	end
+
+	return ""
 end
 
 -- 'Protected' methods --------------------------------------------------------
@@ -344,13 +469,19 @@ end
 
 function Runes.prototype:CreateRuneFrame()
 	-- create numeric runes
-	self.frame.numeric = self:FontFactory(self.moduleSettings.runeFontSize, nil, self.frame.numeric)
+	if not self.frame.numeric then
+		self.frame.numeric = self:FontFactory(self.moduleSettings.runeFontSize, self.frame)
+	end
 
 	self.frame.numeric:SetWidth(50)
 	self.frame.numeric:SetJustifyH("CENTER")
 
 	self.frame.numeric:SetPoint("TOP", self.frame, "TOP", 0, 0)
-	self.frame.numeric:Hide()
+	if self.moduleSettings.runeMode == RUNEMODE_NUMERIC then
+		self.frame.numeric:Show()
+	else
+		self.frame.numeric:Hide()
+	end
 
 	if (not self.frame.graphical) then
 		self.frame.graphical = {}
@@ -379,7 +510,7 @@ function Runes.prototype:CreateRune(i, type, name)
 	-- create runes
 	if (not self.frame.graphical[i]) then
 		self.frame.graphical[i] = CreateFrame("Frame", nil, self.frame)
-		self.frame.graphical[i].rune = self.frame.graphical[i]:CreateTexture(nil, "LOW")
+		self.frame.graphical[i].rune = self.frame.graphical[i]:CreateTexture(nil, "BACKGROUND")
 		self.frame.graphical[i].rune:SetAllPoints(self.frame.graphical[i])
 		self.frame.graphical[i].cd = CreateFrame("Cooldown", nil, self.frame.graphical[i], "CooldownFrameTemplate")
 		self.frame.graphical[i].shine = self.frame.graphical[i]:CreateTexture(nil, "OVERLAY")
@@ -409,7 +540,11 @@ function Runes.prototype:CreateRune(i, type, name)
 	local runeTex = self:GetRuneTexture(name)
 	self.frame.graphical[i].rune:SetTexture(runeTex)
 	self.frame.graphical[i].rune:SetVertexColor(self:GetColor("Runes"..name))
-	self.frame.graphical[i]:Show()
+	if self.moduleSettings.runeMode ~= RUNEMODE_NUMERIC then
+		self.frame.graphical[i]:Show()
+	else
+		self.frame.graphical[i]:Hide()
+	end
 
 	self.frame.graphical[i].cd:SetFrameStrata("BACKGROUND")
 	self.frame.graphical[i].cd:SetFrameLevel(self.frame.graphical[i]:GetFrameLevel()+1)
@@ -436,13 +571,7 @@ function Runes.prototype:ShowBlizz()
 	RuneFrame:Show()
 
 	RuneFrame:GetScript("OnLoad")(RuneFrame)
-	RuneFrame:GetScript("OnEvent")(frame, "PLAYER_ENTERING_WORLD")
-	for i=1, self.numRunes do
-		local frame = _G["RuneButtonIndividual"..i]
-		if frame then
-			frame:GetScript("OnLoad")(frame)
-		end
-	end
+	RuneFrame:GetScript("OnEvent")(RuneFrame, "PLAYER_ENTERING_WORLD")
 end
 
 local function hook_playerframe()
@@ -455,6 +584,10 @@ local function hook_playerframe()
 end
 
 function Runes.prototype:HideBlizz()
+	if not PlayerFrame_HideVehicleTexture then
+		return
+	end
+
 	RuneFrame:Hide()
 	RuneFrame:UnregisterAllEvents()
 
@@ -485,6 +618,14 @@ function Runes.prototype:CheckCombat()
 	self:Redraw()
 end
 
+function Runes.prototype:UseTargetAlpha(scale)
+	if not self.moduleSettings.showWhenNotFull then
+		return Runes.super.prototype.UseTargetAlpha(scale)
+	else
+		return self:GetNumRunesAvailable() ~= self.numRunes
+	end
+end
+
 -- Load us up
 local _, unitClass = UnitClass("player")
 if (unitClass == "DEATHKNIGHT") then

modules/Shards.lua

@@ -3,14 +3,26 @@ local ShardCounter = IceCore_CreateClass(IceClassPowerCounter)
 
 local CurrentSpec = nil
 
-local AfflictionCoords =
-{
-	{0.01562500, 0.28125000, 0.00781250, 0.13281250},
-	{0.01562500, 0.28125000, 0.00781250, 0.13281250},
-	{0.01562500, 0.28125000, 0.00781250, 0.13281250},
-	{0.01562500, 0.28125000, 0.00781250, 0.13281250},
-	{0.01562500, 0.28125000, 0.00781250, 0.13281250},
-}
+local AfflictionCoords
+if IceHUD.WowVer < 70200 then
+	AfflictionCoords =
+	{
+		{0.01562500, 0.28125000, 0.00781250, 0.13281250},
+		{0.01562500, 0.28125000, 0.00781250, 0.13281250},
+		{0.01562500, 0.28125000, 0.00781250, 0.13281250},
+		{0.01562500, 0.28125000, 0.00781250, 0.13281250},
+		{0.01562500, 0.28125000, 0.00781250, 0.13281250},
+	}
+else
+	AfflictionCoords =
+	{
+		{0, 1, 0, 1},
+		{0, 1, 0, 1},
+		{0, 1, 0, 1},
+		{0, 1, 0, 1},
+		{0, 1, 0, 1},
+	}
+end
 
 local DestructionCoords =
 {
@@ -25,6 +37,11 @@ local DemonologyCoords =
 	{0.03906250, 0.55468750, 0.10546875, 0.19921875},
 }
 
+local SPELL_POWER_SOUL_SHARDS = SPELL_POWER_SOUL_SHARDS
+if Enum and Enum.PowerType then
+	SPELL_POWER_SOUL_SHARDS = Enum.PowerType.SoulShards
+end
+
 function ShardCounter.prototype:init()
 	ShardCounter.super.prototype.init(self, "Warlock Power")
 
@@ -36,6 +53,10 @@ function ShardCounter.prototype:init()
 	if IceHUD.WowVer >= 70000 then
 		self.runeHeight = 23
 		self.runeWidth = 26
+		if IceHUD.WowVer >= 70200 then
+			self.runeHeight = 27
+			self.runeWidth = 22
+		end
 		self.runeCoords = AfflictionCoords
 		self.unitPower = SPELL_POWER_SOUL_SHARDS
 		self.unit = "player"
@@ -45,6 +66,16 @@ end
 function ShardCounter.prototype:Enable(core)
 	if IceHUD.WowVer >= 70000 then
 		self.numRunes = UnitPowerMax(self.unit, self.unitPower)
+
+		if IceHUD.WowVer >= 80000 or GetSpecialization() == SPEC_WARLOCK_DESTRUCTION then
+			self.shouldShowUnmodified = true
+			self.numericFormat = "%.1f"
+			self.round = floor
+		else
+			self.shouldShowUnmodified = nil
+			self.numericFormat = nil
+			self.round = nil
+		end
 	end
 
 	ShardCounter.super.prototype.Enable(self, core)
@@ -76,6 +107,7 @@ function ShardCounter.prototype:UpdateRunePower(event, arg1, arg2)
 	end
 
 	if event == "PLAYER_ENTERING_WORLD" and IceHUD.WowVer < 70000 then
+		self:TargetChanged()
 		self:UpdatePowerType(event)
 	end
 
@@ -90,10 +122,10 @@ function ShardCounter.prototype:CheckGreenFire()
 end
 
 function ShardCounter.prototype:UpdatePowerType(event)
-	if IceHUD.WowVer >= 50000 then
+	if IceHUD.WowVer >= 50000 and IceHUD.WowVer < 80000 then
 		CurrentSpec = GetSpecialization()
 	else
-		-- all warlocks use shards in pre-5.0, so just act like our spec is affliction
+		-- all warlocks use shards in pre-5.0/post-8.0, so just act like our spec is affliction
 		CurrentSpec = SPEC_WARLOCK_AFFLICTION
 	end
 
@@ -205,6 +237,10 @@ function ShardCounter.prototype:GetDefaultSettings()
 end
 
 function ShardCounter.prototype:GetRuneTexture(rune)
+	if IceHUD.WowVer >= 70200 then
+		return nil
+	end
+
 	if not rune or rune ~= tonumber(rune) then
 		return
 	end
@@ -222,6 +258,10 @@ function ShardCounter.prototype:GetRuneTexture(rune)
 	return "Interface\\PlayerFrame\\UI-WarlockShard"
 end
 
+function ShardCounter.prototype:GetRuneAtlas(rune)
+	return "Warlock-ReadyShard"
+end
+
 function ShardCounter.prototype:ShowBlizz()
 	WarlockPowerFrame:Show()
 
@@ -236,6 +276,6 @@ end
 
 -- Load us up
 local _, unitClass = UnitClass("player")
-if (unitClass == "WARLOCK" and IceHUD.WowVer >= 40000) then
+if (unitClass == "WARLOCK" and WarlockPowerFrame) then
 	IceHUD.ShardCounter = ShardCounter:new()
 end

modules/SliceAndDice.lua

@@ -20,14 +20,38 @@ local impSndBonusPerRank = 0.25
 local maxComboPoints = 5
 local sndEndTime = 0
 local sndDuration = 0
+local sixComboPointsTalentID = 19240
 
 local CurrMaxSnDDuration = 0
 local PotentialSnDDuration = 0
 
+local sndBuffName = 132306
+if IceHUD.WowMain and IceHUD.WowVer < 80000 then
+	sndBuffName = "Ability_Rogue_SliceDice"
+end
+
 if IceHUD.WowVer >= 50000 then
 	baseTime = 12
 	gapPerComboPoint = 6
 end
+if IceHUD.WowClassic then
+	impSndBonusPerRank = 0.15
+	impSndTalentPage = 1
+	impSndTalentIdx = 6
+elseif IceHUD.WowClassicBC then
+	impSndBonusPerRank = 0.15
+	impSndTalentPage = 2
+	impSndTalentIdx = 4
+elseif IceHUD.WowClassicWrath then
+	impSndBonusPerRank = 0.25
+	impSndTalentPage = 2
+	impSndTalentIdx = 23
+end
+
+local SPELL_POWER_COMBO_POINTS = SPELL_POWER_COMBO_POINTS
+if Enum and Enum.PowerType then
+	SPELL_POWER_COMBO_POINTS = Enum.PowerType.ComboPoints
+end
 
 -- Constructor --
 function SliceAndDice.prototype:init()
@@ -50,10 +74,19 @@ function SliceAndDice.prototype:Enable(core)
 	SliceAndDice.super.prototype.Enable(self, core)
 
 	self:RegisterEvent("UNIT_AURA", "UpdateSliceAndDice")
-	if IceHUD.WowVer < 70000 then
+	if IceHUD.EventExistsUnitComboPoints then
 		self:RegisterEvent("UNIT_COMBO_POINTS", "ComboPointsChanged")
 	else
-		self:RegisterEvent("UNIT_POWER", "ComboPointsChanged")
+		self:RegisterEvent(IceHUD.UnitPowerEvent, "ComboPointsChanged")
+	end
+
+	if IceHUD.WowVer >= 70000 then
+		self:RegisterEvent("PLAYER_TALENT_UPDATE", "CheckMaxComboPoints")
+		self:CheckMaxComboPoints()
+	end
+
+	if IceHUD.EventExistsUnitMaxPower then
+		self:RegisterEvent("UNIT_MAXPOWER", "CheckMaxComboPoints")
 	end
 
 	if not self.moduleSettings.alwaysFullAlpha then
@@ -65,12 +98,21 @@ function SliceAndDice.prototype:Enable(core)
 	self:SetBottomText1("")
 end
 
+function SliceAndDice.prototype:CheckMaxComboPoints()
+	if UnitPowerMax then
+		maxComboPoints = UnitPowerMax(self.unit, SPELL_POWER_COMBO_POINTS)
+	else
+		local talentID, name, texture, selected, available, spellID, unknown, row, column, known, grantedByAura = GetTalentInfoByID(sixComboPointsTalentID, GetActiveSpecGroup())
+		maxComboPoints = selected and 6 or 5
+	end
+end
+
 function SliceAndDice.prototype:Disable(core)
 	SliceAndDice.super.prototype.Disable(self, core)
 end
 
 function SliceAndDice.prototype:ComboPointsChanged(...)
-	if select('#', ...) >= 3 and select(1, ...) == "UNIT_POWER" and select(3, ...) ~= "COMBO_POINTS" then
+	if select('#', ...) >= 3 and select(1, ...) == IceHUD.UnitPowerEvent and select(3, ...) ~= "COMBO_POINTS" then
 		return
 	end
 
@@ -172,7 +214,7 @@ function SliceAndDice.prototype:CreateFrame()
 end
 
 function SliceAndDice.prototype:CreateDurationBar()
-	self.durationFrame = self:BarFactory(self.durationFrame, "BACKGROUND","ARTWORK")
+	self.durationFrame = self:BarFactory(self.durationFrame, "BACKGROUND","ARTWORK", "Duration")
 
 	-- Rokiyo: Do we need to call this here?
 	self.CurrScale = 0
@@ -196,7 +238,7 @@ end
 function SliceAndDice.prototype:ResetRotation()
 	SliceAndDice.super.prototype.ResetRotation(self)
 
-	if self.durationFrame.anim then
+	if self.durationFrame and self.durationFrame.anim then
 		self.durationFrame.anim:Stop()
 	end
 end
@@ -205,15 +247,15 @@ end
 
 function SliceAndDice.prototype:GetBuffDuration(unitName, buffName)
 	local i = 1
-	local buff, rank, texture, count, type, duration, endTime, remaining
-	if IceHUD.WowVer >= 30000 then
-		buff, rank, texture, count, type, duration, endTime = UnitBuff(unitName, i)
+	local buff, _, texture, duration, endTime, remaining
+	if IceHUD.SpellFunctionsReturnRank then
+		buff, _, texture, _, _, duration, endTime = UnitBuff(unitName, i)
 	else
-		buff, rank, texture, count, duration, remaining = UnitBuff(unitName, i)
+		buff, texture, _, _, duration, endTime = UnitBuff(unitName, i)
 	end
 
 	while buff do
-		if (texture and string.match(texture, buffName)) then
+		if (texture and (type(buffName) == 'string' and string.match(texture, buffName) or texture == buffName)) then
 			if endTime and not remaining then
 				remaining = endTime - GetTime()
 			end
@@ -222,10 +264,10 @@ function SliceAndDice.prototype:GetBuffDuration(unitName, buffName)
 
 		i = i + 1;
 
-		if IceHUD.WowVer >= 30000 then
-			buff, rank, texture, count, type, duration, endTime = UnitBuff(unitName, i)
+		if IceHUD.SpellFunctionsReturnRank then
+			buff, _, texture, _, _, duration, endTime = UnitBuff(unitName, i)
 		else
-			buff, rank, texture, count, duration, remaining = UnitBuff(unitName, i)
+			buff, texture, _, _, duration, endTime = UnitBuff(unitName, i)
 		end
 	end
 
@@ -235,7 +277,7 @@ end
 function SliceAndDice.prototype:MyOnUpdate()
 	SliceAndDice.super.prototype.MyOnUpdate(self)
 	if self.bUpdateSnd then
-		self:UpdateSliceAndDice(nil, self.unit, true)
+		self:UpdateSliceAndDice("internal", self.unit)
 	end
 	if self.target or self.moduleSettings.bShowWithNoTarget then
 		self:UpdateDurationBar()
@@ -243,10 +285,10 @@ function SliceAndDice.prototype:MyOnUpdate()
 end
 
 local function SNDGetComboPoints(unit)
-	if IceHUD.WowVer >= 60000 then
-		return UnitPower(unit, SPELL_POWER_COMBO_POINTS)
-	elseif IceHUD.WowVer >= 30000 then
+	if IceHUD.PerTargetComboPoints then
 		return GetComboPoints(unit, "target")
+	elseif IceHUD.WowVer >= 60000 then
+		return UnitPower(unit, SPELL_POWER_COMBO_POINTS)
 	else
 		return GetComboPoints()
 	end
@@ -260,22 +302,27 @@ local function HasSpell(id)
 end
 
 local function ShouldHide()
+	if IceHUD.WowVer >= 90000 or IceHUD.WowClassicBC or IceHUD.WowClassicWrath then
+		return false
+	end
+
 	return --[[(IceHUD.WowVer < 70000 or not IsSpellKnown(193316)) and]] not IsPlayerSpell(5171) -- IsSpellKnown returns incorrect info for SnD in 7.0
 	-- commented code is here in case we decide we'd like to use this module for Roll the Bones.
 	-- if we do, though, the "active" check gets way more complicated since it can activate any number of 6 different abilities
 	-- with different durations
 end
 
-function SliceAndDice.prototype:UpdateSliceAndDice(event, unit, fromUpdate)
+function SliceAndDice.prototype:UpdateSliceAndDice(event, unit)
 	if unit and unit ~= self.unit then
 		return
 	end
 
 	local now = GetTime()
 	local remaining = nil
+	local fromUpdate = event == "internal"
 
 	if not fromUpdate or IceHUD.WowVer < 30000 then
-		sndDuration, remaining = self:GetBuffDuration(self.unit, "Ability_Rogue_SliceDice")
+		sndDuration, remaining = self:GetBuffDuration(self.unit, sndBuffName)
 
 		if not remaining then
 			sndEndTime = 0
@@ -377,13 +424,11 @@ function SliceAndDice.prototype:UpdateDurationBar(event, unit)
 end
 
 function SliceAndDice.prototype:GetMaxBuffTime(numComboPoints)
-	local maxduration
-
 	if numComboPoints == 0 then
 		return 0
 	end
 
-	maxduration = baseTime + ((numComboPoints - 1) * gapPerComboPoint)
+	local maxduration = baseTime + ((numComboPoints - 1) * gapPerComboPoint)
 
 	if self:HasNetherbladeBonus() then
 		maxduration = maxduration + netherbladeBonus
@@ -399,8 +444,10 @@ function SliceAndDice.prototype:GetMaxBuffTime(numComboPoints)
 		end
 
 		local rank = 0
-		local _
-		_, _, _, _, rank = GetTalentInfo(impSndTalentPage, impSndTalentIdx)
+		if GetTalentInfo then
+			local _
+			_, _, _, _, rank = GetTalentInfo(impSndTalentPage, impSndTalentIdx)
+		end
 
 		maxduration = maxduration * (1 + (rank * impSndBonusPerRank))
 	end
@@ -461,6 +508,9 @@ function SliceAndDice.prototype:HasNineTailedBonus()
 end
 
 function SliceAndDice.prototype:HasGlyphBonus()
+	if not GetNumGlyphSockets then
+		return false
+	end
 	for i=1,GetNumGlyphSockets() do
 		local enabled, _, _, spell = GetGlyphSocketInfo(i)
 

modules/Stagger.lua

@@ -13,6 +13,7 @@ local ModerateID = 124274
 local HeavyID = 124273
 local StaggerID = 124255
 local staggerNames = {"", "", ""}
+local staggerIds = {LightID, ModerateID, HeavyID}
 
 local MinLevel = 10
 
@@ -71,7 +72,7 @@ function StaggerBar.prototype:GetOptions()
 		name = "Max Percent",
 		desc = "Maximum percentage of your maximum health for the Stagger bar to represent. I.e, if set to 20%, the bar will be full when the Stagger damage over time effect is dealing 20% of your maximum health per second.",
 		min = 0,
-		max = 50,
+		max = 100,
 		step = 1,
 		get = function()
 			return self.moduleSettings.maxPercent
@@ -136,7 +137,7 @@ function StaggerBar.prototype:CreateFrame()
 end
 
 function StaggerBar.prototype:CreateTimerBar()
-	self.timerFrame = self:BarFactory(self.timerFrame, "MEDIUM","ARTWORK")
+	self.timerFrame = self:BarFactory(self.timerFrame, "MEDIUM","ARTWORK", "Timer")
 
 	self.CurrScale = 0
 
@@ -156,6 +157,7 @@ function StaggerBar.prototype:UpdateShown()
 end
 
 function StaggerBar.prototype:PLAYER_ENTERING_WORLD()
+	self:TargetChanged()
 	self:UpdateStaggerBar()
 end
 
@@ -165,7 +167,7 @@ end
 
 function StaggerBar.prototype:GetDebuffInfo()
 	if IceHUD.WowVer >= 70000 then
-		self.amount = UnitStagger(self.unit)
+		self.amount = UnitStagger(self.unit) or 0
 		self.staggerLevel = 1
 
 		local healthMax = UnitHealthMax(self.unit)
@@ -183,13 +185,13 @@ function StaggerBar.prototype:GetDebuffInfo()
 	local staggerLevel = 1
 
 	for i = 1, IceCore.BuffLimit do
-		local debuffID = select(11, UnitDebuff(self.unit, i))
+		local debuffID = select(IceHUD.SpellFunctionsReturnRank and 11 or 10, UnitDebuff(self.unit, i))
 
 		if debuffID == LightID or debuffID == ModerateID or debuffID == HeavyID then
-			local spellName = select(1, UnitDebuff(self.unit, i))
+			local spellName = UnitDebuff(self.unit, i)
 
-			duration = select(6, UnitAura(self.unit, spellName, "", "HARMFUL"))
-			amount = select(15, UnitAura(self.unit, spellName, "", "HARMFUL"))
+			duration = select(IceHUD.SpellFunctionsReturnRank and 6 or 5, UnitAura(self.unit, spellName, "", "HARMFUL"))
+			amount = select(IceHUD.SpellFunctionsReturnRank and 15 or 14, UnitAura(self.unit, spellName, "", "HARMFUL"))
 			staggerLevel = (debuffID == LightID) and 1 or (debuffID == ModerateID) and 2 or 3
 
 			break
@@ -201,9 +203,14 @@ function StaggerBar.prototype:GetDebuffInfo()
 	self.staggerLevel = staggerLevel or 1
 end
 
-function StaggerBar.prototype:COMBAT_LOG_EVENT_UNFILTERED(_, timestamp, event, hideCaster, sourceGUID, sourceName, sourceFlags, sourceFlags2, destGUID, destName, destFlags, destFlags2, spellID)
-	if destName == playerName then
-		if spellID == StaggerID or event == "SWING_DAMAGE" or event == "SPELL_AURA_APPLIED" or event == "SPELL_AURA_REMOVED" then
+function StaggerBar.prototype:COMBAT_LOG_EVENT_UNFILTERED(...)
+	local eventArgs = {...}
+    if (CombatLogGetCurrentEventInfo) then
+        eventArgs = {CombatLogGetCurrentEventInfo()}
+    end
+
+	if eventArgs[9] == playerName then
+		if eventArgs[12] == StaggerID or eventArgs[2] == "SWING_DAMAGE" or eventArgs[2] == "SPELL_AURA_APPLIED" or eventArgs[2] == "SPELL_AURA_REMOVED" then
 			self:UpdateStaggerBar()
 		end
 	end
@@ -216,7 +223,7 @@ function StaggerBar.prototype:UpdateStaggerBar()
 	local maxHealth = UnitHealthMax(self.unit)
 	local scale = IceHUD:Clamp((self.amount / maxHealth) * (100 / self.moduleSettings.maxPercent), 0, 1)
 
-	if self.amount > 0 and (IceHUD.WowVer >= 7000 or self.duration <= 10) then
+	if self.amount > 0 and (IceHUD.WowVer >= 70000 or self.duration <= 10) then
 		-- self.timerFrame.bar:SetVertexColor(self:GetColor("StaggerTime", self.moduleSettings.timerAlpha))
 		self:UpdateBar(scale or 0, "Stagger"..self.staggerLevel)
 		self:UpdateShown()
@@ -227,8 +234,20 @@ function StaggerBar.prototype:UpdateStaggerBar()
 	end
 end
 
-function StaggerBar.prototype:GetDebuffDuration(unitName, buffName)
-	local name, _, _, _, _, duration, endTime = UnitDebuff(unitName, buffName)
+function StaggerBar.prototype:GetDebuffDuration(unitName, buffId)
+	local name, _, duration, endTime
+	if IceHUD.SpellFunctionsReturnRank then
+		name, _, _, _, _, duration, endTime = UnitDebuff(unitName, buffName)
+	else
+		for i = 1, IceCore.BuffLimit do
+			local id
+			name, _, _, _, duration, endTime, _, _, _, id = UnitDebuff(unitName, i)
+
+			if id == buffId then
+				break
+			end
+		end
+	end
 
 	if name then
 		return duration, endTime - GetTime()
@@ -255,7 +274,7 @@ function StaggerBar.prototype:UpdateTimerFrame(event, unit, fromUpdate)
 
 	if not fromUpdate then
 		for i = 1, 3 do
-			self.StaggerDuration, remaining = self:GetDebuffDuration(self.unit, staggerNames[i])
+			self.StaggerDuration, remaining = self:GetDebuffDuration(self.unit, staggerIds[i])
 
 			if remaining then
 				break

modules/TargetAbsorb.lua

@@ -4,13 +4,8 @@ IceTargetAbsorb.prototype.highestAbsorbSinceLastZero = 0
 IceTargetAbsorb.prototype.ColorName = "TargetAbsorb"
 
 local UnitGetTotalAbsorbs = UnitGetTotalAbsorbs
-if IceHUD.WowVer < 50200 then
-	UnitGetTotalAbsorbs = nil
-end
 
--- Constructor --
 function IceTargetAbsorb.prototype:init(moduleName, unit, colorName)
-	-- not sure if this is necessary...i think it is...this way, we can instantiate this bar on its own or as a parent class
 	if moduleName == nil or unit == nil then
 		IceTargetAbsorb.super.prototype.init(self, "TargetAbsorb", "target")
 	else
@@ -29,50 +24,61 @@ function IceTargetAbsorb.prototype:GetDefaultSettings()
 
 	settings["side"] = IceCore.Side.Right
 	settings["offset"] = 3
-	settings["upperText"] = "[TotalAbsorb]"
+	settings["upperText"] = "[TotalAbsorb:VeryShort]"
 
 	return settings
 end
 
--- OVERRIDE
 function IceTargetAbsorb.prototype:Enable(core)
 	IceTargetAbsorb.super.prototype.Enable(self, core)
 
 	self:RegisterEvent("UNIT_ABSORB_AMOUNT_CHANGED", "UpdateAbsorbAmount")
 	self:MyRegisterCustomEvents()
 
-	self:UpdateAbsorbAmount("UNIT_ABSORB_AMOUNT_CHANGED", self.unit)
+	self:UpdateAbsorbAmount()
 
 	self:Show(false)
 end
 
 function IceTargetAbsorb.prototype:MyRegisterCustomEvents()
-	self:RegisterEvent("PLAYER_TARGET_CHANGED", "UpdateAbsorbAmount")
 end
 
 function IceTargetAbsorb.prototype:MyUnregisterCustomEvents()
-	self:UnregisterEvent("PLAYER_TARGET_CHANGED")
+end
+
+function IceTargetAbsorb.prototype:Update()
+	self:UpdateAbsorbAmount()
 end
 
 function IceTargetAbsorb.prototype:UpdateAbsorbAmount(event, unit)
-	if UnitGetTotalAbsorbs == nil or (event == "UNIT_ABSORB_AMOUNT_CHANGED" and unit ~= self.unit) then
+	if event == "UNIT_ABSORB_AMOUNT_CHANGED" and unit ~= self.unit then
 		return
 	end
 
-	local absorbAmount = UnitGetTotalAbsorbs(self.unit)
+	local absorbAmount = UnitGetTotalAbsorbs(self.unit) or 0
 
-	if absorbAmount == nil or absorbAmount <= 0 then
+	if absorbAmount <= 0 then
 		self.highestAbsorbSinceLastZero = 0
 	elseif absorbAmount > self.highestAbsorbSinceLastZero then
 		self.highestAbsorbSinceLastZero = absorbAmount
 	end
 
-	if absorbAmount == nil or absorbAmount <= 0 or self.highestAbsorbSinceLastZero <= 0 then
+	self.absorbPercent = self.highestAbsorbSinceLastZero ~= 0 and absorbAmount / self.highestAbsorbSinceLastZero or 0
+
+	if absorbAmount <= 0 or self.highestAbsorbSinceLastZero <= 0 then
 		self:Show(false)
 	else
 		self:Show(true)
 		self:UpdateBar(absorbAmount / self.highestAbsorbSinceLastZero, self.ColorName)
 	end
+
+	if not IceHUD.IceCore:ShouldUseDogTags() and self.frame:IsVisible() then
+		if (self.PlayerAltManaMax ~= 100) then
+			self:SetBottomText1(self:GetFormattedText(self:Round(absorbAmount)), self.ColorName)
+		else
+			self:SetBottomText1()
+		end
+	end
 end
 
 function IceTargetAbsorb.prototype:Disable(core)
@@ -82,4 +88,6 @@ function IceTargetAbsorb.prototype:Disable(core)
 	self:MyUnregisterCustomEvents()
 end
 
-IceHUD.TargetAbsorb = IceTargetAbsorb:new()
+if UnitGetTotalAbsorbs ~= nil then
+	IceHUD.TargetAbsorb = IceTargetAbsorb:new()
+end

modules/TargetCC.lua

@@ -7,7 +7,7 @@ TargetCC.prototype.debuffRemaining = 0
 TargetCC.prototype.debuffDuration = 0
 
 local GetNumPartyMembers, GetNumRaidMembers = GetNumPartyMembers, GetNumRaidMembers
-if IceHUD.WowVer >= 50000 then
+if GetNumGroupMembers then
 	GetNumPartyMembers = GetNumGroupMembers
 	GetNumRaidMembers = GetNumGroupMembers
 end
@@ -35,9 +35,9 @@ local StunCCList = {
 	-- bash
 	5211,
 	-- Maim
-	22570,
-	-- pounce
-	9005,
+	203123,
+	-- Rake
+	163505,
 	-- war stomp
 	20549,
 	-- deep freeze
@@ -53,6 +53,8 @@ local StunCCList = {
     105593,
     -- Remorseless Winter
     115001,
+    -- Between the Eyes
+    199804,
 }
 
 local IncapacitateCCList = {
@@ -78,6 +80,14 @@ local IncapacitateCCList = {
 	28271,
 	-- Polymorph: Penguin
 	59634,
+	-- Polymorph: Monkey
+	161354,
+	-- Polymorph: Polar Bear Cub
+	120137,
+	-- Polymorph: Porcupine
+	120140,
+	-- Polymorph: Direhorn
+	162625,
 	-- Hibernate
 	2637,
 	-- Freezing Trap Effect
@@ -103,6 +113,8 @@ local IncapacitateCCList = {
 local FearCCList = {
 	-- Psychic Scream
 	8122,
+	-- Fear (Retail)
+	118699,
 	-- Fear
 	5782,
 	-- Howl of Terror
@@ -113,6 +125,16 @@ local FearCCList = {
 	5246,
 	-- Hex
 	51514,
+	-- Hex: Compy
+	210873,
+	-- Hex: Wicker Mongrel
+	277784,
+	-- Hex: Zandalari Tendonripper
+	277778,
+	-- Hex: Spider
+	211004,
+	-- Hex: Skeletal Hatchling
+	269352,
 	-- Scare Beast
 	1513,
 }
@@ -315,7 +337,12 @@ end
 
 function TargetCC.prototype:GetMaxDebuffDuration(unitName, debuffNames)
 	local i = 1
-	local debuff, rank, texture, count, debuffType, duration, endTime, unitCaster, _, _, spellId = UnitAura(unitName, i, "HARMFUL")
+	local debuff, rank, texture, count, debuffType, duration, endTime, unitCaster, _, _, spellId
+	if IceHUD.SpellFunctionsReturnRank then
+		debuff, rank, texture, count, debuffType, duration, endTime, unitCaster, _, _, spellId = UnitAura(unitName, i, "HARMFUL")
+	else
+		debuff, texture, count, debuffType, duration, endTime, unitCaster, _, _, spellId = UnitAura(unitName, i, "HARMFUL")
+	end
 	local isMine = unitCaster == "player"
 	local result = {nil, nil, nil}
 	local remaining
@@ -335,7 +362,11 @@ function TargetCC.prototype:GetMaxDebuffDuration(unitName, debuffNames)
 
 		i = i + 1;
 
-		debuff, rank, texture, count, debuffType, duration, endTime, unitCaster, _, _, spellId = UnitAura(unitName, i, "HARMFUL")
+		if IceHUD.SpellFunctionsReturnRank then
+			debuff, rank, texture, count, debuffType, duration, endTime, unitCaster, _, _, spellId = UnitAura(unitName, i, "HARMFUL")
+		else
+			debuff, texture, count, debuffType, duration, endTime, unitCaster, _, _, spellId = UnitAura(unitName, i, "HARMFUL")
+		end
 		isMine = unitCaster == "player"
 	end
 
@@ -344,11 +375,12 @@ end
 
 function TargetCC.prototype:MyOnUpdate()
 	TargetCC.super.prototype.MyOnUpdate(self)
-	self:UpdateTargetDebuffs(nil, self.unit, true)
+	self:UpdateTargetDebuffs("internal", self.unit)
 end
 
-function TargetCC.prototype:UpdateTargetDebuffs(event, unit, isUpdate)
+function TargetCC.prototype:UpdateTargetDebuffs(event, unit)
 	local name, duration, remaining
+	local isUpdate = event == "internal"
 
 	if not isUpdate or not self.lastUpdateTime then
 		self.debuffName, self.debuffDuration, self.debuffRemaining = self:GetMaxDebuffDuration(self.unit, self.debuffList)

modules/TargetCast.lua

@@ -15,8 +15,10 @@ end
 function TargetCast.prototype:Enable(core)
 	TargetCast.super.prototype.Enable(self, core)
 
-	self:RegisterEvent("UNIT_SPELLCAST_INTERRUPTIBLE", "SpellCastInterruptible")
-	self:RegisterEvent("UNIT_SPELLCAST_NOT_INTERRUPTIBLE", "SpellCastNotInterruptible")
+	if IceHUD.EventExistsSpellcastInterruptible then
+		self:RegisterEvent("UNIT_SPELLCAST_INTERRUPTIBLE", "SpellCastInterruptible")
+		self:RegisterEvent("UNIT_SPELLCAST_NOT_INTERRUPTIBLE", "SpellCastNotInterruptible")
+	end
 end
 
 
@@ -63,7 +65,12 @@ function TargetCast.prototype:GetDefaultSettings()
 	settings["side"] = IceCore.Side.Right
 	settings["offset"] = 3
 	settings["flashInstants"] = "Never"
-	settings["flashFailures"] = "Never"
+	-- Fulzamoth 2019-09-27 : let the flash handler work if in Classic and LibClassicCasterino exists
+	if LibClassicCasterino then
+		settings["flashFailures"] = ""
+	else
+		settings["flashFailures"] = "Never"
+	end 
 	settings["shouldAnimate"] = false
 	settings["hideAnimationSettings"] = true
 	settings["usesDogTagStrings"] = false
@@ -82,18 +89,24 @@ function TargetCast.prototype:TargetChanged(unit)
 		return
 	end
 
-	local spell, _, _, _, _, _, _, _, notInterruptibleCast = UnitCastingInfo(self.unit)
-	if (spell) then
-		self.notInterruptible = notInterruptibleCast
-		self:StartBar(IceCastBar.Actions.Cast)
-		return
+	if UnitCastingInfo then
+		local spell = UnitCastingInfo(self.unit)
+		local notInterruptible = select(IceHUD.SpellFunctionsReturnRank and 9 or 8, UnitCastingInfo(self.unit))
+		if spell then
+			self.notInterruptible = notInterruptibleCast
+			self:StartBar(IceCastBar.Actions.Cast)
+			return
+		end
 	end
 
-	local channel, _, _, _, _, _, _, notInterruptibleChannel = UnitChannelInfo(self.unit)
-	if (channel) then
-		self.notInterruptible = notInterruptibleChannel
-		self:StartBar(IceCastBar.Actions.Channel)
-		return
+	if UnitChannelInfo then
+		local channel = UnitChannelInfo(self.unit)
+		notInterruptible = select(IceHUD.SpellFunctionsReturnRank and 8 or 7, UnitChannelInfo(self.unit))
+		if channel then
+			self.notInterruptible = notInterruptibleChannel
+			self:StartBar(IceCastBar.Actions.Channel)
+			return
+		end
 	end
 
 	self:StopBar()
@@ -167,13 +180,18 @@ function TargetCast.prototype:GetOptions()
 end
 
 function TargetCast.prototype:StartBar(action, message)
-	local spell, rank, displayName, icon, startTime, endTime, isTradeSkill, castId, notInterruptible = UnitCastingInfo(self.unit)
-	if not (spell) then
-		spell, rank, displayName, icon, startTime, endTime, isTradeSkill, notInterruptible = UnitChannelInfo(self.unit)
+	local spell, notInterruptible
+	if UnitCastingInfo then
+		spell = UnitCastingInfo(self.unit)
+		notInterruptible = select(IceHUD.SpellFunctionsReturnRank and 9 or 8, UnitCastingInfo(self.unit))
 	end
+	if UnitChannelInfo and not spell then
+		spell = UnitChannelInfo(self.unit)
+		notInterruptible = select(IceHUD.SpellFunctionsReturnRank and 8 or 7, UnitChannelInfo(self.unit))
 
-	if not spell then
-		return
+		if not spell then
+			return
+		end
 	end
 
 	self.notInterruptible = notInterruptible
@@ -184,5 +202,8 @@ end
 -------------------------------------------------------------------------------
 
 
+-- Fulzamoth 2019-09-27 : load in Classic if LibClassicCasterino exists
 -- Load us up
-IceHUD.TargetCast = TargetCast:new()
+if not IceHUD.WowClassic or LibClassicCasterino then
+	IceHUD.TargetCast = TargetCast:new()
+end

modules/TargetHealth.lua

@@ -43,7 +43,7 @@ function IceTargetHealth.prototype:GetDefaultSettings()
 	settings["classColor"] = false
 	settings["hideBlizz"] = false
 	settings["upperText"] = "[PercentHP:Round]"
-	settings["lowerText"] = "[(HP:Round \"/\" MaxHP:Round):HPColor:Bracket]"
+	settings["lowerText"] = "[FractionalHP:Short:HPColor:Bracket]"
 	settings["raidIconOnTop"] = true
 	settings["showRaidIcon"] = true
 	settings["raidIconXOffset"] = 12
@@ -637,9 +637,15 @@ function IceTargetHealth.prototype:Enable(core)
 		self:RegisterEvent("UPDATE_FACTION", "CheckPvP")
 		self:RegisterEvent("PLAYER_FLAGS_CHANGED", "CheckPvP")
 		self:RegisterEvent("UNIT_FACTION", "CheckPvP")
-		self:RegisterEvent("LFG_PROPOSAL_UPDATE", "CheckPartyRole")
-		self:RegisterEvent("LFG_PROPOSAL_FAILED", "CheckPartyRole")
-		self:RegisterEvent("LFG_ROLE_UPDATE", "CheckPartyRole")
+		if GetLFGRoles then
+			self:RegisterEvent("LFG_PROPOSAL_UPDATE", "CheckPartyRole")
+			self:RegisterEvent("LFG_PROPOSAL_FAILED", "CheckPartyRole")
+			self:RegisterEvent("LFG_ROLE_UPDATE", "CheckPartyRole")
+		end
+
+		if IceHUD.ShouldUpdateTargetHealthEveryTick and self.unit == "target" then
+			self.frame:SetScript("OnUpdate", function() self:Update(self.unit) end)
+		end
 	end
 
 	if (self.moduleSettings.hideBlizz) then
@@ -657,6 +663,10 @@ function IceTargetHealth.prototype:Disable(core)
 
 	UnregisterUnitWatch(self.frame)
 
+	if self.registerEvents and IceHUD.ShouldUpdateTargetHealthEveryTick and self.unit == "target" then
+		self.frame:SetScript("OnUpdate", nil)
+	end
+
 	if self.moduleSettings.hideBlizz then
 		self:ShowBlizz()
 	end
@@ -840,21 +850,46 @@ function IceTargetHealth.prototype:Update(unit)
 
 	self:UpdateBar(self.healthPercentage, self.color)
 
-	if not IceHUD.IceCore:ShouldUseDogTags() and self.frame:IsVisible() then
-		self:SetBottomText1(math.floor(self.healthPercentage * 100))
+	if IsAddOnLoaded("RealMobHealth") then
+		if not IceHUD.IceCore:ShouldUseDogTags() and self.frame:IsVisible() then
+			self:SetBottomText1(math.floor(self.healthPercentage * 100))
 
-		if self.moduleSettings.abbreviateHealth then
-			self.health = self:Round(self.health)
-			self.maxHealth = self:Round(self.maxHealth)
-		end
+			if self.moduleSettings.abbreviateHealth then
+				if RealMobHealth.UnitHasHealthData(unit) then
+					self.health, self.maxHealth = RealMobHealth.GetUnitHealth(unit)
+				end
+				self.health = self:Round(self.health)
+				self.maxHealth = self:Round(self.maxHealth)
+			end
 
-		if (self.maxHealth ~= 100) then
-			self:SetBottomText2(self:GetFormattedText(self.health, self.maxHealth), self.color)
-		else
-			self:SetBottomText2()
+			if RealMobHealth.UnitHasHealthData(unit) or (self.maxHealth ~= 100) then
+				if RealMobHealth.UnitHasHealthData(unit) then
+					self.health, self.maxHealth = RealMobHealth.GetUnitHealth(unit)
+					self:SetBottomText2(self:GetFormattedText(self.health, self.maxHealth), self.color)
+				else
+					self:SetBottomText2(self:GetFormattedText(self.health, self.maxHealth), self.color)
+				end				
+			else
+				self:SetBottomText2()
+			end
 		end
+	else
+		if not IceHUD.IceCore:ShouldUseDogTags() and self.frame:IsVisible() then
+			self:SetBottomText1(math.floor(self.healthPercentage * 100))
+
+			if self.moduleSettings.abbreviateHealth then
+				self.health = self:Round(self.health)
+				self.maxHealth = self:Round(self.maxHealth)
+			end
+
+			if (self.maxHealth ~= 100) then
+				self:SetBottomText2(self:GetFormattedText(self.health, self.maxHealth), self.color)
+			else
+				self:SetBottomText2()
+			end
+		end	
 	end
-
+	
 	self:CheckPvP()
 	self:CheckPartyRole()
 	self:SetIconAlpha()
@@ -972,17 +1007,6 @@ function IceTargetHealth.prototype:UpdateRaidTargetIcon()
 end
 
 
-function IceTargetHealth.prototype:Round(health)
-	if (health > 1000000) then
-		return IceHUD:MathRound(health/1000000, 1) .. "M"
-	end
-	if (health > 1000) then
-		return IceHUD:MathRound(health/1000, 1) .. "k"
-	end
-	return health
-end
-
-
 function IceTargetHealth.prototype:CheckPvP()
 	local pvpMode = nil
 	local minx, maxx, miny, maxy
@@ -1041,20 +1065,25 @@ end
 
 
 function IceTargetHealth.prototype:ShowBlizz()
-	TargetFrame:Show()
-	TargetFrame:GetScript("OnLoad")(TargetFrame)
-
-	ComboFrame:Show()
-	ComboFrame:GetScript("OnLoad")(ComboFrame)
+	TargetFrame:SetParent(self.OriginalTargetFrameParent or UIParent)
+	ComboFrame:SetParent(self.OriginalComboFrameParent or UIParent)
 end
 
 
 function IceTargetHealth.prototype:HideBlizz()
-	TargetFrame:Hide()
-	TargetFrame:UnregisterAllEvents()
+	if not self.TargetFrameParent then
+		self.TargetFrameParent = CreateFrame("Frame")
+		self.TargetFrameParent:Hide()
+	end
+	if not self.ComboFrameParent then
+		self.ComboFrameParent = CreateFrame("Frame")
+		self.ComboFrameParent:Hide()
+	end
 
-	ComboFrame:Hide()
-	ComboFrame:UnregisterAllEvents()
+	self.OriginalTargetFrameParent = TargetFrame:GetParent()
+	TargetFrame:SetParent(self.TargetFrameParent)
+	self.OriginalComboFrameParent = ComboFrame:GetParent()
+	ComboFrame:SetParent(self.ComboFrameParent)
 end
 
 function IceTargetHealth.prototype:UpdateBar(scale, color, alpha)
@@ -1074,12 +1103,12 @@ function IceTargetHealth.prototype:CheckPartyRole()
 	if self.configMode or IceHUD:GetIsInLFGGroup() then
 		if self.configMode or self.moduleSettings.showPartyRoleIcon then
 			local isTank, isHeal, isDPS
-			local proposalExists, typeID, id, name
+			local proposalExists, typeID, id, subtypeID, name
 			local texture, role, hasResponded, totalEncounters, completedEncounters, numMembers, isleader
-			proposalExists, typeID, id, name, texture, role, hasResponded, totalEncounters, completedEncounters, numMembers, isleader = GetLFGProposal()
+			proposalExists, id, typeID, subtypeID, name, texture, role, hasResponded, totalEncounters, completedEncounters, numMembers, isleader = GetLFGProposal()
 
 			local p = self.unit
-			if IceHUD.WowVer < 40000 then
+			if not IceHUD.UnitGroupRolesReturnsRoleString then
 				isTank, isHeal, isDPS = UnitGroupRolesAssigned(p)
 			else
 				local grpRole = UnitGroupRolesAssigned(p)

modules/TargetInfo.lua

@@ -2,7 +2,7 @@ local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
 IceTargetInfo = IceCore_CreateClass(IceElement)
 
 local CooldownFrame_SetTimer = CooldownFrame_SetTimer
-if IceHUD.WowVer >= 70000 then
+if CooldownFrame_Set then
 	CooldownFrame_SetTimer = CooldownFrame_Set
 end
 
@@ -12,6 +12,10 @@ local internal = "internal"
 
 local ValidAnchors = { "TOPLEFT", "TOPRIGHT", "BOTTOMLEFT", "BOTTOMRIGHT", "CENTER" }
 
+---- Fulzamoth - 2019-09-04 : support for cooldowns on target buffs/debuffs (classic)
+local LibClassicDurations = LibStub("LibClassicDurations", 1)
+---- end change by Fulzamoth
+
 IceTargetInfo.prototype.unit = "target"
 
 IceTargetInfo.prototype.buffSize = nil
@@ -129,7 +133,9 @@ function IceTargetInfo.prototype:Enable(core)
 	self:RegisterEvent("UNIT_LEVEL", "TargetLevel")
 
 	self:RegisterEvent("UNIT_FLAGS", "TargetFlags")
-	self:RegisterEvent("UNIT_DYNAMIC_FLAGS", "TargetFlags")
+	if IceHUD.EventExistsUnitDynamicFlags then
+		self:RegisterEvent("UNIT_DYNAMIC_FLAGS", "TargetFlags")
+	end
 
 	self:RegisterEvent("RAID_TARGET_UPDATE", "UpdateRaidTargetIcon")
 
@@ -958,6 +964,23 @@ function IceTargetInfo.prototype:GetOptions()
 		order = 39.3,
 	}
 
+	opts["showRaidIcon"] = {
+		type = 'toggle',
+		name = L['Show raid icon'],
+		desc = L['Whether or not to show the raid icon for this unit.'],
+		get = function()
+			return self.moduleSettings.showRaidIcon
+		end,
+		set = function(info, v)
+			self.moduleSettings.showRaidIcon = v
+			self:UpdateRaidTargetIcon()
+		end,
+		disabled = function()
+			return not self.moduleSettings.enabled
+		end,
+		order = 37.02,
+	}
+
 	return opts
 end
 
@@ -1011,6 +1034,7 @@ function IceTargetInfo.prototype:GetDefaultSettings()
 			["sortByExpiration"] = true,
 		}
 	}
+	defaults["showRaidIcon"] = true
 
 	return defaults
 end
@@ -1325,6 +1349,7 @@ do
 					icon:SetHeight(size-2)
 				end
 			else
+				frame.texture:SetTexture(0, 0, 0, 0.5)
 				icon:SetWidth(size-2)
 				icon:SetHeight(size-2)
 			end
@@ -1388,7 +1413,29 @@ function IceTargetInfo.prototype:UpdateBuffType(aura)
 
 	if self.moduleSettings.auras[aura].show then
 		for i = 1, IceCore.BuffLimit do
-			local name, rank, icon, count, debuffType, duration, expirationTime, unitCaster, isStealable = UnitAura(self.unit, i, reaction .. (filter and "|PLAYER" or ""))
+			local name, rank, icon, count, debuffType, duration, expirationTime, unitCaster, isStealable
+
+			---- Fulzamoth - 2019-09-04 : support for cooldowns on target buffs/debuffs (classic)
+			local spellID
+			---- end change by Fulzamoth
+
+			if IceHUD.SpellFunctionsReturnRank then
+				name, rank, icon, count, debuffType, duration, expirationTime, unitCaster, isStealable = UnitAura(self.unit, i, reaction .. (filter and "|PLAYER" or ""))
+			else
+				---- Fulzamoth - 2019-09-04 : support for cooldowns on target buffs/debuffs (classic)
+				-- 1. in addition to other info, get the spellID for for the (de)buff
+				name, icon, count, debuffType, duration, expirationTime, unitCaster, isStealable, _, spellID = UnitAura(self.unit, i, reaction .. (filter and "|PLAYER" or ""))
+				if duration == 0 and LibClassicDurations then
+					-- 2. if no duration defined for the (de)buff, look up the spell in LibClassicDurations
+					local classicDuration, classicExpirationTime = LibClassicDurations:GetAuraDurationByUnit(self.unit, spellID, caster)
+					-- 3. set the duration if we found one.
+					if classicDuration then
+						duration = classicDuration
+						expirationTime = classicExpirationTime
+					end
+				end
+				---- end change by Fulzamoth
+			end
 			local isFromMe = (unitCaster == "player")
 
 			if not icon and IceHUD.IceCore:IsInConfigMode() and UnitExists(self.unit) then
@@ -1479,7 +1526,7 @@ function IceTargetInfo.prototype:AuraChanged(event, unit)
 end
 
 function IceTargetInfo.prototype:UpdateRaidTargetIcon()
-	if not (UnitExists(self.unit)) then
+	if not (UnitExists(self.unit)) or not self.moduleSettings.showRaidIcon then
 		self.frame.raidIcon:Hide()
 		return
 	end
@@ -1558,7 +1605,7 @@ function IceTargetInfo.prototype:TargetName(event, unit)
 		end
 
 
-		if IceHUD.WowVer < 50000 then
+		if UnitIsPartyLeader then
 			self.leader = UnitIsPartyLeader(self.unit) and " |cffcccc11Leader|r" or ""
 		else
 			self.leader = UnitIsGroupLeader(self.unit) and " |cffcccc11Leader|r" or ""
@@ -1629,7 +1676,7 @@ end
 
 function IceTargetInfo.prototype:TargetFlags(event, unit)
 	if (unit == self.unit or unit == internal) then
-		if IceHUD.WowVer < 70000 then
+		if UnitIsTapped then
 			self.tapped = UnitIsTapped(self.unit) and (not UnitIsTappedByPlayer(self.unit))
 		else
 			self.tapped = UnitIsTapDenied(self.unit)

modules/TargetInvuln.lua

@@ -7,7 +7,7 @@ TargetInvuln.prototype.buffRemaining = 0
 TargetInvuln.prototype.buffDuration = 0
 
 local GetNumPartyMembers, GetNumRaidMembers = GetNumPartyMembers, GetNumRaidMembers
-if IceHUD.WowVer >= 50000 then
+if GetNumGroupMembers then
 	GetNumPartyMembers = GetNumGroupMembers
 	GetNumRaidMembers = GetNumGroupMembers
 end
@@ -146,7 +146,12 @@ end
 
 function TargetInvuln.prototype:GetMaxbuffDuration(unitName, buffNames)
 	local i = 1
-	local buff, rank, texture, count, buffType, duration, endTime, unitCaster = UnitAura(unitName, i, "HELPFUL")
+	local buff, rank, texture, count, buffType, duration, endTime, unitCaster
+	if IceHUD.SpellFunctionsReturnRank then
+		buff, rank, texture, count, buffType, duration, endTime, unitCaster = UnitAura(unitName, i, "HELPFUL")
+	else
+		buff, texture, count, buffType, duration, endTime, unitCaster = UnitAura(unitName, i, "HELPFUL")
+	end
 	local isMine = unitCaster == "player"
 	local result = {nil, nil, nil}
 	local remaining
@@ -173,7 +178,11 @@ function TargetInvuln.prototype:GetMaxbuffDuration(unitName, buffNames)
 
 		i = i + 1;
 
-		buff, rank, texture, count, buffType, duration, endTime, unitCaster = UnitAura(unitName, i, "HELPFUL")
+		if IceHUD.SpellFunctionsReturnRank then
+			buff, rank, texture, count, buffType, duration, endTime, unitCaster = UnitAura(unitName, i, "HELPFUL")
+		else
+			buff, texture, count, buffType, duration, endTime, unitCaster = UnitAura(unitName, i, "HELPFUL")
+		end
 		isMine = unitCaster == "player"
 	end
 
@@ -182,13 +191,14 @@ end
 
 function TargetInvuln.prototype:MyOnUpdate()
 	TargetInvuln.super.prototype.MyOnUpdate(self)
-	self:UpdateTargetBuffs(nil, self.unit, true)
+	self:UpdateTargetBuffs("internal", self.unit)
 end
 
-function TargetInvuln.prototype:UpdateTargetBuffs(event, unit, isUpdate)
+function TargetInvuln.prototype:UpdateTargetBuffs(event, unit)
 	local name, duration, remaining
+	local isUpdate = event == "internal"
 
-	if not isUpdate then
+	if not isUpdate or not self.lastUpdateTime then
 		self.buffName, self.buffDuration, self.buffRemaining = self:GetMaxbuffDuration(self.unit, self.buffList)
 	else
 		self.buffRemaining = math.max(0, self.buffRemaining - (GetTime() - self.lastUpdateTime))

modules/TargetMana.lua

@@ -4,6 +4,28 @@ IceTargetMana.prototype.registerEvents = true
 IceTargetMana.prototype.color = nil
 IceTargetMana.prototype.determineColor = true
 
+local SPELL_POWER_MANA = SPELL_POWER_MANA
+local SPELL_POWER_RAGE = SPELL_POWER_RAGE
+local SPELL_POWER_FOCUS = SPELL_POWER_FOCUS
+local SPELL_POWER_ENERGY = SPELL_POWER_ENERGY
+local SPELL_POWER_RUNIC_POWER = SPELL_POWER_RUNIC_POWER
+local SPELL_POWER_INSANITY = SPELL_POWER_INSANITY
+local SPELL_POWER_FURY = SPELL_POWER_FURY
+local SPELL_POWER_MAELSTROM = SPELL_POWER_MAELSTROM
+local SPELL_POWER_PAIN = SPELL_POWER_PAIN
+local SPELL_POWER_LUNAR_POWER = SPELL_POWER_LUNAR_POWER
+if Enum and Enum.PowerType then
+	SPELL_POWER_MANA = Enum.PowerType.Mana
+	SPELL_POWER_RAGE = Enum.PowerType.Rage
+	SPELL_POWER_FOCUS = Enum.PowerType.Focus
+	SPELL_POWER_ENERGY = Enum.PowerType.Energy
+	SPELL_POWER_RUNIC_POWER = Enum.PowerType.RunicPower
+	SPELL_POWER_INSANITY = Enum.PowerType.Insanity
+	SPELL_POWER_FURY = Enum.PowerType.Fury
+	SPELL_POWER_MAELSTROM = Enum.PowerType.Maelstrom
+	SPELL_POWER_PAIN = Enum.PowerType.Pain
+	SPELL_POWER_LUNAR_POWER = Enum.PowerType.LunarPower
+end
 
 -- Constructor --
 function IceTargetMana.prototype:init(moduleName, unit)
@@ -18,6 +40,12 @@ function IceTargetMana.prototype:init(moduleName, unit)
 	self:SetDefaultColor("TargetEnergy", 228, 242, 31)
 	self:SetDefaultColor("TargetFocus", 242, 149, 98)
 	self:SetDefaultColor("TargetRunicPower", 52, 64, 221)
+	if IceHUD.WowVer >= 70000 then
+		self:SetDefaultColor("TargetInsanity", 150, 50, 255)
+		self:SetDefaultColor("TargetFury", 255, 50, 255)
+		self:SetDefaultColor("TargetMaelstrom", 52, 64, 221)
+		self:SetDefaultColor("TargetPain", 255, 50, 255)
+	end
 end
 
 
@@ -27,7 +55,7 @@ function IceTargetMana.prototype:GetDefaultSettings()
 	settings["side"] = IceCore.Side.Right
 	settings["offset"] = 2
 	settings["upperText"] = "[PercentMP:Round]"
-	settings["lowerText"] = "[FractionalMP:PowerColor]"
+	settings["lowerText"] = "[FractionalMP:Short:PowerColor]"
 	settings["onlyShowMana"] = false
 
 	return settings
@@ -38,9 +66,11 @@ function IceTargetMana.prototype:Enable(core)
 	IceTargetMana.super.prototype.Enable(self, core)
 
 	if self.registerEvents then
-		if IceHUD.WowVer >= 40000 then
-			self:RegisterEvent("UNIT_POWER", "UpdateEvent")
-			self:RegisterEvent("UNIT_MAXPOWER", "UpdateEvent")
+		if not IceHUD.PerPowerEventsExist then
+			self:RegisterEvent(IceHUD.UnitPowerEvent, "UpdateEvent")
+			if IceHUD.EventExistsUnitMaxPower then
+				self:RegisterEvent("UNIT_MAXPOWER", "UpdateEvent")
+			end
 		else
 			self:RegisterEvent("UNIT_MAXMANA", "UpdateEvent")
 			self:RegisterEvent("UNIT_MAXRAGE", "UpdateEvent")
@@ -53,7 +83,7 @@ function IceTargetMana.prototype:Enable(core)
 			self:RegisterEvent("UNIT_FOCUS", "UpdateEvent")
 
 			-- DK rune stuff
-			if IceHUD.WowVer >= 30000 then
+			if SPELL_POWER_RUNIC_POWER then
 				self:RegisterEvent("UNIT_RUNIC_POWER", "UpdateEvent")
 				self:RegisterEvent("UNIT_MAXRUNIC_POWER", "UpdateEvent")
 			end
@@ -105,6 +135,14 @@ function IceTargetMana.prototype:Update(unit)
 			self.color = "TargetEnergy"
 		elseif (manaType == SPELL_POWER_RUNIC_POWER) then
 			self.color = "TargetRunicPower"
+		elseif (manaType == SPELL_POWER_INSANITY) then
+			self.color = "TargetInsanity"
+		elseif (manaType == SPELL_POWER_FURY) then
+			self.color = "TargetFury"
+		elseif (manaType == SPELL_POWER_MAELSTROM) then
+			self.color = "TargetMaelstrom"
+		elseif (manaType == SPELL_POWER_PAIN) then
+			self.color = "TargetPain"
 		end
 
 		if (self.tapped) then
@@ -112,20 +150,21 @@ function IceTargetMana.prototype:Update(unit)
 		end
 	end
 
-	if manaType == SPELL_POWER_RAGE or manaType == SPELL_POWER_RUNIC_POWER then
-		self.bTreatEmptyAsFull = true
-	else
-		self.bTreatEmptyAsFull = false
-	end
+	self.bTreatEmptyAsFull = self:TreatEmptyAsFull(manaType)
 
 	self:UpdateBar(self.manaPercentage, self.color)
 
 	if not IceHUD.IceCore:ShouldUseDogTags() then
 		self:SetBottomText1(math.floor(self.manaPercentage * 100))
-		self:SetBottomText2(self:GetFormattedText(self.mana, self.maxMana), color)
+		self:SetBottomText2(self:GetFormattedText(self.mana, self.maxMana), self.color)
 	end
 end
 
+function IceTargetMana.prototype:TreatEmptyAsFull(manaType)
+	return manaType == SPELL_POWER_RAGE or manaType == SPELL_POWER_RUNIC_POWER
+		or (IceHUD.WowVer >= 70000 and (manaType == SPELL_POWER_LUNAR_POWER or manaType == SPELL_POWER_INSANITY
+		or manaType == SPELL_POWER_FURY or manaType == SPELL_POWER_PAIN or manaType == SPELL_POWER_MAELSTROM))
+end
 
 -- OVERRIDE
 function IceTargetMana.prototype:GetOptions()

modules/TargetOfTarget.lua

@@ -485,7 +485,12 @@ function TargetOfTarget.prototype:UpdateBuffs()
 
 	if (self.moduleSettings.showDebuffs) then
 		for i = 1, IceCore.BuffLimit do
-			local buffName, buffRank, buffTexture, buffApplications = UnitDebuff(self.unit, i)
+			local buffName, buffRank, buffTexture, buffApplications
+			if IceHUD.SpellFunctionsReturnRank then
+				buffName, buffRank, buffTexture, buffApplications = UnitDebuff(self.unit, i)
+			else
+				buffName, buffTexture, buffApplications = UnitDebuff(self.unit, i)
+			end
 
 			if (buffApplications and (buffApplications > 1)) then
 				debuffs = debuffs + 1

modules/TargetOfTargetCast.lua

@@ -58,16 +58,20 @@ function TargetTargetCast.prototype:UpdateTargetTarget()
 		return
 	end
 
-	local spell = UnitCastingInfo(self.unit)
-	if (spell) then
-		self:StartBar(IceCastBar.Actions.Cast)
-		return
+	if UnitCastingInfo then
+		local spell = UnitCastingInfo(self.unit)
+		if spell then
+			self:StartBar(IceCastBar.Actions.Cast)
+			return
+		end
 	end
 
-	local channel = UnitChannelInfo(self.unit)
-	if (channel) then
-		self:StartBar(IceCastBar.Actions.Channel)
-		return
+	if UnitChannelInfo then
+		local channel = UnitChannelInfo(self.unit)
+		if channel then
+			self:StartBar(IceCastBar.Actions.Channel)
+			return
+		end
 	end
 
 	self:StopBar()
@@ -144,4 +148,6 @@ end
 
 
 -- Load us up
-IceHUD.TargetTargetCast = TargetTargetCast:new()
+if not IceHUD.WowClassic then
+	IceHUD.TargetTargetCast = TargetTargetCast:new()
+end

modules/TargetOfTargetHealth.lua

@@ -24,7 +24,7 @@ function TargetTargetHealth.prototype:GetDefaultSettings()
 	settings["selfColor"] = { r = 0, g = 0, b = 1 }
 	settings["selfDisplayMode"] = "Color as SelfColor"
 	settings["upperText"] = "[PercentHP:Round]"
-	settings["lowerText"] = "[(HP:Round \"/\" MaxHP:Round):HPColor:Bracket]"
+	settings["lowerText"] = "[FractionalHP:Short:HPColor:Bracket]"
 	settings["barVerticalOffset"] = 35
 	settings["scale"] = 0.7
 	settings["enabled"] = false

modules/TargetOfTargetMana.lua

@@ -21,7 +21,7 @@ function TargetTargetMana.prototype:GetDefaultSettings()
 	settings["side"] = IceCore.Side.Right
 	settings["offset"] = 11
 	settings["upperText"] = "[PercentMP:Round]"
-	settings["lowerText"] = "[FractionalMP:PowerColor]"
+	settings["lowerText"] = "[FractionalMP:Short:PowerColor]"
 	settings["barVerticalOffset"] = 35
 	settings["scale"] = 0.7
 	settings["enabled"] = false

modules/Threat.lua

@@ -16,13 +16,20 @@ IceThreat.prototype.scheduledEvent = nil
 
 local GetNumPartyMembers, GetNumRaidMembers = GetNumPartyMembers, GetNumRaidMembers
 local MAX_NUM_RAID_MEMBERS, MAX_NUM_PARTY_MEMBERS = MAX_NUM_RAID_MEMBERS, MAX_NUM_PARTY_MEMBERS
-if IceHUD.WowVer >= 50000 then
+if not GetNumPartyMembers then
 	GetNumPartyMembers = GetNumGroupMembers
 	GetNumRaidMembers = GetNumGroupMembers
 	MAX_NUM_PARTY_MEMBERS = MAX_PARTY_MEMBERS
 	MAX_NUM_RAID_MEMBERS = MAX_RAID_MEMBERS
 end
 
+local UnitGroupRolesAssigned = UnitGroupRolesAssigned
+if not UnitGroupRolesAssigned then
+	UnitGroupRolesAssigned = function()
+		return "NONE"
+	end
+end
+
 local MAX_NUM_RAID_MEMBERS = 40
 local MAX_NUM_PARTY_MEMBERS = 5
 
@@ -224,7 +231,7 @@ end
 
 -- create the aggro range indicator bar
 function IceThreat.prototype:CreateAggroBar()
-	self.aggroBar = self:BarFactory(self.aggroBar, "BACKGROUND","ARTWORK")
+	self.aggroBar = self:BarFactory(self.aggroBar, "BACKGROUND","ARTWORK", "Aggro")
 
 	local r, g, b = self:GetColor("ThreatPullAggro")
 	if (self.settings.backgroundToggle) then
@@ -236,7 +243,7 @@ function IceThreat.prototype:CreateAggroBar()
 end
 
 function IceThreat.prototype:CreateSecondThreatBar()
-	self.secondThreatBar = self:BarFactory(self.secondThreatBar, "MEDIUM", "OVERLAY")
+	self.secondThreatBar = self:BarFactory(self.secondThreatBar, "MEDIUM", "OVERLAY", "SecondThreat")
 
 	self.secondThreatBar.bar:SetVertexColor(self:GetColor("ThreatSecondPlace", self.alpha * self.moduleSettings.secondPlaceThreatAlpha))
 
@@ -468,4 +475,6 @@ function IceThreat.prototype:Show(bShouldShow)
 end
 
 -- Load us up
-IceHUD.IceThreat = IceThreat:new()
+if UnitDetailedThreatSituation then
+	IceHUD.IceThreat = IceThreat:new()
+end

modules/Totems.lua

@@ -2,7 +2,7 @@ local L = LibStub("AceLocale-3.0"):GetLocale("IceHUD", false)
 local Totems = IceCore_CreateClass(IceElement)
 
 local CooldownFrame_SetTimer = CooldownFrame_SetTimer
-if IceHUD.WowVer >= 70000 then
+if CooldownFrame_Set then
 	CooldownFrame_SetTimer = CooldownFrame_Set
 end
 
@@ -215,7 +215,7 @@ function Totems.prototype:Enable(core)
 	Totems.super.prototype.Enable(self, core)
 
 	self:RegisterEvent("PLAYER_TOTEM_UPDATE", "UpdateTotem");
-	self:RegisterEvent("PLAYER_ENTERING_WORLD", "ResetTotemAvailability");
+	self:RegisterEvent("PLAYER_ENTERING_WORLD", "EnteringWorld");
 
 	if self.moduleSettings.hideBlizz then
 		self:HideBlizz()
@@ -230,6 +230,11 @@ function Totems.prototype:Disable(core)
 	end
 end
 
+function Totems.prototype:EnteringWorld()
+	self:TargetChanged()
+	self:ResetTotemAvailability()
+end
+
 function Totems.prototype:ResetTotemAvailability()
 	for i=1, self.numTotems do
 		self:UpdateTotem(nil, i)
@@ -237,16 +242,17 @@ function Totems.prototype:ResetTotemAvailability()
 end
 
 function Totems.prototype:UpdateTotem(event, totem, ...)
-	if not totem or tonumber(totem) ~= totem or totem < 1 or totem > self.numTotems then
+	if not totem or tonumber(totem) ~= totem or totem < 1 or totem > self.numTotems or not GetTotemInfo then
 		return
 	end
-	local thisTotemName = self.totemNames[TOTEM_PRIORITIES[totem]]
+
 	local haveTotem, name, startTime, duration, icon = GetTotemInfo(totem);
 	if duration > 0 then
 		self.frame.graphical[totem].totem:SetTexture(icon)
 		CooldownFrame_SetTimer(self.frame.graphical[totem].cd, startTime, duration, true)
 		self.frame.graphical[totem].cd:Show()
 		self.frame.graphical[totem]:Show()
+		self.frame.graphical[totem].name = name
 	else
 		self.frame.graphical[totem].cd:Hide()
 		self.frame.graphical[totem]:Hide()
@@ -281,10 +287,9 @@ function Totems.prototype:CreateTotemFrame()
 		self.frame.graphical = {}
 	end
 
-	local totemType
 	for i=1, self.numTotems do
-		slot = TOTEM_PRIORITIES[i]
-		self:CreateTotem(slot,  self.totemNames[slot])
+		local slot = TOTEM_PRIORITIES[i]
+		self:CreateTotem(slot, self.totemNames[slot])
 	end
 end
 
@@ -293,14 +298,18 @@ function Totems.prototype:GetAlphaAdd()
 end
 
 function Totems.prototype:ShowBlizz()
-	TotemFrame:Show()
-	TotemFrame:GetScript("OnLoad")(TotemFrame)
+	if TotemFrame then
+		TotemFrame:Show()
+		TotemFrame:GetScript("OnLoad")(TotemFrame)
+	end
 end
 
 
 function Totems.prototype:HideBlizz()
-	TotemFrame:Hide()
-	TotemFrame:UnregisterAllEvents()
+	if TotemFrame then
+		TotemFrame:Hide()
+		TotemFrame:UnregisterAllEvents()
+	end
 end
 
 function Totems.prototype:TargetChanged()
@@ -326,21 +335,18 @@ function Totems.prototype:CheckCombat()
 end
 
 function Totems.prototype:CreateTotem(i, name)
-	-- whiskey tango foxtrot?! apparently arenas can cause this? I can't test out the real cause myself, so putting in a stopgap for now
-	if not name then
+	if not name or not GetTotemInfo then
 		return
 	end
 	local haveTotem, name, startTime, duration, icon = GetTotemInfo(i)
-	local bWasNewFrame = false
 	if (not self.frame.graphical[i]) then
 		self.frame.graphical[i] = CreateFrame("Frame", nil, self.frame)
-		self.frame.graphical[i].totem = self.frame.graphical[i]:CreateTexture(nil, "LOW")
+		self.frame.graphical[i].totem = self.frame.graphical[i]:CreateTexture(nil, "BACKGROUND")
 		self.frame.graphical[i].cd = CreateFrame("Cooldown", nil, self.frame.graphical[i], "CooldownFrameTemplate")
 		self.frame.graphical[i].shine = self.frame.graphical[i]:CreateTexture(nil, "OVERLAY")
 
 		self.frame.graphical[i].totem:SetTexture(icon)
 		self.frame.graphical[i].totem:SetAllPoints(self.frame.graphical[i])
-		bWasNewFrame = true
 	end
 
 	self.frame.graphical[i]:SetFrameStrata("BACKGROUND")
@@ -354,15 +360,22 @@ function Totems.prototype:CreateTotem(i, name)
 	end
 
 	if not self.graphicalOnEnter then
-		self.graphicalOnEnter = function(button) GameTooltip:SetOwner(button); GameTooltip:SetTotem(button.slot) end
+		self.graphicalOnEnter = function(button)
+			GameTooltip:SetOwner(button)
+			if IceHUD.WowClassic then
+				GameTooltip:SetText(button.name)
+			else
+				GameTooltip:SetTotem(button.slot)
+			end
+		end
 	end
 	if not self.graphicalOnLeave then
 		self.graphicalOnLeave = function() GameTooltip:Hide() end
 	end
 	if not self.graphicalOnMouseUp then
-		self.graphicalOnMouseUp = function (self, mouseButton)
+		self.graphicalOnMouseUp = function (button, mouseButton)
 			if mouseButton == "RightButton" then
-				DestroyTotem(self.slot)
+				DestroyTotem(button.slot)
 			end
 		end
 	end
@@ -390,21 +403,23 @@ function Totems.prototype:CreateTotem(i, name)
 		self.frame.graphical[i]:EnableMouse(true)
 		self.frame.graphical[i]:SetScript("OnEnter", self.graphicalOnEnter)
 		self.frame.graphical[i]:SetScript("OnLeave", self.graphicalOnLeave)
+		if IceHUD.CanHookDestroyTotem then
+			self.frame.graphical[i]:SetScript("OnMouseUp", self.graphicalOnMouseUp)
+		end
 	else
 		self.frame.graphical[i]:EnableMouse(false)
 		self.frame.graphical[i]:SetScript("OnEnter", nil)
 		self.frame.graphical[i]:SetScript("OnLeave", nil)
+		if IceHUD.CanHookDestroyTotem then
+			self.frame.graphical[i]:SetScript("OnMouseUp", nil)
+		end
 	end
 	self.frame.graphical[i].slot = i
-
-	-- it looks like HookScript will continue to add handlers every time instead of replacing them like SetScript
-	if (bWasNewFrame) then
-		--self.frame.graphical[i]:HookScript("OnMouseUp", self.graphicalOnMouseUp)
-	end
+	self.frame.graphical[i].name = name
 end
 
 -- Load us up
 local _, unitClass = UnitClass("player")
-if (unitClass == "SHAMAN") or (unitClass == "DRUID") then
+if IceHUD.WowVer >= 90000 or (unitClass == "SHAMAN") or (unitClass == "DRUID") then
 	IceHUD.Totems = Totems:new()
 end

readme.md

@@ -0,0 +1,87 @@
+# IceHUD
+
+IceHUD is a highly configurable and customizable HUD addon in the spirit of DHUD, MetaHUD, and others designed to keep your focus in the center of the screen where your character is.
+
+## **What it is**
+
+* Player and target health and mana bars, casting and mirror bars, pet health and mana bars, druid mana bar in forms, extensive target info, ToT display, and much more, in a vertically-oriented heads-up display.
+
+## **Short feature list**
+
+* Lots of different bar shapes and patterns to make the HUD look like you want
+* Class-specific modules such as combo point counters, Slice'n'dice timers, druid mana trackers, Eclipse bar, Holy Power monitoring, Warlock shard tracking, and more
+* Target-of-target bars, Crowd Control timers, Range Finders, Threat meters, and plenty of other helpful modules
+* Lots of DogTag-supported strings for extreme customizability (with the option to completely disable DogTag support for those that dislike the CPU toll that it takes)
+* Cast lag indicator (optional)
+* Alpha settings for in combat, target selected, etc.
+* Fully customizable bars and counters capable of tracking buff/debuff applications on any unit, spell/ability cooldowns, and the health/mana of any unit you specify. The custom health/mana bars will even work with crazy unit specifications like "focustargettargetfocustarget" if you want!
+* Highly configurable (can totally re-arrange all bars, change text display, etc.)
+
+## **Slash commands**
+
+* /icehud - opens the configuration UI to tweak any setting
+* /icehudCL - command-line access to tweak IceHUD settings (for use with macros, etc.)
+
+## **Frequently Asked Questions**
+
+1. **How do I hide the default Blizzard player, target unit frames and party unit frames?**
+   Type /icehud, expand the "Module Settings" section, click "Player Health" or "Target Health," and check "Hide Blizzard Frame" and/or "Hide Blizzard Party Frame". (NOTE: before version 1.3.7, the player/target unitframes were hidden by default. Follow the same steps to enable them if desired)
+
+1. **How do I turn off click-targeting and menus on the player bar?**
+   Type /icehud, expand the "Module Settings" section, click "Player Health," un-check "Allow click-targeting." Note that as of v1.3, there is now an option to allow click-targeting out of combat, but turn it off while in combat.
+
+1. **How do I hide the HUD or change its transparency based on combat, targeting, etc.?**
+   Type /icehud, check the "Transparency Settings" section. Nearly any combination of states should be available for tweaking.
+
+1. **Even if the rest of the HUD is transparent, the health percentages seem to show up. Why?**
+   Type /icehud, expand the "Module Settings" section, expand "Player Health," click "Text Settings," look for options about keeping the lower/upper text blocks alpha locked. If the text is alpha locked, it will not drop below 100%, otherwise it respects its bar's transparency setting. Player Health/Mana, Target Health/Mana, and pet bars should all have these options.
+
+1. **Is there any way to see combo points for Rogues and Druids or sunder applications for Warriors?**
+   Yes, check the "Combo Points" and "Sunders" modules in the /icehud configuration panel. (Note that these modules may not show up if you're not of the appropriate class to see them. They should be present for their respective classes, however.)
+
+1. **What's this thing at the top of the player's cast bar and threat bar? It's darker than the rest of the bar.** (and may be colored red)
+   That's the Cast Lag Indicator (or the aggro-pull warning for the Threat bar) that shows you when you can start casting a new spell and still be able to finish the current one (based on your lag to the server). You can disable this in the Player Cast Bar settings under the /icehud configuration screen.
+
+1. **Is there a bar that shows breath underwater and if so, how can I adjust it?**
+   Yes, this is called the MirrorBarHandler in the module settings portion of the /icehud configuration. It's called that because it mirrors casting bar behavior, displays more than just breathing (fatigue is one example), and that's what Blizzard calls it. It can be moved/adjusted/resized/etc. as with any other module.
+
+1. **There's a long green bar that sometimes shows up below everything else. What is it?**
+   That would be the TargetOfTarget module. That module is available for people who don't want the full ToT health/mana bars, but do want some sort of ToT representation on the screen. It's configurable through the /icehud module settings.
+
+1. **IceHUD needs a bar or counter for buff/debuff X!**
+   Good news: as of v1.5, you can create as many bars and counters for any buffs or debuffs you want! Type /icehud, select one of the custom module types in the drop-down at the top of the settings page, and press the Create button. This will create a custom module and automatically select it in the list. It is highly recommend that you rename the bar as soon as possible to avoid any confusion later.
+
+1. **How do I turn off the resting/combat/PvP/etc. icons on the player or target?**
+   Type /icehud, expand Module Settings, expand PlayerHealth (or TargetHealth for targets), click Icon Settings. You can control every aspect of the icons there including location, visibility, draw order, etc.
+
+1. **How do I turn off buffs/debuffs on the player's or target's bar?**
+   Type /icehud, expand Module Settings, expand PlayerInfo (or TargetInfo for targets), select Buff Settings or Debuff Settings, and un-check "show buffs" (or "show debuffs").
+
+1. **How do I turn off these big huge bars that pulse whenever one of my abilities procs?**
+   This isn't IceHUD - it's Blizzard's Spell Alerts they added in 4.0.1. Interface options => Combat => "Spell Alert Opacity" to turn them off or search for a mod to tweak their positioning/size/etc.
+
+1. **I don't like where some of the bars are placed. How do I put the health/mana on the left/right?**
+   Type /icehud, expand Module Settings, expand whatever module you want to move (e.g. PlayerHealth, PlayerMana), and adjust the "Side" and "Offset" settings. "Side" controls whether it's on the left or the right and "Offset" controls how far from center it is.
+
+1. **Which module displays Monk Chi power?**
+   Prior to v1.11.2, this module was called HarmonyPower. Harmony was the original name for Chi back when 5.0 was in beta, so I used Blizzard's name for it while I was developing for Cataclysm. IceHUD v1.11.2 changed this module to be called Chi.
+
+1. **How do I add commas/periods into big numbers like health?**
+   If you have DogTags enabled, you can open the Text Settings for the module in question and add SeparateDigits() around the tag you're trying to split up. To display Health/MaxHealth with commas, use: [(SeparateDigits(HP):HPColor "/" SeparateDigits(MaxHP):HPColor):Bracket]. To use periods instead of commas, use: [(SeparateDigits(HP, "."):HPColor "/" SeparateDigits(MaxHP, "."):HPColor):Bracket]. Use the /dog help menu to build your own similar tags for Mana, etc.
+
+1. **The countdown timers on buffs and debuffs completely obscure the icon. How do I disable or adjust the text?**
+   IceHUD is not responsible for this countdown text and cannot control it. The 6.0 patch added an option in the game client to display counts on top of cooldowns. Look at the Action Bars menu under the game's Interface options. You can turn the text on or off there. Mods like OmniCC or CooldownCount will generally give you the same feature but allow you to control when, where, and how the text shows up.
+
+1. **When I rotate some modules 90 degrees, such as the castbar, the bar appears to wiggle up and down as it fills or empties. How do I fix this?**
+   This is a side effect of the animation API that I'm co-opting to force a rotation without having to provide duplicates of every bar texture in the mod. Any bar moving sufficiently quickly and updating rapidly will cause this. IceHUD is intended to be a vertically-oriented mod, so the rotation feature is there for people who are willing to accept the side effects that come with it. My suggestion is to use one of the many horizontally-oriented bar mods out there if you're wanting horizontal bars. Quartz is a good castbar replacement that you can use and disable IceHUD's built-in castbar, for example.
+
+1. **How do I get rid of the bars that showed up beneath the player in the 7.0 patch?**
+   Blizzard added a "Personal Resource Display" feature in the 7.0 game client. You can disable it in the Game options -> Interface -> Names -> Personal Resource Display.
+
+1. **Why is there no target castbar for Classic?**
+   The Classic game client doesn't offer a reliable way to show castbars for anyone except the player. IceHUD doesn't support the type of inaccurate guessing at combat log details that would be required to get a semi-useful target castbar.
+
+1. **Why do buff/debuff timers not work in Classic?**
+   The Classic game client doesn't provide this information to addons because it wasn't a feature when the game first released. You can install the LibClassicDurations addon to enable support, but it's a best guess and not completely accurate.
+
+See [here](https://www.wowace.com/projects/ice-hud/issues/113) for a user-created guide to creating new IceHUD textures.

this_version.md

@@ -0,0 +1,30 @@
+# Changelog
+
+v1.14.5:
+
+- Fix castbar flashing. There are controls on the player castbar module for flashing when a spell succeeds or fails, and separate controls for flashing when an instant cast completes. Those were broken, but now work again.
+- Add "@" after the number when the Combo Points module is in Numeric mode, "Show Charged points" is enabled, and the current combo point is charged.
+- Fix Charged point support in the ComboPointsBar module.
+
+v1.14.4:
+
+- Update TOC for 10.0.2
+
+v1.14.3:
+
+- Add Spell ID support for aura tracking.
+- Add Evoker support.
+- Add Empowered Casting (hold-to-cast levels) support.
+
+v1.14.2:
+
+- Fix CC and Invuln modules not showing immediately when they should.
+
+v1.14.1:
+
+- Fix Hide Party feature on pre-10.0 clients.
+
+v1.14.0:
+
+- 10.0 compatibility
+- Renamed Anima Charged combo points to Charged, and removed specific references to Kyrian.