WoWInterface SVN FuryCommander

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /
    from Rev 6 to Rev 7
    ↔ Reverse comparison
  •

Rev 6 → Rev 7

trunk/FuryCommander.lua
4,13 → 4,15
FC = { }
FC.VERSION = GetAddOnMetadata("FuryCommander", "Version")
 
function FuryCommander:InitBarArray()
FC.VAR = {
function FuryCommander:InitBarArray()
height = tonumber(string.match(GetCVar("gxResolution"), "%d+x(%d+)"))
width = tonumber(string.match(GetCVar("gxResolution"), "(%d+)x+%d"))
width = width*FuryCommander_Save.eyefinity--eyefinity is wird
FC.V = {
['bColor'] = {.1,.1,.1},
['wColor'] = {.6,.6,.6},
['resolution'] = GetCVar("gxResolution"),
['pxHeight'] = UIParent:GetHeight() / tonumber(string.match(GetCVar("gxResolution"), "%d+x(%d+)")) / GetCVar("uiScale"),
['pxWidth'] = UIParent:GetWidth() / tonumber(string.match(GetCVar("gxResolution"), "(%d+)x+%d")) / GetCVar("uiScale")
['pxH'] = UIParent:GetHeight() / height,
['pxW'] = UIParent:GetWidth() / width
}
FC.ICON = {
['BLT'] = {
27,117 → 29,6
['obj'] = 0,
['expire'] = 0
},
['KS'] = {
['obj'] = 0,
['expire'] = 0,
['name'] = FC_SPELL_KS,
['type'] = 2
},
['CS'] = {
['obj'] = 0,
['expire'] = 0,
['name'] = FC_SPELL_CS,
['type'] = 2
},
['EA'] = {
['obj'] = 0,
['expire'] = 0,
['name'] = FC_SPELL_EA,
['type'] = 2
},
['VEN'] = {
['obj'] = 0,
['expire'] = 0,
['name'] = FC_SPELL_VEN,
['type'] = 2
},
['VENCD'] = {
['obj'] = 0,
['expire'] = 0,
['name'] = FC_SPELL_VEN,
['type'] = 2
},
['ToT'] = {
['obj'] = 0,
['expire'] = 0,
['name'] = FC_SPELL_TOT,
['type'] = 1
},
['SnD'] = {
['obj'] = 0,
['expire'] = 0,
['name'] = FC_SPELL_SND,
['type'] = 1
},
['FE'] = {
['obj'] = 0,
['expire'] = 0,
['name'] = FC_SPELL_FE,
['type'] = 1
},
['FECD'] = {
['obj'] = 0,
['expire'] = 0,
['name'] = FC_SPELL_FE,
['type'] = 1
},
['DP'] = {
['obj'] = 0,
['expire'] = 0,
['name'] = FC_SPELL_DP,
['type'] = 2,
['count'] = 0
},
['ENV'] = {
['obj'] = 0,
['expire'] = 0,
['name'] = FC_SPELL_ENV,
['type'] = 1
},
['REC'] = {
['obj'] = 0,
['expire'] = 0,
['tick'] = {
['obj'] = {},
['expire'] = {}
},
['name'] = FC_SPELL_REC,
['type'] = 1
},
['RUP'] = {
['obj'] = 0,
['expire'] = 0,
['tick'] = {
['obj'] = {},
['expire'] = {},
['value'] = 2
},
['name'] = FC_SPELL_RUP,
['type'] = 2
},
['GAR'] = {
['obj'] = 0,
['expire'] = 0,
['tick'] = {
['obj'] = {},
['expire'] = {},
['value'] = 3
},
['name'] = FC_SPELL_GAR,
['type'] = 2
},
['AR'] = {
['obj'] = 0,
['expire'] = 0,
['name'] = FC_SPELL_AR,
['type'] = 1,
},
['ARCD'] = {
['obj'] = 0,
['expire'] = 0,
['name'] = FC_SPELL_AR,
['type'] = 1,
}
}
end
 
182,7 → 73,7
end
 
function FuryCommander:ChangeAnchor()
offSetSize = FuryCommander_Save.BarMargin -- other good values, -1, -2
offSetSize = FuryCommander_Save.BarMargin*FC.V.pxH -- other good values, -1, -2
LastAnchorNeg = VTimerRage
AnchorFromNeg = "BOTTOMRIGHT"
AnchorToNeg = "TOPRIGHT"
201,6 → 92,11
FC.BARS['CS']['obj']:SetPoint(AnchorFromPos, LastAnchorPos, AnchorToPos, 0, offSetSize*-1)
LastAnchorPos = FC.BARS['CS']['obj']
end
if FuryCommander_Save.Pos.CP == i and FC.BARS['CP']['expire'] ~= 0 then
FC.BARS['CP']['obj']:ClearAllPoints()
FC.BARS['CP']['obj']:SetPoint(AnchorFromPos, LastAnchorPos, AnchorToPos, 0, offSetSize*-1)
LastAnchorPos = FC.BARS['CP']['obj']
end
if FuryCommander_Save.Pos.REC == i and FC.BARS['REC']['expire'] ~= 0 then
FC.BARS['REC']['obj']:ClearAllPoints()
FC.BARS['REC']['obj']:SetPoint(AnchorFromPos, LastAnchorPos, AnchorToPos, 0, offSetSize*-1)
288,6 → 184,11
FC.BARS['CS']['obj']:SetPoint(AnchorFromNeg, LastAnchorNeg, AnchorToNeg, 0, offSetSize)
LastAnchorNeg = FC.BARS['CS']['obj']
end
if FuryCommander_Save.Pos.CP == i*-1 and FC.BARS['CP']['expire'] ~= 0 then
FC.BARS['CP']['obj']:ClearAllPoints()
FC.BARS['CP']['obj']:SetPoint(AnchorFromNeg, LastAnchorNeg, AnchorToNeg, 0, offSetSize)
LastAnchorNeg = FC.BARS['CP']['obj']
end
if FuryCommander_Save.Pos.REC == i*-1 and FC.BARS['REC']['expire'] ~= 0 then
FC.BARS['REC']['obj']:ClearAllPoints()
FC.BARS['REC']['obj']:SetPoint(AnchorFromNeg, LastAnchorNeg, AnchorToNeg, 0, offSetSize)
384,11 → 285,6
end
end
 
function FuryCommander:PLAYER_TARGET_CHANGED(eventName, arg1)
--FC.OTHER['HEALTH']['obj']:Hide()
FuryCommander:ChangeAnchor()
end
 
function FuryCommander:OnDisable()
FuryCommander:UnregisterAllEvents()
end
403,58 → 299,98
bgFile="Interface\\AddOns\\FuryCommander\\Images\\solid.tga",
edgeFile="",
tile=true, tileSize=1, edgeSize=0,
insets={left=-1, right=-1, top=-1, bottom=-1}
insets={left=-1*FC.V.pxW, right=-1*FC.V.pxW, top=-1*FC.V.pxH, bottom=-1*FC.V.pxH}
})
f:SetBackdropBorderColor(1,1,1,1)
f:SetBackdropColor(.1,.1,.1)
f:SetBackdropBorderColor(unpack(FC.V.wColor))
f:SetBackdropColor(unpack(FC.V.bColor))
f:SetFrameStrata("MEDIUM")
 
-- text on the right --
f.text = f:CreateFontString(nil, nil, "GameFontWhite")
f.text:SetFontObject(FC.BarFont2)
f.text:SetWidth(40)
f.text:SetPoint("TOPRIGHT", f, "TOPRIGHT", -5, 0)
f.text:SetWidth(40*FC.V.pxW)
f.text:SetPoint("TOPRIGHT", f, "TOPRIGHT", -5*FC.V.pxW, 0)
f.text:SetJustifyH("RIGHT")
 
f.iconBackground = f:CreateTexture(nil, "BACKGROUND")
f.iconBackground:SetPoint("RIGHT", f, "LEFT", -2*FC.V.pxW, 0)
f.iconBackground:SetTexture(unpack(FC.V.bColor))
 
f.icon = f:CreateTexture(nil, "OVERLAY")
f.icon:SetPoint("BOTTOMLEFT", f.iconBackground, "BOTTOMLEFT", 1, 1)
f.iconBackground:SetPoint("TOPRIGHT", f, "TOPLEFT", 0, 1)
f.icon:SetPoint("CENTER", f.iconBackground, "CENTER", 0, 0)
f.icon:SetTexCoord(.08, .92, .08, .92)
f.iconBackground:SetTexture(.1,.1,.1, 1)
 
-- Count on the icon --
f.textIcon = f:CreateFontString(nil, "OVERLAY", nil)
f.textIcon:SetFontObject(FC.BarFont2)
f.textIcon:SetPoint("CENTER", f.icon , "CENTER", f.icon:GetHeight()+4, 0)
f.textIcon:SetJustifyH("CENTER")
 
-- text on the left --
f.text2 = f:CreateFontString(nil, nil, nil)
f.text2:SetPoint("TOPLEFT", f, "TOPLEFT", 2, 0)
f.text2:SetPoint("TOPLEFT", f, "TOPLEFT", 2*FC.V.pxW, 0)
f.text2:SetFontObject(FC.BarFont2)
f.text2:SetWidth(120)
f.text2:SetWidth(120*FC.V.pxW)
f.text2:SetPoint("RIGHT", f, "RIGHT", 0, 0)
f.text2:SetJustifyH("CENTER")
 
f:SetStatusBarColor(r, g, b)
f.border = FuryCommander:tukSkin(f, false)
f.iconBorder = FuryCommander:tukSkin(f, f.icon)
 
return f
 
end
 
function FuryCommander:CPFrame()
f = CreateFrame("StatusBar", nil, UIParent)
 
f.bg = f:CreateTexture(nil, "BACKGROUND")
f.bg:SetPoint("TOPLEFT", f, "TOPLEFT", 0, 0)
f.bg:SetPoint("BOTTOMRIGHT", f, "BOTTOMRIGHT", 0, 0)
f:SetBackdrop({
bgFile="Interface\\AddOns\\FuryCommander\\Images\\solid.tga",
edgeFile="",
tile=false, tileSize=1, edgeSize=0,
insets={left=-1*FC.V.pxW, right=-1*FC.V.pxW, top=-1*FC.V.pxH, bottom=-1*FC.V.pxH}
})
f:SetBackdropBorderColor(unpack(FC.V.wColor))
f:SetBackdropColor(unpack(FC.V.bColor))
f:SetFrameStrata("MEDIUM")
 
f.combos = {}
 
for i = 1, 5 do
combo = CreateFrame("Frame", nil, f)
combo.bg = combo:CreateTexture(nil, "BACKGROUND")
combo.bg:SetAllPoints(combo)
combo.bg:SetTexture("Interface\\AddOns\\FuryCommander\\Images\\solid.tga")
combo:Hide()
f.combos[i] = combo
end
 
f.overlay = CreateFrame("Frame", nil, f)
f.overlay:SetAllPoints(f)
 
f.comboText = f.overlay:CreateFontString(nil, "OVERLAY")
f.comboText:SetFontObject(FC.BarFont4)
f.comboText:SetWidth(120*FC.V.pxW)
f.comboText:SetJustifyH("CENTER")
f.comboText:SetAllPoints(f.overlay)
 
f.border = FuryCommander:tukSkin(f, false)
 
f:Hide()
return f
 
end
function FuryCommander:CreateCore()
FuryCommanderFrame = CreateFrame('Frame', 'FuryCommanderFrame', UIParent)
FuryCommanderFrame:SetToplevel(true)
FuryCommanderFrame:EnableMouse(false)
FuryCommanderFrame:SetMovable(true)
FuryCommanderFrame:SetWidth(28)
FuryCommanderFrame:SetHeight(28)
FuryCommanderFrame:SetWidth(28*FC.V.pxW)
FuryCommanderFrame:SetHeight(28*FC.V.pxH)
FuryCommanderFrame:SetPoint(FuryCommander_Save.point, FuryCommander_Save.relativeTo, FuryCommander_Save.relativePoint, FuryCommander_Save.xOfs, FuryCommander_Save.yOfs)
FuryCommanderFrame:SetBackdrop({
bgFile="Interface\\AddOns\\FuryCommander\\Images\\solid.tga",
edgeFile="",
tile=true, tileSize=1, edgeSize=0,
insets={left=-1, right=-1, top=-1, bottom=-1}
insets={left=-1*FC.V.pxW, right=-1*FC.V.pxW, top=-1*FC.V.pxH, bottom=-1*FC.V.pxH}
})
FuryCommanderFrame:SetBackdropColor(0.7,0.2,0.2,1)
FuryCommanderFrame:SetScript("OnMouseDown",function () FuryCommander:MoveStart(FuryCommanderFrame) end)
462,7 → 398,7
FuryCommanderFrame:SetScript("OnUpdate",function () FuryCommander:OnUpdate() end)
 
