You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
220 lines
7.2 KiB
220 lines
7.2 KiB
--[[
|
|
# Element: Experience Bar
|
|
|
|
Handles the updating of a status bar that displays the unit's Experience.
|
|
|
|
## Widget
|
|
|
|
Experience - A `StatusBar` used to represent the unit's Experience.
|
|
|
|
## Sub-Widgets
|
|
|
|
.bg - A `Texture` used as a background. It will inherit the color of the main StatusBar.
|
|
|
|
## Notes
|
|
|
|
A default texture will be applied if the widget is a StatusBar and doesn't have a texture set.
|
|
|
|
## Options
|
|
|
|
.smoothGradient - 9 color values to be used with the .colorSmooth option (table)
|
|
.considerSelectionInCombatHostile - Indicates whether selection should be considered hostile while the unit is in
|
|
combat with the player (boolean)
|
|
|
|
The following options are listed by priority. The first check that returns true decides the color of the bar.
|
|
|
|
.colorDisconnected - Use `self.colors.disconnected` to color the bar if the unit is offline (boolean)
|
|
.colorTapping - Use `self.colors.tapping` to color the bar if the unit isn't tapped by the player (boolean)
|
|
.colorThreat - Use `self.colors.threat[threat]` to color the bar based on the unit's threat status. `threat` is
|
|
defined by the first return of [UnitThreatSituation](https://wow.gamepedia.com/API_UnitThreatSituation) (boolean)
|
|
.colorClass - Use `self.colors.class[class]` to color the bar based on unit class. `class` is defined by the
|
|
second return of [UnitClass](http://wowprogramming.com/docs/api/UnitClass.html) (boolean)
|
|
.colorClassNPC - Use `self.colors.class[class]` to color the bar if the unit is a NPC (boolean)
|
|
.colorClassPet - Use `self.colors.class[class]` to color the bar if the unit is player controlled, but not a player
|
|
(boolean)
|
|
.colorSelection - Use `self.colors.selection[selection]` to color the bar based on the unit's selection color.
|
|
`selection` is defined by the return value of Private.unitSelectionType, a wrapper function
|
|
for [UnitSelectionType](https://wow.gamepedia.com/API_UnitSelectionType) (boolean)
|
|
.colorReaction - Use `self.colors.reaction[reaction]` to color the bar based on the player's reaction towards the
|
|
unit. `reaction` is defined by the return value of
|
|
[UnitReaction](http://wowprogramming.com/docs/api/UnitReaction.html) (boolean)
|
|
.colorSmooth - Use `smoothGradient` if present or `self.colors.smooth` to color the bar with a smooth gradient
|
|
based on the player's current Experience percentage (boolean)
|
|
.colorExperience - Use `self.colors.Experience` to color the bar. This flag is used to reset the bar color back to default
|
|
if none of the above conditions are met (boolean)
|
|
|
|
## Sub-Widgets Options
|
|
|
|
.multiplier - Used to tint the background based on the main widgets R, G and B values. Defaults to 1 (number)[0-1]
|
|
|
|
## Examples
|
|
|
|
-- Position and size
|
|
local Experience = CreateFrame('StatusBar', nil, self)
|
|
Experience:SetHeight(20)
|
|
Experience:SetPoint('TOP')
|
|
Experience:SetPoint('LEFT')
|
|
Experience:SetPoint('RIGHT')
|
|
|
|
-- Add a background
|
|
local Background = Experience:CreateTexture(nil, 'BACKGROUND')
|
|
Background:SetAllPoints(Experience)
|
|
Background:SetTexture(1, 1, 1, .5)
|
|
|
|
-- Options
|
|
Experience.colorTapping = true
|
|
Experience.colorDisconnected = true
|
|
Experience.colorClass = true
|
|
Experience.colorReaction = true
|
|
Experience.colorExperience = true
|
|
|
|
-- Make the background darker.
|
|
Background.multiplier = .5
|
|
|
|
-- Register it with oUF
|
|
Experience.bg = Background
|
|
self.PBExperience = Experience
|
|
--]]
|
|
local PA = _G.ProjectAzilroka
|
|
local oUF = PA.oUF
|
|
if not oUF then
|
|
return
|
|
end
|
|
|
|
local function UpdateColor(self, event, unit)
|
|
if (not unit or self.unit ~= unit) then
|
|
return
|
|
end
|
|
local element = self.PBExperience
|
|
|
|
local r, g, b, t
|
|
if (element.colorSmooth) then
|
|
r, g, b = self:ColorGradient(element.cur or 1, element.max or 1, unpack(element.smoothGradient or self.colors.smooth))
|
|
elseif (element.colorExperience) then
|
|
t = self.colors.power.MANA
|
|
end
|
|
|
|
if (t) then
|
|
r, g, b = t[1], t[2], t[3]
|
|
end
|
|
|
|
if (b) then
|
|
element:SetStatusBarColor(r, g, b)
|
|
|
|
local bg = element.bg
|
|
if (bg) then
|
|
local mu = bg.multiplier or 1
|
|
bg:SetVertexColor(r * mu, g * mu, b * mu)
|
|
end
|
|
end
|
|
|
|
if (element.PostUpdateColor) then
|
|
element:PostUpdateColor(unit, r, g, b)
|
|
end
|
|
end
|
|
|
|
local function ColorPath(self, ...)
|
|
--[[ Override: Experience.UpdateColor(self, event, unit)
|
|
Used to completely override the internal function for updating the widgets' colors.
|
|
|
|
* self - the parent object
|
|
* event - the event triggering the update (string)
|
|
* unit - the unit accompanying the event (string)
|
|
--]]
|
|
(self.PBExperience.UpdateColor or UpdateColor)(self, ...)
|
|
end
|
|
|
|
local function Update(self, event, unit)
|
|
local petInfo = self.pbouf_petinfo
|
|
if not petInfo then
|
|
return
|
|
end
|
|
|
|
local element = self.PBExperience
|
|
|
|
--[[ Callback: Experience:PreUpdate(unit)
|
|
Called before the element has been updated.
|
|
|
|
* self - the Experience element
|
|
* unit - the unit for which the update has been triggered (string)
|
|
--]]
|
|
if (element.PreUpdate) then
|
|
element:PreUpdate(unit)
|
|
end
|
|
|
|
local cur, max = C_PetBattles.GetXP(petInfo.petOwner, petInfo.petIndex)
|
|
local level = C_PetBattles.GetLevel(petInfo.petOwner, petInfo.petIndex)
|
|
if level == 25 then
|
|
max = 1
|
|
cur = 1
|
|
end
|
|
element:SetMinMaxValues(0, max)
|
|
|
|
element:SetValue(cur)
|
|
|
|
element.cur = cur
|
|
element.max = max
|
|
|
|
--[[ Callback: Experience:PostUpdate(unit, cur, max)
|
|
Called after the element has been updated.
|
|
|
|
* self - the Experience element
|
|
* unit - the unit for which the update has been triggered (string)
|
|
* cur - the unit's current Experience value (number)
|
|
* max - the unit's maximum possible Experience value (number)
|
|
--]]
|
|
if (element.PostUpdate) then
|
|
element:PostUpdate(unit, cur, max)
|
|
end
|
|
end
|
|
|
|
local function Path(self, event, ...)
|
|
if (self.isForced and event ~= "ElvUI_UpdateAllElements") then
|
|
return
|
|
end -- ElvUI changed
|
|
|
|
--[[ Override: Experience.Override(self, event, unit)
|
|
Used to completely override the internal update function.
|
|
|
|
* self - the parent object
|
|
* event - the event triggering the update (string)
|
|
* unit - the unit accompanying the event (string)
|
|
--]]
|
|
(self.PBExperience.Override or Update)(self, event, ...)
|
|
|
|
ColorPath(self, event, ...)
|
|
end
|
|
|
|
local function ForceUpdate(element)
|
|
Path(element.__owner, "ForceUpdate", element.__owner.unit)
|
|
end
|
|
|
|
local function Enable(self, unit)
|
|
local element = self.PBExperience
|
|
if (element) then
|
|
element.__owner = self
|
|
element.ForceUpdate = ForceUpdate
|
|
|
|
self:RegisterEvent("PET_BATTLE_XP_CHANGED", Path, true)
|
|
|
|
if (element:IsObjectType("StatusBar") and not element:GetStatusBarTexture()) then
|
|
element:SetStatusBarTexture([[Interface\TargetingFrame\UI-StatusBar]])
|
|
end
|
|
|
|
element:Show()
|
|
|
|
return true
|
|
end
|
|
end
|
|
|
|
local function Disable(self)
|
|
local element = self.PBExperience
|
|
if (element) then
|
|
element:Hide()
|
|
|
|
element:SetScript("OnUpdate", nil) -- ElvUI changed
|
|
self:UnregisterEvent("PET_BATTLE_XP_CHANGED", Path)
|
|
end
|
|
end
|
|
|
|
oUF:AddElement("PBExperience", Path, Enable, Disable)
|
|
|