VTimerRage = CreateFrame('StatusBar', 'VTimerRage', UIParent)
VTimerRage:SetSize(200,20)
VTimerRage:SetSize(200*FC.V.pxW,20*FC.V.pxH)
VTimerRage:SetMinMaxValues(0,100)
VTimerRage:SetPoint('TOPLEFT', FuryCommanderFrame, 'TOPRIGHT', 0, 0)
VTimerRage:SetFrameLevel(1)
470,30 → 406,34
VTimerRage:SetBackdrop({
bgFile="Interface\\AddOns\\FuryCommander\\Images\\solid.tga",
edgeFile="",
tile=true, tileSize=0, edgeSize=0,
insets={left=0, right=0, top=0, bottom=0}
tile=true, tileSize=1, edgeSize=0,
insets={left=-1*FC.V.pxW, right=-1*FC.V.pxW, top=-1*FC.V.pxH, bottom=-1*FC.V.pxH}
})
VTimerRage:SetBackdropBorderColor(1,1,1,1)
VTimerRage:SetBackdropColor(.1,.1,.1)
VTimerRage:SetBackdropBorderColor(unpack(FC.V.wColor))
VTimerRage:SetBackdropColor(unpack(FC.V.bColor))
VTimerRage:SetStatusBarTexture(FuryCommander:BarTexture())
VTimerRage:SetFrameStrata("MEDIUM")
VTimerRage:SetFrameLevel(1)
VTimerRage:SetStatusBarColor(234/255, 234/255, 234/255)
if FuryCommander_Save.HideEnergy then
if FuryCommander_Save.HideRage then
VTimerRage:Hide()
else
VTimerRage:Show()
end
 
VTimerRage.border = FuryCommander:tukSkin(VTimerRage, false)
--VTimerRage.border = { }
 
VTimerRageTxt = VTimerRage:CreateFontString('VTimerRageTxt', 'OVERLAY', GameFontWhite)
VTimerRageTxt:SetJustifyH("RIGHT")
VTimerRageTxt:SetSize(49,20)
VTimerRageTxt:SetPoint('RIGHT', VTimerRage, 'RIGHT', -5, 0)
VTimerRageTxt:SetSize(49*FC.V.pxW,20*FC.V.pxH)
VTimerRageTxt:SetPoint('RIGHT', VTimerRage, 'RIGHT', -5*FC.V.pxW, 0)
VTimerRageTxt:SetFontObject(FC.BarFont1)
 
FuryCommander_Combo = VTimerRage:CreateFontString('FuryCommander_Combo', 'OVERLAY', GameFontWhite)
FuryCommander_Combo:SetJustifyH("LEFT")
FuryCommander_Combo:SetSize(20,20)
FuryCommander_Combo:SetPoint('TOPLEFT', VTimerRage, 'TOPLEFT', 5, 0)
FuryCommander_Combo:SetSize(20*FC.V.pxW,20*FC.V.pxH)
FuryCommander_Combo:SetPoint('TOPLEFT', VTimerRage, 'TOPLEFT', 5*FC.V.pxW, 0)
FuryCommander_Combo:SetFontObject(FC.BarFont3)
 
FuryCommander_Spark = {}
501,7 → 441,7
FuryCommander_Spark[i] = VTimerRage:CreateTexture(nil, 'OVERLAY', GameFontWhite)
FuryCommander_Spark[i]:SetTexture("Interface\\CastingBar\\UI-CastingBar-Spark")
FuryCommander_Spark[i]:SetBlendMode('ADD')
FuryCommander_Spark[i]:SetSize(5,20)
FuryCommander_Spark[i]:SetSize(5*FC.V.pxW,20*FC.V.pxH)
end
end
 
509,7 → 449,7
for i = 1, 3 do
BAR['tick']['obj'][i] = BAR['obj']:CreateTexture('FuryCommander_Spark3', 'OVERLAY', GameFontWhite)
BAR['tick']['obj'][i]:SetTexture('Interface\\AddOns\\FuryCommander\\Images\\solid.tga')
BAR['tick']['obj'][i]:SetWidth(1)
BAR['tick']['obj'][i]:SetWidth(1*FC.V.pxW)
BAR['tick']['obj'][i]:SetVertexColor(226/255, 226/255, 226/255, 0.75)
end
end
519,8 → 459,8
MoveFrame:SetToplevel(true)
MoveFrame:EnableMouse(false)
MoveFrame:SetMovable(true)
MoveFrame:SetWidth(28*FC.VAR.pxWidth)
MoveFrame:SetHeight(28*FC.VAR.pxWidth)
MoveFrame:SetWidth(28*FC.V.pxW)
MoveFrame:SetHeight(28*FC.V.pxW)
MoveFrame:SetPoint(point, relativeTo, relativePoint, xOfs, yOfs)
MoveFrame:SetBackdrop({
bgFile="Interface\\AddOns\\FuryCommander\\Images\\solid.tga",
533,116 → 473,118
MoveFrame:SetScript("OnMouseUp",function () FuryCommander:MoveStop(MoveFrame) end)
MoveFrame:SetScript("OnUpdate",function () FuryCommander:OnUpdate() end)
 
f = CreateFrame("Button", name..'button', UIParent)
f = CreateFrame("Frame", name..'button', UIParent)
f:SetPoint('TOPLEFT', MoveFrame:GetName(), 'TOPRIGHT', 0, 0)
f:SetFrameStrata("LOW")
f:SetWidth(50*FC.VAR.pxWidth)
f:SetHeight(50*FC.VAR.pxHeight)
f:Hide()
f:Disable()
f:SetFrameStrata("MEDIUM")
f:SetFrameLevel(1)
f:SetWidth(50*FC.V.pxW)
f:SetHeight(50*FC.V.pxH)
--f:Hide()
f:Show()
f:SetDisabledTexture(icon)
f:SetDisabledFontObject(FC.BarFontIcon)
f:SetText(10)
 
FuryCommander:tukSkin(f)
iconSpell = f:CreateTexture(name..'icon')
iconSpell:SetAllPoints(f)
iconSpell:SetTexture(icon)
iconSpell:SetTexCoord(.08, .92, .08, .92)
 
f.overlayGrey = CreateFrame('Frame', nil, f)
f.overlayGrey:SetFrameStrata("MEDIUM")
f.overlayGrey:SetWidth(50*FC.VAR.pxWidth)
f.overlayGrey:SetHeight(50*FC.VAR.pxWidth)
f.overlayGrey:SetPoint('TOP', f:GetName(), 'TOP', 0, 0)
f.overlayGrey:SetBackdrop({
bgFile="Interface\\AddOns\\FuryCommander\\Images\\solid.tga",
edgeFile="",
tile=true, tileSize=1, edgeSize=0,
insets={left=-1, right=-1, top=-1, bottom=-1}
})
f.overlayGrey:SetBackdropColor(.5,.5,.5,.5)
f.overlayGrey:Show()
f.overlayGrey:Hide()
FuryCommander:tukSkin(f, false)
 
f.overlayBlue = CreateFrame('Frame', nil, f)
f.overlayBlue:SetFrameStrata("MEDIUM")
f.overlayBlue:SetWidth(50*FC.VAR.pxWidth)
f.overlayBlue:SetHeight(50*FC.VAR.pxWidth)
f.overlayBlue:SetPoint('TOP', f:GetName(), 'TOP', 0, 0)
f.overlayBlue:SetBackdrop({
f.overlay = CreateFrame('Frame', nil, f)
f.overlay:SetFrameStrata("MEDIUM")
f.overlay:SetFrameLevel(2)
f.overlay:SetWidth(50*FC.V.pxW)
f.overlay:SetHeight(50*FC.V.pxH)
f.overlay:SetPoint('CENTER', f:GetName(), 'CENTER', 0, 0)
f.overlay:SetBackdrop({
bgFile="Interface\\AddOns\\FuryCommander\\Images\\solid.tga",
edgeFile="",
tile=true, tileSize=1, edgeSize=0,
insets={left=-1, right=-1, top=-1, bottom=-1}
insets={left=0, right=0, top=0, bottom=0}
})
f.overlayBlue:SetBackdropColor(0,0,1,.5)
f.overlayBlue:Hide()
--f.overlayBlue
--f.overlay:SetBackdropColor(0,0,0,.7)
f.overlay:SetBackdropColor(.1,.1,.8,.5)
f.overlay:Show()
 
 
--f:SetFormattedText("10")
 
print(f:GetText())
 
 
f.iconTxt = f.overlay:CreateFontString(nil, 'OVERLAY', GameFontWhite)
f.iconTxt:SetJustifyH("CENTER")
f.iconTxt:SetJustifyV("MIDDLE")
f.iconTxt:SetSize(50*FC.V.pxW,50*FC.V.pxH)
f.iconTxt:SetPoint('CENTER', f, "CENTER", 0, 0)
f.iconTxt:SetFontObject(FC.BarFontIcon)
f.iconTxt:SetShadowColor(0,0,0,1)
f.iconTxt:SetShadowOffset(2*FC.V.pxW, -2*FC.V.pxH)
f.iconTxt:SetText(10)
 
return f, MoveFrame
end
 
function FuryCommander:CreateTextureSkin(frame, anchor, xOfs, yOfs, w, h, color)
t = frame:CreateTexture(nil, "OVERLAY")
t:SetTexture("Interface\\AddOns\\SliceCommander\\Images\\solid.tga")
t:SetSize(w,h)
t:SetPoint(anchor, frame:GetName(), anchor, xOfs, yOfs)
t:SetVertexColor(unpack(color))
t:Show()
end
 
function FuryCommander:tukSkin(frame)
pxHeight = FC.VAR.pxHeight
pxWidth = FC.VAR.pxWidth
 
bColor = FC.VAR.bColor
wColor = FC.VAR.wColor
 
h = frame:GetHeight()
w = frame:GetWidth()
 
FuryCommander:CreateTextureSkin(frame, "TOP", 0, 0, w, pxHeight, bColor)
FuryCommander:CreateTextureSkin(frame, "BOTTOM", 0, 0, w, pxHeight, bColor)
FuryCommander:CreateTextureSkin(frame, "RIGHT", 0, 0, pxWidth, h, bColor)
FuryCommander:CreateTextureSkin(frame, "LEFT", 0, 0, pxWidth, h, bColor)
 
w = w-2*pxWidth
h = h-2*pxHeight
FuryCommander:CreateTextureSkin(frame, "TOP", 0, -pxHeight, w, pxHeight, wColor)
FuryCommander:CreateTextureSkin(frame, "BOTTOM", 0, pxHeight, w, pxHeight, wColor)
FuryCommander:CreateTextureSkin(frame, "RIGHT", -pxWidth, 0, pxWidth, h, wColor)
FuryCommander:CreateTextureSkin(frame, "LEFT", pxWidth, 0, pxWidth, h, wColor)
 
w = w-2*pxWidth
h = h-2*pxHeight
FuryCommander:CreateTextureSkin(frame, "TOP", 0, -(2*pxHeight), w, pxHeight, bColor)
FuryCommander:CreateTextureSkin(frame, "BOTTOM", 0, (2*pxHeight), w, pxHeight, bColor)
FuryCommander:CreateTextureSkin(frame, "RIGHT", -(2*pxWidth), 0, pxWidth, h, bColor)
FuryCommander:CreateTextureSkin(frame, "LEFT", (2*pxWidth), 0, pxWidth, h, bColor)
 
collectgarbage()
end
 
function FuryCommander:NewFont(name, FontSize, aShadow, rColor, gColor, bColor)
f = CreateFont(name)
f:SetFont("Interface\\AddOns\\FuryCommander\\Fonts\\FRIZQT__.TTF", FontSize)
f:SetTextColor(rColor, gColor, bColor, 1)
f:SetShadowColor(0, 0, 0, aShadow)
f:SetShadowOffset(2, -2)
f:SetTextColor(rColor, gColor, bColor, 1)
f:SetShadowOffset(0.8, -0.8)
 
return f
end
 
function FuryCommander:PLAYER_LOGIN()
FuryCommander:ApplyConf()
FuryCommander:tukSkin(VTimerRage)
collectgarbage()
function FuryCommander:ApplySkin(isApply)
if isApply then
for i,v in pairs(FC.BARS) do
if i ~= 'MH' and i ~= 'OH' then
if i ~= 'THREAT' and i ~= 'CP' then
v['obj'].iconBackground:ClearAllPoints()
v['obj'].iconBackground:SetPoint("RIGHT", v['obj'], "LEFT", -6*FC.V.pxW, 0)
v['obj']:SetWidth(v['obj']:GetWidth()-4*FC.V.pxW)
end
FuryCommander:SetSizeBorder(v['obj'], v['obj'].border)
FuryCommander:SetSizeBorder(VTimerRage, VTimerRage.border)
end
end
else
for i,v in pairs(FC.BARS) do
if i ~= 'MH' and i ~= 'OH' and i ~= 'THREAT' and i ~= 'CP' then
v['obj'].iconBackground:ClearAllPoints()
v['obj'].iconBackground:SetPoint("RIGHT", v['obj'], "LEFT", -2*FC.V.pxW, 0)
v['obj']:SetWidth(v['obj']:GetWidth()+4*FC.V.pxW)
FuryCommander:SetSizeBorder(v['obj'], v['obj'].border)
FuryCommander:SetSizeBorder(VTimerRage, VTimerRage.border)
end
end
end
end
 
function FuryCommander:CreateTextureSkin(frame, w, h, color, level, texture)
t = CreateFrame('Frame', nil, frame)
t:SetBackdrop({
bgFile="Interface\\AddOns\\FuryCommander\\Images\\solid.tga",
edgeFile="",
tile=true, tileSize=1, edgeSize=0,
insets={left=0, right=0, top=0, bottom=0}
})
t:SetFrameLevel(level)
t:SetFrameStrata("LOW")
t:SetBackdropColor(unpack(color))
if texture then
t:SetPoint("CENTER", texture, "CENTER", 0, 0)
t:SetSize(texture:GetWidth()+w, texture:GetHeight()+h)
else
t:SetPoint("CENTER", frame, "CENTER", 0, 0)
t:SetSize(frame:GetWidth()+w, frame:GetHeight()+h)
end
t:Show()
 
return t
end
 
function FuryCommander:tukSkin(frame, texture)
return {
[1] = FuryCommander:CreateTextureSkin(frame, 6*FC.V.pxW, 6*FC.V.pxH, FC.V.bColor, 1, texture),
[2] = FuryCommander:CreateTextureSkin(frame, 4*FC.V.pxW, 4*FC.V.pxH, FC.V.wColor, 2, texture),
[3] = FuryCommander:CreateTextureSkin(frame, 2*FC.V.pxW, 2*FC.V.pxH, FC.V.bColor, 3, texture)
}
end
 
function FuryCommander:AbilityCDBar(BAR, display)
if display ~= true then
if BAR['obj']:IsVisible() then
788,16 → 730,6
end
end
end
elseif soundTest == 3 and BAR['expire'] > last then
if FuryCommander_Save.ARMarioMod then
if duration > 16 then
FuryCommander:Sound('ARSound_Glyphed')
else
FuryCommander:Sound('ARSound')
end
end
BAR['cd'] = true
BAR['obj']:SetStatusBarColor(226/255, 130/255, 90/255)
end
else
if BAR['obj']:IsVisible() then
920,19 → 852,6
end
end
 
function FuryCommander:TestBF()
if FuryCommander_Save.display.BF then
name = UnitAura("player", FC_SPELL_BF, nil, "PLAYER")
if name and not FC.OTHER['BF']['obj']:IsVisible() then
FC.OTHER['BF']['obj']:Show()
elseif not name and FC.OTHER['BF']['obj']:IsVisible() then
FC.OTHER['BF']['obj']:Hide()
end
else
FC.OTHER['BF']['obj']:Hide()
end
end
 
function FuryCommander:Latency()
FC.tNow = GetTime()
if (FuryCommander_Save.PadLatency) then
943,17 → 862,14
 
function FuryCommander:Rage()
VTimerRage:SetValue(UnitMana("player"))
VTimerRage:SetMinMaxValues(0,100)
VTimerRage:SetMinMaxValues(0,UnitManaMax("player"))
VTimerRageTxt:SetText(VTimerRage:GetValue())
 
if FC.LastEnergy < FuryCommander_Save.Energy2 and UnitMana('player') >= FuryCommander_Save.Energy2 then
FuryCommander:Sound("EnergySound2")
elseif FC.LastEnergy < FuryCommander_Save.Energy1 and UnitMana('player') >= FuryCommander_Save.Energy1 then
FuryCommander:Sound("EnergySound1")
elseif FC.LastEnergy < FuryCommander_Save.Energy3 and UnitMana('player') >= FuryCommander_Save.Energy3 then
FuryCommander:Sound("EnergySound3")
 
if 0 == UnitMana('player') and UnitAffectingCombat("player")~=1 then
VTimerRage:SetAlpha(FuryCommander_Save.RageTrans)
else
VTimerRage:SetAlpha(FuryCommander_Save.FrameOpacity)
end
FC.LastEnergy = UnitMana('player')
end
 
function FuryCommander:Bloodthirst()
972,30 → 888,11
end
 
function FuryCommander:OnUpdate()
FuryCommander:Rage()--Update Rage value and play sound if necessary
FuryCommander:Rage()--Update energy value and play sound if necessary
FuryCommander:Latency()--Update timer reference and latency
 
FuryCommander:TargetThreat()--Update Threat Bar
 
FuryCommander:Bloodthirst()
 
--[[RUP_AlertPending = FuryCommander:UpdateBar(FC.BARS['RUP'], FuryCommander_Save.display.RUP, soundRup, RUP_AlertPending, 2, 2)--Update Rupture Bar
SND_AlertPending = FuryCommander:UpdateBar(FC.BARS['SnD'], FuryCommander_Save.display.SnD, soundSnd, SND_AlertPending, false, 1)--Update SnD Bar
FuryCommander:UpdateBar(FC.BARS['REC'], FuryCommander_Save.display.REC, nil, nil, 3, 0)--Update Recuprate Bar
FuryCommander:UpdateBar(FC.BARS['GAR'], FuryCommander_Save.display.GAR, nil, nil, 3, 0)--Update Garrote Bar
FuryCommander:UpdateBar(FC.BARS['EA'], FuryCommander_Save.display.EA, nil, nil, false, 0)--Update Expose Armor Bar
FuryCommander:UpdateBar(FC.BARS['FE'], FuryCommander_Save.display.FE, nil, nil, false, 0)--Update Feint Bar
FuryCommander:UpdateBar(FC.BARS['KS'], FuryCommander_Save.display.KS, nil, nil, false, 0)--Update Kidney Shot Bar
FuryCommander:UpdateBar(FC.BARS['CS'], FuryCommander_Save.display.CS, nil, nil, false, 0)--Update Cheap Shot Bar
FuryCommander:UpdateBar(FC.BARS['DP'], FuryCommander_Save.display.DP, nil, nil, false, 0)--Update Deadly poison Bar
FuryCommander:UpdateBar(FC.BARS['ENV'], FuryCommander_Save.display.ENV, nil, nil, false, 0)--Update Envenom Bar
FuryCommander:UpdateBar(FC.BARS['VEN'], FuryCommander_Save.display.VEN, nil, nil, false, 0)--Update Vendetta Bar
FuryCommander:UpdateBar(FC.BARS['AR'], FuryCommander_Save.display.AR, nil, nil, false, 3)--Update Adrenaline rush Bar
FuryCommander:AbilityCDBar(FC.BARS['VENCD'], FuryCommander_Save.display.VENCD)--Update Vendetta CD bar
FuryCommander:AbilityCDBar(FC.BARS['ToT'], FuryCommander_Save.display.ToT)--Update ToT CD bar
FuryCommander:AbilityCDBar(FC.BARS['ARCD'], FuryCommander_Save.display.ARCD)--Update Adrenaline rush CD bar
FuryCommander:AbilityCDBar(FC.BARS['FECD'], FuryCommander_Save.display.FE)--Update Feint CD bar
FuryCommander:TestBF()--Update BF bar display]]
end
 
do
1004,7 → 901,13
 
SLASH_FURYCOMMANDER1 = "/furycommander"
SLASH_FURYCOMMANDER2 = "/fc"
SlashCmdList["FURYCOMMANDER"] = function(msg)
InterfaceOptionsFrame_OpenToCategory("FuryCommander")
SlashCmdList["FURYCOMMANDER"] = function(msg, editbox)
local command, rest = msg:match("^(%S*)%s*(.-)$")
if command == "eyefinity" and tonumber(rest) then
FuryCommander_Save.eyefinity = rest
ReloadUI()
else
InterfaceOptionsFrame_OpenToCategory("FuryCommander")
end
end
end
\ No newline at end of file
trunk/Config.lua
1,252 → 1,9
local AceConfigDialog = LibStub("AceConfigDialog-3.0")
local AceConfig = LibStub("AceConfig-3.0")
 
SC_OptionsTable_Sound = {
name = SC_LANG_SOUND,
handler = SliceCommander,
type = "group",
args = {--Sound settings
headerSndSoundSetting = {--Slice and Dice
order = 1,
name = "Slice and Dice",
type = "header"
},
Tick3 = {--Alert - 3 sec
order = 2,
name = "Alert - 3 sec",
desc = "Alert 3 secondes before fade",
type = "select",
values = function()
return SliceCommander:ConfigSoundMenuInit("Tick")
end,
set = function(info,val)
SliceCommander:SoundTest(val)
SliceCommander_Save.Tick3 = val
end,
get = function(info) return SliceCommander_Save.Tick3 end
},
Tick2 = {--Alert - 2 sec
order = 4,
name = "Alert - 2 sec",
desc = "Alert 2 secondes before fade",
type = "select",
values = function()
return SliceCommander:ConfigSoundMenuInit("Tick")
end,
set = function(info,val)
SliceCommander:SoundTest(val)
SliceCommander_Save.Tick2 = val
end,
get = function(info) return SliceCommander_Save.Tick2 end
},
Tick1 = {--Alert - 1 sec
order = 6,
name = "Alert - 1 sec",
desc = "Alert 1 secondes before fade",
type = "select",
values = function()
return SliceCommander:ConfigSoundMenuInit("Tick")
end,
set = function(info,val)
SliceCommander:SoundTest(val)
SliceCommander_Save.Tick1 = val
end,
get = function(info) return SliceCommander_Save.Tick1 end
},
Apply3 = {--Refresh - 3 sec
order = 3,
name = "Refresh - 3 sec",
desc = "Refresh 3 secondes before fade",
type = "select",
values = function()
return SliceCommander:ConfigSoundMenuInit("Apply")
end,
set = function(info,val)
SliceCommander:SoundTest(val)
SliceCommander_Save.Apply3 = val
end,
get = function(info) return SliceCommander_Save.Apply3 end
},
Apply2 = {--Refresh - 2 sec
order = 5,
name = "Refresh - 2 sec",
desc = "Refresh 2 secondes before fade",
type = "select",
values = function()
return SliceCommander:ConfigSoundMenuInit("Apply")
end,
set = function(info,val)
SliceCommander:SoundTest(val)
SliceCommander_Save.Apply2 = val
end,
get = function(info) return SliceCommander_Save.Apply2 end
},
Apply1 = {--Refresh - 1 sec
order = 7,
name = "Refresh - 1 sec",
desc = "Refresh 1 secondes before fade",
type = "select",
values = function()
return SliceCommander:ConfigSoundMenuInit("Apply")
end,
set = function(info,val)
SliceCommander:SoundTest(val)
SliceCommander_Save.Apply1 = val
end,
get = function(info) return SliceCommander_Save.Apply1 end
},
Fail = {--Faillure
order = 8,
name = "Faillure",
desc = "The refresh failled",
type = "select",
values = function()
return SliceCommander:ConfigSoundMenuInit("Fail")
end,
set = function(info,val)
SliceCommander:SoundTest(val)
SliceCommander_Save.Fail = val
end,
get = function(info) return SliceCommander_Save.Fail end
},
 
Applied = {--Applied
order = 9,
name = "Applied",
desc = "Slice and Dice is applied",
type = "select",
values = function()
return SliceCommander:ConfigSoundMenuInit("Apply")
end,
set = function(info,val)
SliceCommander:SoundTest(val)
SliceCommander_Save.Applied = val
end,
get = function(info) return SliceCommander_Save.Applied end
},
Expire = {--Expire
order = 10,
name = "Expired",
desc = "Slice and Dice buff expire",
type = "select",
values = function()
return SliceCommander:ConfigSoundMenuInit("Fail")
end,
set = function(info,val)
SliceCommander:SoundTest(val)
SliceCommander_Save.Expire = val
end,
get = function(info) return SliceCommander_Save.Expire end
},
headerRupSoundSetting = {--Rupture
order = 11,
name = "Rupture",
type = "header"
},
RUP_Alert = {--Alert
order = 12,
name = "Alert",
desc = "Alert 3, 2 and 1 secondes before fade",
type = "select",
values = function()
return SliceCommander:ConfigSoundMenuInit("Tick")
end,
set = function(info,val)
SliceCommander:SoundTest(val)
SliceCommander_Save.RUP_Alert = val
end,
get = function(info) return SliceCommander_Save.RUP_Alert end
},
RUP_Refresh3 = {--Refresh - 3 sec
order = 13,
name = "Refresh - 3 sec",
desc = "Refresh 3 secondes before fade",
type = "select",
values = function()
return SliceCommander:ConfigSoundMenuInit("Apply")
end,
set = function(info,val)
SliceCommander:SoundTest(val)
SliceCommander_Save.RUP_Refresh3 = val
end,
get = function(info) return SliceCommander_Save.RUP_Refresh3 end
},
RUP_Refresh2 = {--Refresh - 2 sec
order = 15,
name = "Refresh - 2 sec",
desc = "Refresh 2 secondes before fade",
type = "select",
values = function()
return SliceCommander:ConfigSoundMenuInit("Apply")
end,
set = function(info,val)
SliceCommander:SoundTest(val)
SliceCommander_Save.RUP_Refresh2 = val
end,
get = function(info) return SliceCommander_Save.RUP_Refresh2 end
},
RUP_Refresh1 = {--Refresh - 1 sec
order = 17,
name = "Refresh - 1 sec",
desc = "Refresh 1 secondes before fade",
type = "select",
values = function()
return SliceCommander:ConfigSoundMenuInit("Apply")
end,
set = function(info,val)
SliceCommander:SoundTest(val)
SliceCommander_Save.RUP_Refresh1 = val
end,
get = function(info) return SliceCommander_Save.RUP_Refresh1 end
},
RUP_Fail = {--Faillure
order = 14,
name = "Faillure",
desc = "The refresh failled",
type = "select",
values = function()
return SliceCommander:ConfigSoundMenuInit("Fail")
end,
set = function(info,val)
SliceCommander:SoundTest(val)
SliceCommander_Save.RUP_Fail = val
end,
get = function(info) return SliceCommander_Save.RUP_Fail end
},
RUP_Applied = {--Applied
order = 16,
name = "Applied",
desc = "Rupture is applied",
type = "select",
values = function()
return SliceCommander:ConfigSoundMenuInit("Apply")
end,
set = function(info,val)
SliceCommander:SoundTest(val)
SliceCommander_Save.RUP_Applied = val
end,
get = function(info) return SliceCommander_Save.RUP_Applied end
},
RUP_Expire = {--Expire
order = 18,
name = "Expired",
desc = "Rupture debuff expire",
type = "select",
values = function()
return SliceCommander:ConfigSoundMenuInit("Fail")
end,
set = function(info,val)
SliceCommander:SoundTest(val)
SliceCommander_Save.RUP_Expire = val
end,
get = function(info) return SliceCommander_Save.RUP_Expire end
},
}
}
 
SC_OptionsTable_DisplayTimer = {
name = SC_DISPLAY_SETTINGS,
handler = SliceCommander,
handler = FuryCommander,
type = "group",
args = {--Display setting
displayDescription = {
255,27 → 12,27
fontSize = "medium",
type = "description"
},
headerEnergySetting = {--Combo Point Settings
headerRageSetting = {--Combo Point Settings
order = 1,
name = "Energy bar Settings",
name = "Rage bar Settings",
type = "header"
},
HideEnergy = {--Hide Energy
HideRage = {--Hide Rage
order = 2,
name = "Hide Energy bar",
desc = "Hide the Energy bar",
name = "Hide Rage bar",
desc = "Hide the Rage bar",
type = "toggle",
set = function(info,val)
if val then
VTimerEnergy:Hide()
VTimerRage:Hide()
else
VTimerEnergy:Show()
VTimerRage:Show()
end
SliceCommander_Save.HideEnergy = val
FuryCommander_Save.HideRage = val
end,
get = function(info) return SliceCommander_Save.HideEnergy end
get = function(info) return FuryCommander_Save.HideRage end
},
EnergyTrans = {--Energy bar transparancy
RageTrans = {--Rage bar transparancy
order = 3,
name = "Transparency (Full)",
desc = "The fade out value of the energy bar when it is full.",
285,15 → 42,15
step = 1,
bigStep = 1,
set = function(info,val)
SliceCommander:SetPoisonTransparency(val)
SliceCommander_Save.EnergyTrans = val
VTimerRage:SetAlpha(val)
FuryCommander_Save.RageTrans = val
end,
get = function(info) return SliceCommander_Save.EnergyTrans end,
get = function(info) return FuryCommander_Save.RageTrans end,
isPercent = false
},
Energy1 = {--Energy Marker 1
Rage1 = {--Rage Marker 1
order = 4,
name = "Energy Marker 1",
name = "Rage Marker 1",
type = "range",
min = 0,
max = 120,
303,15 → 60,15
if val > UnitManaMax("player") then
val = UnitManaMax("player")
end
SliceCommander_Save.Energy1 = val
SliceCommander:Config_OtherVars()
FuryCommander_Save.Rage1 = val
FuryCommander:Config_OtherVars()
end,
get = function(info) return SliceCommander_Save.Energy1 end,
get = function(info) return FuryCommander_Save.Rage1 end,
isPercent = false
},
Energy2 = {--Energy Marker 2
Rage2 = {--Rage Marker 2
order = 5,
name = "Energy Marker 2",
name = "Rage Marker 2",
type = "range",
min = 0,
max = 120,
321,15 → 78,15
if val > UnitManaMax("player") then
val = UnitManaMax("player")
end
SliceCommander_Save.Energy2 = val
SliceCommander:Config_OtherVars()
FuryCommander_Save.Rage2 = val
FuryCommander:Config_OtherVars()
end,
get = function(info) return SliceCommander_Save.Energy2 end,
get = function(info) return FuryCommander_Save.Rage2 end,
isPercent = false
},
Energy3 = {--Energy Marker 3
Rage3 = {--Rage Marker 3
order = 6,
name = "Energy Marker 3",
name = "Rage Marker 3",
type = "range",
min = 0,
max = 120,
339,10 → 96,10
if val > UnitManaMax("player") then
val = UnitManaMax("player")
end
SliceCommander_Save.Energy3 = val
SliceCommander:Config_OtherVars()
FuryCommander_Save.Rage3 = val
FuryCommander:Config_OtherVars()
end,
get = function(info) return SliceCommander_Save.Energy3 end,
get = function(info) return FuryCommander_Save.Rage3 end,
isPercent = false
},
headerDPSetting = {--Poison bar Settings
356,9 → 113,9
desc = "Display the Poison timer bar",
type = "toggle",
set = function(info,val)
SliceCommander_Save.display.DP = val
FuryCommander_Save.display.DP = val
end,
get = function(info) return SliceCommander_Save.display.DP end
get = function(info) return FuryCommander_Save.display.DP end
},
PosDP = {--Poison position
order = 9,
373,9 → 130,9
return returnArray
end,
set = function(info,val)
SliceCommander_Save.Pos.DP = val
FuryCommander_Save.Pos.DP = val
end,
get = function(info) return SliceCommander_Save.Pos.DP end
get = function(info) return FuryCommander_Save.Pos.DP end
},
EnvenomShow = {--Show Envenom
order = 10,
383,9 → 140,9
desc = "The timer bar in default will display the timer of deadly poison on the target.",
type = "toggle",
set = function(info,val)
SliceCommander_Save.EnvenomShow = val
FuryCommander_Save.EnvenomShow = val
end,
get = function(info) return SliceCommander_Save.EnvenomShow end
get = function(info) return FuryCommander_Save.EnvenomShow end
},
PosENV = {--Poison position
order = 9,
400,9 → 157,9
return returnArray
end,
set = function(info,val)
SliceCommander_Save.Pos.ENV = val
FuryCommander_Save.Pos.ENV = val
end,
get = function(info) return SliceCommander_Save.Pos.ENV end
get = function(info) return FuryCommander_Save.Pos.ENV end
},
PoisonShow = {--Show Poison weapon enchant
order = 11,
410,9 → 167,9
desc = "Display two thin poison bar timer on the energy bar corresponding of each temporary enchant on each weapon.",
type = "toggle",
set = function(info,val)
SliceCommander_Save.display.Poison = val
FuryCommander_Save.display.Poison = val
end,
get = function(info) return SliceCommander_Save.display.Poison end
get = function(info) return FuryCommander_Save.display.Poison end
},
PoisonTransparencyShow = {--Show Poison weapon enchant
order = 12,
420,9 → 177,9
desc = "Disable energy bar and poison bar fade out when poison on weapon(s) is up",
type = "toggle",
set = function(info,val)
SliceCommander_Save.PoisonTransparencyShow = val
FuryCommander_Save.PoisonTransparencyShow = val
end,
get = function(info) return SliceCommander_Save.PoisonTransparencyShow end
get = function(info) return FuryCommander_Save.PoisonTransparencyShow end
},
headerVendettaSetting = {--Vendetta Settings
order = 101,
435,9 → 192,9
desc = "Display the vendetta timer bar",
type = "toggle",
set = function(info,val)
SliceCommander_Save.display.VEN = val
FuryCommander_Save.display.VEN = val
end,
get = function(info) return SliceCommander_Save.display.VEN end
get = function(info) return FuryCommander_Save.display.VEN end
},
PosVEN = {--Vendetta position
order = 103,
452,10 → 209,10
return returnArray
end,
set = function(info,val)
SliceCommander_Save.Pos.VEN = val
SliceCommander_Save.Pos.VENCD = val
FuryCommander_Save.Pos.VEN = val
FuryCommander_Save.Pos.VENCD = val
end,
get = function(info) return SliceCommander_Save.PosVEN end
get = function(info) return FuryCommander_Save.Pos.VEN end
},
headerToTSetting = {--Tricks of the Trade Settings
order = 104,
468,9 → 225,9
desc = "Display the Tricks of the Trade timer bar",
type = "toggle",
set = function(info,val)
SliceCommander_Save.display.ToT = val
FuryCommander_Save.display.ToT = val
end,
get = function(info) return SliceCommander_Save.display.ToT end
get = function(info) return FuryCommander_Save.display.ToT end
},
PosToT = {--ToT position
order = 106,
485,9 → 242,9
return returnArray
end,
set = function(info,val)
SliceCommander_Save.Pos.ToT = val
FuryCommander_Save.Pos.ToT = val
end,
get = function(info) return SliceCommander_Save.Pos.ToT end
get = function(info) return FuryCommander_Save.Pos.ToT end
},
headerRecSetting = {--Recuperate Settings
order = 110,
500,9 → 257,9
desc = "Display the Recuperate timer bar",
type = "toggle",
set = function(info,val)
SliceCommander_Save.display.REC = val
FuryCommander_Save.display.REC = val
end,
get = function(info) return SliceCommander_Save.display.REC end
get = function(info) return FuryCommander_Save.display.REC end
},
PosREC = {--Recuperate position
order = 112,
517,9 → 274,9
return returnArray
end,
set = function(info,val)
SliceCommander_Save.Pos.REC = val
FuryCommander_Save.Pos.REC = val
end,
get = function(info) return SliceCommander_Save.Pos.REC end
get = function(info) return FuryCommander_Save.Pos.REC end
},
headerKSSetting = {--Stun bar Settings
order = 113,
532,9 → 289,9
desc = "Display the Kidney shot timer bar",
type = "toggle",
set = function(info,val)
SliceCommander_Save.display.KS = val
FuryCommander_Save.display.KS = val
end,
get = function(info) return SliceCommander_Save.display.KS end
get = function(info) return FuryCommander_Save.display.KS end
},
PosKS = {--Stun position
order = 115,
549,9 → 306,9
return returnArray
end,
set = function(info,val)
SliceCommander_Save.Pos.KS = val
FuryCommander_Save.Pos.KS = val
end,
get = function(info) return SliceCommander_Save.Pos.KS end
get = function(info) return FuryCommander_Save.Pos.KS end
},
headerCSSetting = {--Stun bar Settings
order = 116,
564,9 → 321,9
desc = "Display the Cheap shot timer bar",
type = "toggle",
set = function(info,val)
SliceCommander_Save.display.CS = val
FuryCommander_Save.display.CS = val
end,
get = function(info) return SliceCommander_Save.display.CS end
get = function(info) return FuryCommander_Save.display.CS end
},
PosCS = {--Stun position
order = 118,
581,9 → 338,9
return returnArray
end,
set = function(info,val)
SliceCommander_Save.Pos.CS = val
FuryCommander_Save.Pos.CS = val
end,
get = function(info) return SliceCommander_Save.Pos.CS end
get = function(info) return FuryCommander_Save.Pos.CS end
},
headerRupSetting = {--Blood Settings
order = 121,
596,9 → 353,9
desc = "Display the Blood timer bar",
type = "toggle",
set = function(info,val)
SliceCommander_Save.display.RUP = val
FuryCommander_Save.display.RUP = val
end,
get = function(info) return SliceCommander_Save.display.RUP end
get = function(info) return FuryCommander_Save.display.RUP end
},
PosRUP = {--Blood position
order = 123,
613,9 → 370,9
return returnArray
end,
set = function(info,val)
SliceCommander_Save.Pos.RUP = val
FuryCommander_Save.Pos.RUP = val
end,
get = function(info) return SliceCommander_Save.Pos.RUP end
get = function(info) return FuryCommander_Save.Pos.RUP end
},
headerGarSetting = {--Blood Settings
order = 124,
628,9 → 385,9
desc = "Display the Garrote timer bar",
type = "toggle",
set = function(info,val)
SliceCommander_Save.display.GAR = val
FuryCommander_Save.display.GAR = val
end,
get = function(info) return SliceCommander_Save.display.GAR end
get = function(info) return FuryCommander_Save.display.GAR end
},
PosGAR = {--Blood position
order = 126,
645,9 → 402,9
return returnArray
end,
set = function(info,val)
SliceCommander_Save.Pos.GAR = val
FuryCommander_Save.Pos.GAR = val
end,
get = function(info) return SliceCommander_Save.Pos.GAR end
get = function(info) return FuryCommander_Save.Pos.GAR end
},
headerSndSetting = {--Slice and Dice Settings
order = 127,
660,9 → 417,9
desc = "Display the Slice and Dice timer bar",
type = "toggle",
set = function(info,val)
SliceCommander_Save.display.SnD = val
FuryCommander_Save.display.SnD = val
end,
get = function(info) return SliceCommander_Save.display.SnD end
get = function(info) return FuryCommander_Save.display.SnD end
},
PosSnD = {--Slice and Dice position
order = 129,
677,9 → 434,9
return returnArray
end,
set = function(info,val)
SliceCommander_Save.Pos.SnD = val
FuryCommander_Save.Pos.SnD = val
end,
get = function(info) return SliceCommander_Save.Pos.SnD end
get = function(info) return FuryCommander_Save.Pos.SnD end
},
headerCPSetting = {--Combo Point Settings
order = 130,
692,9 → 449,9
desc = "Display the Combo Point timer bar",
type = "toggle",
set = function(info,val)
SliceCommander_Save.display.CP = val
FuryCommander_Save.display.CP = val
end,
get = function(info) return SliceCommander_Save.display.CP end
get = function(info) return FuryCommander_Save.display.CP end
},
PosCP = {--Combo Point position
order = 132,
709,9 → 466,9
return returnArray
end,
set = function(info,val)
SliceCommander_Save.Pos.CP = val
FuryCommander_Save.Pos.CP = val
end,
get = function(info) return SliceCommander_Save.Pos.CP end
get = function(info) return FuryCommander_Save.Pos.CP end
},
headerThreatSetting = {--Threat Settings
order = 133,
724,9 → 481,9
desc = "Display the Threat bar",
type = "toggle",
set = function(info,val)
SliceCommander_Save.display.THREAT = val
FuryCommander_Save.display.THREAT = val
end,
get = function(info) return SliceCommander_Save.display.THREAT end
get = function(info) return FuryCommander_Save.display.THREAT end
},
PosTHREAT = {--Threat position
order = 135,
741,9 → 498,9
return returnArray
end,
set = function(info,val)
SliceCommander_Save.Pos.THREAT = val
FuryCommander_Save.Pos.THREAT = val
end,
get = function(info) return SliceCommander_Save.Pos.THREAT end
get = function(info) return FuryCommander_Save.Pos.THREAT end
},
ThreatGroupOnly = {--Show Threat bar only in group
order = 136,
751,9 → 508,9
desc = "Display the Threat bar only if you are in a group or a raid",
type = "toggle",
set = function(info,val)
SliceCommander_Save.ThreatGroupOnly = val
FuryCommander_Save.ThreatGroupOnly = val
end,
get = function(info) return SliceCommander_Save.ThreatGroupOnly end
get = function(info) return FuryCommander_Save.ThreatGroupOnly end
},
headerARSetting = {--Adrenaline rush Settings
order = 137,
766,9 → 523,9
desc = "Display the Adrenaline rush timer bar",
type = "toggle",
set = function(info,val)
SliceCommander_Save.display.AR = val
FuryCommander_Save.display.AR = val
end,
get = function(info) return SliceCommander_Save.display.AR end
get = function(info) return FuryCommander_Save.display.AR end
},
PosAR = {--Adrenaline rush position
order = 139,
783,10 → 540,10
return returnArray
end,
set = function(info,val)
SliceCommander_Save.Pos.AR = val
SliceCommander_Save.Pos.ARCD = val
FuryCommander_Save.Pos.AR = val
FuryCommander_Save.Pos.ARCD = val
end,
get = function(info) return SliceCommander_Save.Pos.AR end
get = function(info) return FuryCommander_Save.Pos.AR end
},
ARCDBarShow = {--Show Adrenaline rush CD
order = 140,
794,20 → 551,10
desc = "Display the Adrenaline rush cooldown bar",
type = "toggle",
set = function(info,val)
SliceCommander_Save.display.ARCD = val
FuryCommander_Save.display.ARCD = val
end,
get = function(info) return SliceCommander_Save.display.ARCD end
get = function(info) return FuryCommander_Save.display.ARCD end
},
ARMarioMod = {--Enable Mario mod
order = 141,
name = "Enable Mario mod",
desc = "Enable mario start music during Adrenaline rush buff",
type = "toggle",
set = function(info,val)
SliceCommander_Save.ARMarioMod = val
end,
get = function(info) return SliceCommander_Save.ARMarioMod end
},
headerEASetting = {--Expose Armor Settings
order = 151,
name = "Expose Armor Settings",
819,9 → 566,9
desc = "Display the Expose Armor timer bar",
type = "toggle",
set = function(info,val)
SliceCommander_Save.display.EA = val
FuryCommander_Save.display.EA = val
end,
get = function(info) return SliceCommander_Save.display.EA end
get = function(info) return FuryCommander_Save.display.EA end
},
PosEA = {--EA position
order = 153,
836,9 → 583,9
return returnArray
end,
set = function(info,val)
SliceCommander_Save.Pos.EA = val
FuryCommander_Save.Pos.EA = val
end,
get = function(info) return SliceCommander_Save.Pos.EA end
get = function(info) return FuryCommander_Save.Pos.EA end
},
headerFESetting = {--Feint Settings
order = 161,
851,9 → 598,9
desc = "Display the Feint timer bar",
type = "toggle",
set = function(info,val)
SliceCommander_Save.display.FE = val
FuryCommander_Save.display.FE = val
end,
get = function(info) return SliceCommander_Save.display.FE end
get = function(info) return FuryCommander_Save.display.FE end
},
PosFE = {--Feint position
order = 163,
868,60 → 615,60
return returnArray
end,
set = function(info,val)
SliceCommander_Save.Pos.FE = val
SliceCommander_Save.Pos.FECD = val
FuryCommander_Save.Pos.FE = val
FuryCommander_Save.Pos.FECD = val
end,
get = function(info) return SliceCommander_Save.Pos.FE end
get = function(info) return FuryCommander_Save.Pos.FE end
},
}
}
 
SC_OptionsTable = {
name = "SliceCommander",
handler = SliceCommander,
name = "FuryCommander",
handler = FuryCommander,
type = "group",
args = {--SliceCommander
args = {--FuryCommander
IsLocked = {--Lock
order = 1,
name = "Lock",
desc = "Disable Left Click to Move",
type = "toggle",
set = function(info,val)
SliceCommander:LockCkecked(val)
FuryCommander:LockCkecked(val)
end,
get = function(info) return SliceCommander_Save.IsLocked end
get = function(info) return FuryCommander_Save.IsLocked end
},
FullTimer = {--Full timer
order = 2,
name = "Full Timer",
desc = "Make timer full bar duration",
type = "toggle",
set = function(info,val) SliceCommander_Save.FullTimer = val end,
get = function(info) return SliceCommander_Save.FullTimer end
set = function(info,val) FuryCommander_Save.FullTimer = val end,
get = function(info) return FuryCommander_Save.FullTimer end
},
PadLatency = {--Latency
order = 3,
name = "Enable Latency",
desc = "Pad Alerts with Latency",
type = "toggle",
set = function(info,val) SliceCommander_Save.PadLatency = val end,
get = function(info) return SliceCommander_Save.PadLatency end
set = function(info,val) FuryCommander_Save.PadLatency = val end,
get = function(info) return FuryCommander_Save.PadLatency end
},
SpellText = {--Spell text
order = 4,
name = "Spell Text",
desc = "Enable spell text on bars",
type = "toggle",
set = function(info,val) SliceCommander_Save.SpellText = val end,
get = function(info) return SliceCommander_Save.SpellText end
set = function(info,val) FuryCommander_Save.SpellText = val end,
get = function(info) return FuryCommander_Save.SpellText end
},
SoundCombat = {--Disable sound out of combat
order = 5,
name = "Sound Combat",
desc = "Disable sounds out of combat",
type = "toggle",
set = function(info,val) SliceCommander_Save.SoundCombat = val end,
get = function(info) return SliceCommander_Save.SoundCombat end
set = function(info,val) FuryCommander_Save.SoundCombat = val end,
get = function(info) return FuryCommander_Save.SoundCombat end
},
headerDisplaySetting = {--CDisplay Setting
order = 6,
935,47 → 682,54
type = "select",
values = function()
returnArray = {}
for key, value in pairs(SliceCommander_BarTextures) do
for key, value in pairs(FuryCommander_BarTextures) do
returnArray[key] = key
end
return returnArray
end,
set = function(info,val)
SliceCommander_Save.BarTexture = val
SliceCommander:Config_RetextureBars(SliceCommander:BarTexture())
FuryCommander_Save.BarTexture = val
FuryCommander:Config_RetextureBars(FuryCommander:BarTexture())
end,
get = function(info) return SliceCommander_Save.BarTexture end
get = function(info) return FuryCommander_Save.BarTexture end
},
Width = {--Width
order = 9,
name = "Width",
desc = "Bar Width",
desc = "Bar Width. If the frame is blury or some texture are shity and you currently play on multiple screen. You should use the command /sc eyefinity x. X is the number of screen you play on.",
type = "range",
min = 125,
max = 300,
step = 1,
bigStep = 5,
set = function(info,val)
SliceCommander_Save.Width = val
SliceCommander:SetWidth(val)
FuryCommander_Save.Width = val
if FuryCommander_Save.skin then
FuryCommander:ApplySkin(false)
end
FuryCommander:SetWidth(val)
if FuryCommander_Save.skin then
FuryCommander:ApplySkin(true)
end
 
end,
get = function(info) return SliceCommander_Save.Width end,
get = function(info) return FuryCommander_Save.Width end,
isPercent = false
},
EnergyHeight = {--Energy bar height
RageHeight = {--Rage bar height
order = 10,
name = "Energy Height",
desc = "EnergyBar Height",
name = "Rage Height",
desc = "RageBar Height",
type = "range",
min = 1,
max = 40,
step = 1,
bigStep = 1,
set = function(info,val)
SliceCommander_Save.EnergyHeight = val
SliceCommander:SetEnergyHeight(val)
FuryCommander_Save.RageHeight = val
FuryCommander:SetRageHeight(val)
end,
get = function(info) return SliceCommander_Save.EnergyHeight end,
get = function(info) return FuryCommander_Save.RageHeight end,
isPercent = false
},
TimerHeight = {--Timer height
988,10 → 742,11
step = 1,
bigStep = 1,
set = function(info,val)
SliceCommander_Save.TimerHeight = val
SliceCommander:SetTimersHeight(val)
FuryCommander_Save.TimerHeight = val
FuryCommander:SetTimersHeight(val)
FuryCommander:ApplySkin(FuryCommander_Save.skin)
end,
get = function(info) return SliceCommander_Save.TimerHeight end,
get = function(info) return FuryCommander_Save.TimerHeight end,
isPercent = false
},
BarMargin = {--Margin
1003,8 → 758,8
max = 10,
step = 1,
bigStep = 1,
set = function(info,val) SliceCommander_Save.BarMargin = val end,
get = function(info) return SliceCommander_Save.BarMargin end,
set = function(info,val) FuryCommander_Save.BarMargin = val end,
get = function(info) return FuryCommander_Save.BarMargin end,
isPercent = false
},
FrameOpacity = {--Opacity
1017,10 → 772,10
step = 1,
bigStep = 1,
set = function(info,val)
SliceCommander:FrameOpacity(val)
SliceCommander_Save.FrameOpacity = val
FuryCommander:FrameOpacity(val)
FuryCommander_Save.FrameOpacity = val
end,
get = function(info) return SliceCommander_Save.FrameOpacity end,
get = function(info) return FuryCommander_Save.FrameOpacity end,
isPercent = false
},
headerCheckHealth = {--Check health header
1033,16 → 788,16
name = "Spec 1",
desc = "Check health for Spec 1",
type = "toggle",
set = function(info,val) SliceCommander_Save.checkHealthSpec1 = val end,
get = function(info) return SliceCommander_Save.checkHealthSpec1 end
set = function(info,val) FuryCommander_Save.checkHealthSpec1 = val end,
get = function(info) return FuryCommander_Save.checkHealthSpec1 end
},
checkHealthSpec2 = {--Check health spec2
order = 16,
name = "Spec 2",
desc = "Check health for Spec 2",
type = "toggle",
set = function(info,val) SliceCommander_Save.checkHealthSpec2 = val end,
get = function(info) return SliceCommander_Save.checkHealthSpec2 end
set = function(info,val) FuryCommander_Save.checkHealthSpec2 = val end,
get = function(info) return FuryCommander_Save.checkHealthSpec2 end
},
HealthUnder = {--Texture
order = 17,
1051,17 → 806,17
type = "select",
values = function()
returnArray = {}
for ignore, SoundName in pairs(SliceCommander_SoundMenu['All']) do
for ignore, SoundName in pairs(FuryCommander_SoundMenu['All']) do
returnArray[SoundName] = SoundName
end
return returnArray
end,
set = function(info,val)
SliceCommander:SoundTest(val)
SliceCommander_Save.HealthUnder = val
FuryCommander:SoundTest(val)
FuryCommander_Save.HealthUnder = val
end,
get = function(info)
return SliceCommander_Save.HealthUnder
return FuryCommander_Save.HealthUnder
end
},
headerKick = {
1074,517 → 829,356
name = "Enable",
desc = "If enable, a warning message will be display when you succeed to interrupts spellcasting.",
type = "toggle",
set = function(info,val) SliceCommander_Save.kickEnable = val end,
get = function(info) return SliceCommander_Save.kickEnable end
set = function(info,val) FuryCommander_Save.kickEnable = val end,
get = function(info) return FuryCommander_Save.kickEnable end
},
kickMessage = {
order = 22,
name = "Warning message",
desc = "The warning message which will be display when you kick is successfull.",
desc = "The warning message which will be display when you kick is successful.",
type = "input",
width = "double",
set = function(info,val) SliceCommander_Save.kickMessage = val end,
get = function(info) return SliceCommander_Save.kickMessage end
set = function(info,val) FuryCommander_Save.kickMessage = val end,
get = function(info) return FuryCommander_Save.kickMessage end
},
headerSkin = {
order = 30,
name = "Kick Feature",
type = "header"
},
skinEnable = {
order = 31,
name = "Enable",
desc = "Add a border like the one on Tukui.",
type = "toggle",
set = function(info,val)
FuryCommander_Save.skin = val
FuryCommander:ApplySkin(val)
FuryCommander:ShowHideBorder(val)
end,
get = function(info) return FuryCommander_Save.skin end
},
}
}
 
function SliceCommander:OnInitialize()
function FuryCommander:OnInitialize()
_, englishClass = UnitClass("player")
if englishClass == "ROGUE" then
 
SliceCommander:TestValueOptions()
SliceCommander:InitBarArray()
 
AceConfig:RegisterOptionsTable("SliceCommander", SC_OptionsTable)
AceConfig:RegisterOptionsTable("SliceCommander_DisplayTimer", SC_OptionsTable_DisplayTimer)
AceConfig:RegisterOptionsTable("SliceCommander_Sound", SC_OptionsTable_Sound)
 
SetDefaultOpttion = AceConfigDialog:AddToBlizOptions("SliceCommander","SliceCommander")
SetDefaultOpttion.default = function() SliceCommander:ResetOptions() end
 
SetDefaultOpttion = AceConfigDialog:AddToBlizOptions("SliceCommander_DisplayTimer",SC_DISPLAY_SETTINGS,"SliceCommander")
SetDefaultOpttion.default = function() SliceCommander:ResetOptions() end
 
SetDefaultOpttion = AceConfigDialog:AddToBlizOptions("SliceCommander_Sound",SC_LANG_SOUND,"SliceCommander")
SetDefaultOpttion.default = function() SliceCommander:ResetOptions() end
 
SliceCommander:RegisterEvent("UNIT_COMBO_POINTS")
SliceCommander:RegisterEvent("PLAYER_TARGET_CHANGED")
SliceCommander:RegisterEvent("UNIT_HEALTH")
SliceCommander:RegisterEvent("PLAYER_LOGIN")
SliceCommander:RegisterEvent("COMBAT_LOG_EVENT_UNFILTERED")
 
SC.BarFont1 = SliceCommander:NewFont("VTimerFont", 17, 0.7, 1, 1, 1)
SC.BarFont2 = SliceCommander:NewFont("VTimerFont2", 8, 0.7, 213/255, 200/255, 184/255)
SC.BarFont3 = SliceCommander:NewFont("VTimerFont1O", 17, 0.2, 0, 0, 0)
SC.BarFont4 = SliceCommander:NewFont("VTimerFont4", 8, 1, 213/255, 200/255, 184/255)
 
SliceCommander:CreateCore()
 
SC.LastEnergy = UnitMana('player')
SC.curCombo = 0
 
SC.OTHER['BG']['obj'] = SliceCommander:BGFrame()--create Bandit's Guile bar
SC.BARS['CP']['obj'] = SliceCommander:CPFrame()--create Combot Point bar
SC.BARS['KS']['obj'] = SliceCommander:NewFrame(227/255, 186/255, 132/255)--create Kidney Shot bar
SC.BARS['CS']['obj'] = SliceCommander:NewFrame(227/255, 186/255, 132/255)--create Cheap Shot bar
SC.BARS['SnD']['obj'] = SliceCommander:NewFrame(193/255, 79/255, 44/255)--create Slice and Dice bar
SC.BARS['RUP']['obj'] = SliceCommander:NewFrame(180/255, 38/255, 38/255)--create Rupture bar
SC.BARS['EA']['obj'] = SliceCommander:NewFrame(151/255, 101/255, 199/255)--create Expose Armor bar
SC.BARS['GAR']['obj'] = SliceCommander:NewFrame(180/255, 38/255, 38/255)--create Garrote bar
SC.BARS['REC']['obj'] = SliceCommander:NewFrame(110/255, 172/255, 163/255)--create Recuperate bar
SC.BARS['VEN']['obj'] = SliceCommander:NewFrame(110/255, 34/255, 45/255)--create Vendetta bar
SC.BARS['VENCD']['obj'] = SliceCommander:NewFrame(139/255, 78/255, 87/255)--create CD Vendetta bar
SC.BARS['AR']['obj'] = SliceCommander:NewFrame(226/255, 130/255, 90/255)--create Adrenaline Rush bar
SC.BARS['ARCD']['obj'] = SliceCommander:NewFrame(255/255, 173/255, 132/255)--create CD Adrenaline Rush bar
SC.BARS['DP']['obj'] = SliceCommander:NewFrame(64/255, 167/255, 64/255)--create Deadly Poison bar
SC.BARS['ENV']['obj'] = SliceCommander:NewFrame(64/255, 167/255, 64/255)--create Envenome bar
SC.BARS['ToT']['obj'] = SliceCommander:NewFrame(77/255, 77/255, 255/255)--create Tricks of Trade bar
SC.BARS['FE']['obj'] = SliceCommander:NewFrame(37/255, 108/255, 174/255)--create Feint bar
SC.BARS['FECD']['obj'] = SliceCommander:NewFrame(37/255, 108/255, 174/255)--create Feint CD bar
SC.BARS['THREAT']['obj'] = SliceCommander:NewFrame(0, 0, 0)
 
 
 
SliceCommander:NewTickArray(SC.BARS['RUP'])--Create Ticks marker for Rupture Bar
SliceCommander:NewTickArray(SC.BARS['GAR'])--Create Ticks marker for Garrote Bar
SliceCommander:NewTickArray(SC.BARS['REC']) --Create Ticks marker for Recuperate Bar
 
SC.OTHER['BF']['obj'] = SliceCommander:NewIcon("Interface\\Icons\\Ability_Warrior_PunishingBlow")--Create Blade fury icon display when BF is enable
SC.OTHER['HEALTH']['obj'] = SliceCommander:NewIcon("Interface\\Icons\\Ability_BackStab")--Create Backstab icon display when Target is under 35% HP
 
SC.BARS['VENCD']['obj'].icon:SetTexture("Interface\\Icons\\Ability_Rogue_Deadliness")
SC.BARS['ARCD']['obj'].icon:SetTexture("Interface\\Icons\\Spell_Shadow_ShadowWordDominate")
SC.BARS['ToT']['obj'].icon:SetTexture("Interface\\Icons\\Ability_Rogue_TricksOftheTrade")
SC.BARS['FECD']['obj'].icon:SetTexture("Interface\\Icons\\ability_rogue_feint")
 
SC.BARS['THREAT']['obj'].iconBackground:SetAlpha(0)--Hide icone for Threat bar
SC.BARS['THREAT']['obj']:SetMinMaxValues(0, 110)--Threat value should be between 0 and 110
 
SC.BARS['MH']['obj'] = SliceCommander:NewPoisonFrame("BOTTOMLEFT", "TOPLEFT", 0, -3*SC.V.pxH)--Create MH poison timer
SC.BARS['OH']['obj'] = SliceCommander:NewPoisonFrame("TOPLEFT", "BOTTOMLEFT", 0 , 3*SC.V.pxH)--Create OH poison timer
 
soundRup = {'RUP_Alert', 'RUP_Alert', 'RUP_Alert'}--Intilaise sounds array
soundSnd = {'Tick1', 'Tick2', 'Tick3'}
RUP_AlertPending = 3
SND_AlertPending = 3
DEFAULT_CHAT_FRAME:AddMessage('|cffc14f2cSlice|r|cff40a740Commander|r v'..SC.VERSION)
if englishClass == "WARRIOR" then
FuryCommander:RegisterEvent("PLAYER_LOGIN")
FuryCommander:RegisterEvent("UNIT_HEALTH")
FuryCommander:RegisterEvent("COMBAT_LOG_EVENT_UNFILTERED")
else
SliceCommander:OnDisable()
FuryCommander:OnDisable()
return 0
end
end
 
function SliceCommander:TestValueOptions()
if SliceCommander_Save == nil or SliceCommander_Save.display == nil or SliceCommander_Save.Pos == nil then
SliceCommander_Save = { display = {}, Pos = {} }
function FuryCommander:PLAYER_LOGIN()
FuryCommander:TestValueOptions()
FuryCommander:InitBarArray()
 
AceConfig:RegisterOptionsTable("FuryCommander", SC_OptionsTable)
AceConfig:RegisterOptionsTable("FuryCommander_DisplayTimer", SC_OptionsTable_DisplayTimer)
 
SetDefaultOpttion = AceConfigDialog:AddToBlizOptions("FuryCommander","FuryCommander")
SetDefaultOpttion.default = function() FuryCommander:ResetOptions() end
 
SetDefaultOpttion = AceConfigDialog:AddToBlizOptions("FuryCommander_DisplayTimer",SC_DISPLAY_SETTINGS,"FuryCommander")
SetDefaultOpttion.default = function() FuryCommander:ResetOptions() end
 
FC.BarFont1 = FuryCommander:NewFont("VTimerFont", 17, 0.7, 1, 1, 1)
FC.BarFont2 = FuryCommander:NewFont("VTimerFont2", 8, 0.7, 213/255, 200/255, 184/255)
FC.BarFont3 = FuryCommander:NewFont("VTimerFont1O", 17, 0.2, 0, 0, 0)
FC.BarFont4 = FuryCommander:NewFont("VTimerFont4", 8, 1, 213/255, 200/255, 184/255)
FC.BarFontIcon = FuryCommander:NewFont("IconFont", 40, 0.5, 1, .1, .1)
 
FuryCommander:CreateCore()
 
FC.BARS['THREAT']['obj'] = FuryCommander:NewFrame(0, 0, 0)
 
FC.ICON['BLT']['obj'], FC.ICON['BLT']['frame'] = FuryCommander:NewIcon("Interface\\Icons\\spell_nature_bloodlust", FC.ICON['BLT']['name'], FuryCommander_Save.bloodthirst.point, FuryCommander_Save.bloodthirst.relativeTo, FuryCommander_Save.bloodthirst.relativePoint, FuryCommander_Save.bloodthirst.xOfs, FuryCommander_Save.bloodthirst.yOfs)--Create Bloodthirst icon
 
FC.BARS['THREAT']['obj'].iconBackground:SetAlpha(0)--Hide icone for Threat bar
for i,v in pairs(FC.BARS['THREAT']['obj'].iconBorder) do
v:Hide()
end
if SliceCommander_Save.ARSound == nil then
SliceCommander_Save.ARSound = 'Mario'
FC.BARS['THREAT']['obj']:SetMinMaxValues(0, 110)--Threat value should be between 0 and 110
 
print('|cffc14f2cFury|r|cff40a740Commander|r v'..FC.VERSION)
FuryCommander:ApplyConf()
collectgarbage()
end
 
function FuryCommander:TestValueOptions()
if FuryCommander_Save == nil or FuryCommander_Save.display == nil or FuryCommander_Save.Pos == nil then
FuryCommander_Save = { display = {}, Pos = {} }
end
if SliceCommander_Save.ARSound_Glyphed == nil then
SliceCommander_Save.ARSound_Glyphed = 'Mario glyphed'
if FuryCommander_Save.IsLocked == nil then
FuryCommander_Save.IsLocked = true
end
if SliceCommander_Save.IsLocked == nil then
SliceCommander_Save.IsLocked = true
if FuryCommander_Save.HideRage == nil then
FuryCommander_Save.HideRage = false
end
if SliceCommander_Save.HideEnergy == nil then
SliceCommander_Save.HideEnergy = false
if FuryCommander_Save.Rage1 == nil then
FuryCommander_Save.Rage1 = 35
end
if SliceCommander_Save.Energy1 == nil then
SliceCommander_Save.Energy1 = 35
if FuryCommander_Save.Rage2 == nil then
FuryCommander_Save.Rage2 = 55
end
if SliceCommander_Save.Energy2 == nil then
SliceCommander_Save.Energy2 = 55
if FuryCommander_Save.Rage3 == nil then
FuryCommander_Save.Rage3 = 25
end
if SliceCommander_Save.Energy3 == nil then
SliceCommander_Save.Energy3 = 25
if FuryCommander_Save.Width == nil then
FuryCommander_Save.Width = 279
end
if SliceCommander_Save.Fail == nil then
SliceCommander_Save.Fail = 'None'
if FuryCommander_Save.PadLatency == nil then
FuryCommander_Save.PadLatency = true
end
if SliceCommander_Save.Expire == nil then
SliceCommander_Save.Expire = 'None'
if FuryCommander_Save.FullTimer == nil then
FuryCommander_Save.FullTimer = false
end
if SliceCommander_Save.Tick3 == nil then
SliceCommander_Save.Tick3 = 'None'
if FuryCommander_Save.RageTrans == nil then
FuryCommander_Save.RageTrans = 0
end
if SliceCommander_Save.Tick2 == nil then
SliceCommander_Save.Tick2 = 'None'
if FuryCommander_Save.BarMargin == nil then
FuryCommander_Save.BarMargin = 7
end
if SliceCommander_Save.Tick1 == nil then
SliceCommander_Save.Tick1 = 'None'
if FuryCommander_Save.checkHealthSpec1 == nil then
FuryCommander_Save.checkHealthSpec1 = true
end
if SliceCommander_Save.Applied == nil then
SliceCommander_Save.Applied = 'None'
if FuryCommander_Save.checkHealthSpec2 == nil then
FuryCommander_Save.checkHealthSpec2 = true
end
if SliceCommander_Save.Apply3 == nil then
SliceCommander_Save.Apply3 = 'None'
if FuryCommander_Save.ThreatGroupOnly == nil then
FuryCommander_Save.ThreatGroupOnly = true
end
if SliceCommander_Save.Apply2 == nil then
SliceCommander_Save.Apply2 = 'None'
if FuryCommander_Save.RageHeight == nil then
FuryCommander_Save.RageHeight = 28
end
if SliceCommander_Save.Apply1 == nil then
SliceCommander_Save.Apply1 = 'None'
if FuryCommander_Save.TimerHeight == nil then
FuryCommander_Save.TimerHeight = 17
end
if SliceCommander_Save.EnergySound1 == nil then
SliceCommander_Save.EnergySound1 = 'None'
if FuryCommander_Save.BarTexture == nil then
FuryCommander_Save.BarTexture = 'Blizzard'
end
if SliceCommander_Save.EnergySound2 == nil then
SliceCommander_Save.EnergySound2 = 'None'
if FuryCommander_Save.FrameOpacity == nil then
FuryCommander_Save.FrameOpacity = 100
end
if SliceCommander_Save.EnergySound3 == nil then
SliceCommander_Save.EnergySound3 = 'None'
if FuryCommander_Save.kickEnable == nil then
FuryCommander_Save.kickEnable = true
end
if SliceCommander_Save.HealthUnder == nil then
SliceCommander_Save.HealthUnder = 'You Spin Me'
if FuryCommander_Save.kickMessage == nil then
FuryCommander_Save.kickMessage = "Kick successful"
end
if SliceCommander_Save.RUP_Fail == nil then
SliceCommander_Save.RUP_Fail = 'None'
if FuryCommander_Save.point == nil then
FuryCommander_Save.point = "TOP"
end
if SliceCommander_Save.RUP_Expire == nil then
SliceCommander_Save.RUP_Expire = 'None'
--if FuryCommander_Save.relativeTo == nil then
FuryCommander_Save.relativeTo = "UIParent"
--end
if FuryCommander_Save.relativePoint == nil then
FuryCommander_Save.relativePoint = "TOP"
end
if SliceCommander_Save.RUP_Applied == nil then
SliceCommander_Save.RUP_Applied = 'None'
if FuryCommander_Save.xOfs == nil then
FuryCommander_Save.xOfs = 0
end
if SliceCommander_Save.RUP_Refresh3 == nil then
SliceCommander_Save.RUP_Refresh3 = 'None'
if FuryCommander_Save.yOfs == nil then
FuryCommander_Save.yOfs = -300
end
if SliceCommander_Save.RUP_Refresh2 == nil then
SliceCommander_Save.RUP_Refresh2 = 'None'
if FuryCommander_Save.bloodthirst.point == nil then
FuryCommander_Save.bloodthirst.point = "TOP"
end
if SliceCommander_Save.RUP_Refresh1 == nil then
SliceCommander_Save.RUP_Refresh1 = 'None'
--if FuryCommander_Save.bloodthirst.relativeTo == nil then
FuryCommander_Save.bloodthirst.relativeTo = "UIParent"
--end
if FuryCommander_Save.bloodthirst.relativePoint == nil then
FuryCommander_Save.bloodthirst.relativePoint = "TOP"
end
if SliceCommander_Save.RUP_Alert == nil then
SliceCommander_Save.RUP_Alert = 'None'
if FuryCommander_Save.bloodthirst.xOfs == nil then
FuryCommander_Save.bloodthirst.xOfs = 0
end
if SliceCommander_Save.Width == nil then
SliceCommander_Save.Width = 280
if FuryCommander_Save.bloodthirst.yOfs == nil then
FuryCommander_Save.bloodthirst.yOfs = -400
end
if SliceCommander_Save.PadLatency == nil then
SliceCommander_Save.PadLatency = true
if FuryCommander_Save.skin == nil then
FuryCommander_Save.skin = true
end
if SliceCommander_Save.SpellText == nil then
SliceCommander_Save.SpellText = true
if FuryCommander_Save.eyefinity == nil then
FuryCommander_Save.eyefinity = 1
end
if SliceCommander_Save.FullTimer == nil then
SliceCommander_Save.FullTimer = false
end
 
function FuryCommander:ResetOptions()
FuryCommander_Save = nil
FuryCommander:TestValueOptions()
if FC.BARS['SnD']['obj'] ~= 0 then
FuryCommander:ApplyConf()
LibStub("AceConfigRegistry-3.0"):NotifyChange("FuryCommander")
end
if SliceCommander_Save.SoundCombat == nil then
SliceCommander_Save.SoundCombat = true
end
if SliceCommander_Save.EnergyTrans == nil then
SliceCommander_Save.EnergyTrans = 0
end
if SliceCommander_Save.BarMargin == nil then
SliceCommander_Save.BarMargin = 3
end
if SliceCommander_Save.PoisonTransparencyShow == nil then
SliceCommander_Save.PoisonTransparencyShow = true
end
if SliceCommander_Save.checkHealthSpec1 == nil then
SliceCommander_Save.checkHealthSpec1 = true
end
if SliceCommander_Save.checkHealthSpec2 == nil then
SliceCommander_Save.checkHealthSpec2 = true
end
if SliceCommander_Save.ThreatGroupOnly == nil then
SliceCommander_Save.ThreatGroupOnly = true
end
if SliceCommander_Save.EnergyHeight == nil then
SliceCommander_Save.EnergyHeight = 28
end
if SliceCommander_Save.TimerHeight == nil then
SliceCommander_Save.TimerHeight = 17
end
if SliceCommander_Save.BarTexture == nil then
SliceCommander_Save.BarTexture = 'Blizzard'
end
if SliceCommander_Save.display.CP == nil then
SliceCommander_Save.display.CP = true
end
if SliceCommander_Save.display.Poison == nil then
SliceCommander_Save.display.Poison = true
end
if SliceCommander_Save.display.DP == nil then
SliceCommander_Save.display.DP = false
end
if SliceCommander_Save.display.ENV == nil then
SliceCommander_Save.display.ENV = true
end
if SliceCommander_Save.display.EA == nil then
SliceCommander_Save.display.EA = true
end
if SliceCommander_Save.display.SnD == nil then
SliceCommander_Save.display.SnD = true
end
if SliceCommander_Save.display.VEN == nil then
SliceCommander_Save.display.VEN = true
end
if SliceCommander_Save.display.VENCD == nil then
SliceCommander_Save.display.VENCD = true
end
if SliceCommander_Save.display.REC == nil then
SliceCommander_Save.display.REC = true
end
if SliceCommander_Save.display.KS == nil then
SliceCommander_Save.display.KS = true
end
if SliceCommander_Save.display.CS == nil then
SliceCommander_Save.display.CS = true
end
if SliceCommander_Save.display.ToT == nil then
SliceCommander_Save.display.ToT = true
end
if SliceCommander_Save.display.RUP == nil then
SliceCommander_Save.display.RUP = true
end
if SliceCommander_Save.display.GAR == nil then
SliceCommander_Save.display.GAR = true
end
if SliceCommander_Save.display.THREAT == nil then
SliceCommander_Save.display.THREAT = true
end
if SliceCommander_Save.display.AR == nil then
SliceCommander_Save.display.AR = true
end
if SliceCommander_Save.display.ARCD == nil then
SliceCommander_Save.display.ARCD = true
end
if SliceCommander_Save.display.BF == nil then
SliceCommander_Save.display.BF = true
end
if SliceCommander_Save.display.FE == nil then
SliceCommander_Save.display.FE = true
end
if SliceCommander_Save.Pos.CP == nil then
SliceCommander_Save.Pos.CP = -1
end
if SliceCommander_Save.Pos.THREAT == nil then
SliceCommander_Save.Pos.THREAT = -2
end
if SliceCommander_Save.Pos.CS == nil then
SliceCommander_Save.Pos.CS = -3
end
if SliceCommander_Save.Pos.KS == nil then
SliceCommander_Save.Pos.KS = -4
end
if SliceCommander_Save.Pos.REC == nil then
SliceCommander_Save.Pos.REC = 1
end
if SliceCommander_Save.Pos.SnD == nil then
SliceCommander_Save.Pos.SnD = 2
end
if SliceCommander_Save.Pos.RUP == nil then
SliceCommander_Save.Pos.RUP = 3
end
if SliceCommander_Save.Pos.GAR == nil then
SliceCommander_Save.Pos.GAR = 4
end
if SliceCommander_Save.Pos.ToT == nil then
SliceCommander_Save.Pos.ToT = 5
end
if SliceCommander_Save.Pos.VEN == nil then
SliceCommander_Save.Pos.VEN = 6
end
if SliceCommander_Save.Pos.VENCD == nil then
SliceCommander_Save.Pos.VENCD = 6
end
if SliceCommander_Save.Pos.DP == nil then
SliceCommander_Save.Pos.DP = 7
end
if SliceCommander_Save.Pos.ENV == nil then
SliceCommander_Save.Pos.ENV = 8
end
if SliceCommander_Save.Pos.AR == nil then
SliceCommander_Save.Pos.AR = 9
end
if SliceCommander_Save.Pos.ARCD == nil then
SliceCommander_Save.Pos.ARCD = 9
end
if SliceCommander_Save.Pos.EA == nil then
SliceCommander_Save.Pos.EA = 10
end
if SliceCommander_Save.Pos.FE == nil then
SliceCommander_Save.Pos.FE = 11
end
if SliceCommander_Save.Pos.FECD == nil then
SliceCommander_Save.Pos.FECD = 11
end
if SliceCommander_Save.FrameOpacity == nil then
SliceCommander_Save.FrameOpacity = 100
end
if SliceCommander_Save.ARMarioMod == nil then
SliceCommander_Save.ARMarioMod = false
end
if SliceCommander_Save.kickEnable == nil then
SliceCommander_Save.kickEnable = true
end
if SliceCommander_Save.kickMessage == nil then
SliceCommander_Save.kickMessage = "Kick successful"
end
if SliceCommander_Save.point == nil then
SliceCommander_Save.point = "TOP"
end
if SliceCommander_Save.relativeTo == nil then
SliceCommander_Save.relativeTo = "UIParent"
end
if SliceCommander_Save.relativePoint == nil then
SliceCommander_Save.relativePoint = "TOP"
end
if SliceCommander_Save.xOfs == nil then
SliceCommander_Save.xOfs = 0
end
if SliceCommander_Save.yOfs == nil then
SliceCommander_Save.yOfs = -300
end
end
 
function SliceCommander:ResetOptions()
SliceCommander_Save = nil
SliceCommander:TestValueOptions()
if SC.BARS['SnD']['obj'] ~= 0 then
SliceCommander:ApplyConf()
LibStub("AceConfigRegistry-3.0"):NotifyChange("SliceCommander")
function FuryCommander:ShowHideBorder(visible)
if visible then
for i,v in pairs(VTimerRage.border) do
v:Show()
end
for i,v in pairs(FC.BARS) do
if i ~= "MH" and i ~= "OH" then
for j,w in pairs(v['obj'].border) do
w:Show()
end
if i ~= "THREAT" and i ~= "CP" then
for j,w in pairs(v['obj'].iconBorder) do
w:Show()
end
end
end
end
else
for i,v in pairs(VTimerRage.border) do
v:Hide()
end
for i,v in pairs(FC.BARS) do
if i ~= "MH" and i ~= "OH" then
for j,w in pairs(v['obj'].border) do
w:Hide()
end
if i ~= "THREAT" and i ~= "CP" then
for j,w in pairs(v['obj'].iconBorder) do
w:Hide()
end
end
end
end
end
end
 
 
 
function SliceCommander:ApplyConf()
SliceCommander:LockCkecked(SliceCommander_Save.IsLocked)
SliceCommander:SetTimersHeight(SliceCommander_Save.TimerHeight)
SliceCommander:SetWidth(SliceCommander_Save.Width)
SliceCommander:SetEnergyHeight(SliceCommander_Save.EnergyHeight)
SliceCommander:Config_RetextureBars(SliceCommander:BarTexture())
SliceCommander:FrameOpacity(SliceCommander_Save.FrameOpacity)
SliceCommander:SetPoisonTransparency(SliceCommander_Save.EnergyTrans)
function FuryCommander:ApplyConf()
FuryCommander:LockCkecked(FuryCommander_Save.IsLocked)
FuryCommander:SetTimersHeight(FuryCommander_Save.TimerHeight)
FuryCommander:SetWidth(FuryCommander_Save.Width)
FuryCommander:SetRageHeight(FuryCommander_Save.RageHeight)
FuryCommander:Config_RetextureBars(FuryCommander:BarTexture())
FuryCommander:FrameOpacity(FuryCommander_Save.FrameOpacity)
VTimerRage:SetAlpha(FuryCommander_Save.RageTrans)
FuryCommander:ApplySkin(FuryCommander_Save.skin)
FuryCommander:ShowHideBorder(FuryCommander_Save.skin)
end
 
function SliceCommander:ConfigSoundMenuInit(WhichMenu)
function FuryCommander:ConfigSoundMenuInit(WhichMenu)
returnArray = {}
for ignore, SoundName in pairs(SliceCommander_SoundMenu[WhichMenu]) do
for ignore, SoundName in pairs(FuryCommander_SoundMenu[WhichMenu]) do
returnArray[SoundName] = SoundName
end
return returnArray
end
 
function SliceCommander:Config_OtherVars()
SliceCommander_Spark[1]:SetPoint("TOPLEFT", VTimerEnergy, "TOPLEFT", ((SliceCommander_Save.Energy1 / UnitManaMax("player") * SliceCommander_Save.Width)-1)*SC.V.pxW, 0)
SliceCommander_Spark[2]:SetPoint("TOPLEFT", VTimerEnergy, "TOPLEFT", ((SliceCommander_Save.Energy2 / UnitManaMax("player") * SliceCommander_Save.Width)-1)*SC.V.pxW, 0)
SliceCommander_Spark[3]:SetPoint("TOPLEFT", VTimerEnergy, "TOPLEFT", ((SliceCommander_Save.Energy3 / UnitManaMax("player") * SliceCommander_Save.Width)-1)*SC.V.pxW, 0)
function FuryCommander:Config_OtherVars()
FuryCommander_Spark[1]:SetPoint("TOPLEFT", VTimerRage, "TOPLEFT", ((FuryCommander_Save.Rage1 / UnitManaMax("player") * FuryCommander_Save.Width)-1)*FC.V.pxW, 0)
FuryCommander_Spark[2]:SetPoint("TOPLEFT", VTimerRage, "TOPLEFT", ((FuryCommander_Save.Rage2 / UnitManaMax("player") * FuryCommander_Save.Width)-1)*FC.V.pxW, 0)
FuryCommander_Spark[3]:SetPoint("TOPLEFT", VTimerRage, "TOPLEFT", ((FuryCommander_Save.Rage3 / UnitManaMax("player") * FuryCommander_Save.Width)-1)*FC.V.pxW, 0)
end
 
function SliceCommander:LockCkecked(checked)
function FuryCommander:LockCkecked(checked)
if checked then
SliceCommander:SetPoisonTransparency(SliceCommander_Save.FrameOpacity)
SliceCommanderFrame:SetAlpha(0)
SliceCommanderFrame:EnableMouse(false)
SliceCommander_Save.IsLocked = true
FC.ICON['BLT']['frame']:SetAlpha(0)
FC.ICON['BLT']['frame']:EnableMouse(false)
FuryCommanderFrame:SetAlpha(0)
FuryCommanderFrame:EnableMouse(false)
FuryCommander_Save.IsLocked = true
else
SliceCommander:SetPoisonTransparency(100)
SliceCommanderFrame:SetAlpha(.5)
SliceCommanderFrame:EnableMouse(true)
SliceCommander_Save.IsLocked = false
FC.ICON['BLT']['frame']:SetAlpha(.5)
FC.ICON['BLT']['frame']:EnableMouse(true)
FuryCommanderFrame:SetAlpha(.5)
FuryCommanderFrame:EnableMouse(true)
FuryCommander_Save.IsLocked = false
end
end
 
function SliceCommander:Config_RetextureBars(texture)
VTimerEnergy:SetStatusBarTexture(texture)
for i,v in pairs(SC.BARS) do
if v['expire'] ~= nil and i ~= 'CP' then
function FuryCommander:Config_RetextureBars(texture)
VTimerRage:SetStatusBarTexture(texture)
for i,v in pairs(FC.BARS) do
if v['expire'] ~= nil then
v['obj']:SetStatusBarTexture(texture)
end
end
 
for i = 1, 5 do
SC.BARS['CP']['obj'].combos[i].bg:SetTexture(texture)
end
end
 
function SliceCommander:SetWidth(w)
h = SC.BARS['RUP']['obj'].iconBackground:GetHeight()/SC.V.pxH
for i,v in pairs(SC.BARS) do
if v['expire'] ~= nil and i ~= 'THREAT' and i ~= 'CP' then
v['obj']:SetWidth((w-h-1)*SC.V.pxW)
function FuryCommander:SetWidth(w)
h = FC.BARS['THREAT']['obj'].iconBackground:GetHeight()/FC.V.pxH
for i,v in pairs(FC.BARS) do
if v['expire'] ~= nil and i ~= 'THREAT' then
difW = (w-h-1) - v['obj']:GetWidth()/FC.V.pxW
v['obj']:SetWidth((w-h-1)*FC.V.pxW)
for y,w in pairs(v['obj'].border) do
w:SetWidth(w:GetWidth()+difW*FC.V.pxW)
end
end
end
VTimerEnergy:SetWidth(w*SC.V.pxW)
SC.BARS['MH']['obj']:SetWidth(w*SC.V.pxW)
SC.BARS['OH']['obj']:SetWidth(w*SC.V.pxW)
SC.BARS['CP']['obj']:SetWidth(w*SC.V.pxW)
SC.BARS['THREAT']['obj']:SetWidth(w*SC.V.pxW)
difW = h-VTimerRage:GetWidth()/FC.V.pxW
for i,v in pairs(VTimerRage.border) do
v:SetWidth(v:GetWidth()+difW*FC.V.pxW)
end
VTimerRage:SetWidth(w*FC.V.pxW)
 
cx = 0
widthCP = (((w-(2*4))/5))*SC.V.pxW
for i = 1, 5 do
SC.BARS['CP']['obj'].combos[i]:ClearAllPoints()
SC.BARS['CP']['obj'].combos[i]:SetPoint("TOPLEFT", SC.BARS['CP']['obj'], "TOPLEFT", cx, 0)
SC.BARS['CP']['obj'].combos[i]:SetPoint("BOTTOMRIGHT", SC.BARS['CP']['obj'], "BOTTOMLEFT", cx + widthCP , 0)
cx = cx + widthCP + 2*SC.V.pxW
FC.BARS['THREAT']['obj']:SetWidth(w*FC.V.pxW)
for i,v in pairs(FC.BARS['THREAT']['obj'].border) do
v:SetWidth(v:GetWidth()+difW*FC.V.pxW)
end
SliceCommander:Config_OtherVars()
 
FuryCommander:Config_OtherVars()
end
 
function SliceCommander:SetEnergyHeight(h)
SliceCommanderFrame:SetWidth(h*SC.V.pxW)
SliceCommanderFrame:SetHeight(h*SC.V.pxH)
VTimerEnergy:SetHeight(h*SC.V.pxH)
VTimerEnergyTxt:SetHeight(h*SC.V.pxH)
SliceCommander_Combo:SetHeight(h*SC.V.pxH)
SliceCommander_Spark[1]:SetHeight(h*SC.V.pxH)
SliceCommander_Spark[2]:SetHeight(h*SC.V.pxH)
SliceCommander_Spark[3]:SetHeight(h*SC.V.pxH)
function FuryCommander:SetSizeBorder(frame, border)
k = 6
for i,v in pairs(border) do
v:SetHeight(frame:GetHeight()+k*FC.V.pxH)
v:SetWidth(frame:GetWidth()+k*FC.V.pxW)
k = k-2
end
end
 
function SliceCommander:SetTimerHeight(BAR, h)
BAR:SetHeight(h*SC.V.pxH)
BAR.text:SetHeight(h*SC.V.pxH)
BAR.text2:SetHeight(h*SC.V.pxH)
BAR.icon:SetHeight(h*SC.V.pxH)
BAR.icon:SetWidth(h*SC.V.pxW)
BAR.iconBackground:SetHeight((h+2)*SC.V.pxH)
BAR.iconBackground:SetWidth((h+2)*SC.V.pxW)
function FuryCommander:SetRageHeight(h)
FuryCommanderFrame:SetWidth(h*FC.V.pxW)
FuryCommanderFrame:SetHeight(h*FC.V.pxH)
VTimerRage:SetHeight(h*FC.V.pxH)
VTimerRageTxt:SetHeight(h*FC.V.pxH)
FuryCommander_Combo:SetHeight(h*FC.V.pxH)
FuryCommander_Spark[1]:SetHeight(h*FC.V.pxH)
FuryCommander_Spark[2]:SetHeight(h*FC.V.pxH)
FuryCommander_Spark[3]:SetHeight(h*FC.V.pxH)
FuryCommander:SetSizeBorder(VTimerRage, VTimerRage.border)
end
 
function SliceCommander:SetTimersHeight(h)
for i,v in pairs(SC.BARS) do
if v['expire'] ~= nil and i ~= 'CP' and i ~= 'MH' and i ~= 'OH' then
SliceCommander:SetTimerHeight(v['obj'], h)
function FuryCommander:SetTimersHeight(h)
for i,v in pairs(FC.BARS) do
if v['expire'] ~= nil then
v['obj']:SetHeight(h*FC.V.pxH)
v['obj'].text:SetHeight(h*FC.V.pxH)
v['obj'].text2:SetHeight(h*FC.V.pxH)
v['obj'].icon:SetHeight(h*FC.V.pxH)
v['obj'].icon:SetWidth(h*FC.V.pxW)
v['obj'].iconBackground:SetHeight((h+2)*FC.V.pxH)
v['obj'].iconBackground:SetWidth((h+2)*FC.V.pxW)
 
FuryCommander:SetSizeBorder(v['obj'], v['obj'].border)
if i ~= 'THREAT' then
FuryCommander:SetSizeBorder(v['obj'].icon, v['obj'].iconBorder)
end
end
end
 
for i = 1, 3 do
SC.BARS['REC']['tick']['obj'][i]:SetHeight(h*SC.V.pxH)
end
for i = 1, 3 do
SC.BARS['GAR']['tick']['obj'][i]:SetHeight(h*SC.V.pxH)
end
for i = 1, 3 do
SC.BARS['RUP']['tick']['obj'][i]:SetHeight(h*SC.V.pxH)
end
SC.BARS['CP']['obj']:SetHeight(h*SC.V.pxH)
SC.BARS['CP']['obj'].comboText:SetHeight(h*SC.V.pxH)
for i = 1, 5 do
SC.BARS['CP']['obj'].combos[i]:SetHeight((h-2)*SC.V.pxH)
end
SC.BarFont2:SetFont("Interface\\AddOns\\SliceCommander\\Fonts\\FRIZQT__.TTF", (h-2)*SC.V.pxH)
SC.BarFont4:SetFont("Interface\\AddOns\\SliceCommander\\Fonts\\FRIZQT__.TTF", (h-2)*SC.V.pxH)
SliceCommander:SetWidth(SliceCommander_Save.Width)
FC.BarFont2:SetFont("Interface\\AddOns\\FuryCommander\\Fonts\\FRIZQT__.TTF", (h-2)*FC.V.pxH)
FC.BarFont4:SetFont("Interface\\AddOns\\FuryCommander\\Fonts\\FRIZQT__.TTF", (h-2)*FC.V.pxH)
FuryCommander:SetWidth(FuryCommander_Save.Width)
end
 
function SliceCommander:FrameOpacity(opValue)
SliceCommander:SetPoisonTransparency(opValue)
function FuryCommander:FrameOpacity(opValue)
VTimerRage:SetAlpha(opValue)
 
for i,v in pairs(SC.BARS) do
for i,v in pairs(FC.BARS) do
if v['expire'] ~= nil then
v['obj']:SetAlpha(opValue/100)
end
end
 
SC.OTHER['BF']['obj']:SetAlpha(opValue/100)
SC.OTHER['HEALTH']['obj']:SetAlpha(opValue/100)
end
\ No newline at end of file