WoWInterface SVN SliceCommander

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /
    from Rev 228 to Rev 229
    ↔ Reverse comparison
  •

Rev 228 → Rev 229

trunk/SliceCommander.lua
56,8 → 56,8
end
 
function SliceCommander:SetComboPts()
local points = UnitPower("player", SPELL_POWER_COMBO_POINTS)
local maxCP = UnitPowerMax("player", SPELL_POWER_COMBO_POINTS)
local points = UnitPower("player", Enum.PowerType.ComboPoints)
local maxCP = UnitPowerMax("player", Enum.PowerType.ComboPoints)
 
for i = 1, maxCP do
SC.BARS['CP']['obj'].combos[i]:Hide()
228,13 → 228,13
value1, value2, value3 = 0 , 0, 0
local last = BAR['expire']
if BAR['type'] == 1 then
_, _, icon, count, _, duration, BAR['expire'], unitCaster, _, _, _, _, _, _, _, _, value1, value2, value3 = UnitAura("player", BAR['name'], nil, "PLAYER")
_, icon, count, _, duration, BAR['expire'], unitCaster, _, _, _, _, _, _, _, _, value1, value2, value3 = SliceCommander:UnitAura("player", BAR['id'], "PLAYER")
elseif BAR['type'] == 2 then
_, _, icon, count, _, duration, BAR['expire'], unitCaster = UnitDebuff("target", BAR['name'], nil, "PLAYER")
_, icon, count, _, duration, BAR['expire'], unitCaster = SliceCommander:UnitAura("target", BAR['id'], "PLAYER HARMFUL")
elseif BAR['type'] == 3 then
_, _, icon, count, _, duration, BAR['expire'], unitCaster = UnitDebuff("player", BAR['name'], nil, "PLAYER")
_, icon, count, _, duration, BAR['expire'], unitCaster = SliceCommander:UnitAura("player", BAR['id'], "PLAYER HARMFUL")
else
_, _, icon, count, _, duration, BAR['expire'], unitCaster = UnitDebuff("target", BAR['name'])
_, icon, count, _, duration, BAR['expire'], unitCaster = SliceCommander:UnitAura("target", BAR['id'], "HARMFUL")
end
 
if unitCaster ~= "player" and BAR['type'] ~= 3 and unitCaster ~= nil then
292,9 → 292,9
if not UnitAffectingCombat("player") then
local alreadyExist = GetMacroBody("SC_TOT")
if alreadyExist then
EditMacro("SC_TOT", "SC_TOT", "INV_MISC_QUESTIONMARK", "/cast [@"..SC.SET.TOTTarget..",modifier:alt] [help] [@targettarget, help][@none,@="..SC.SET.TOTTarget.."] "..SC_SPELL['TOT'], 1, 1)
EditMacro("SC_TOT", "SC_TOT", "INV_MISC_QUESTIONMARK", "/cast [@"..SC.SET.TOTTarget..",modifier:alt] [help] [@targettarget, help][@none,@="..SC.SET.TOTTarget.."] "..GetSpellInfo(SC_SPELL['TOT']), 1, 1)
else
CreateMacro("SC_TOT", "INV_MISC_QUESTIONMARK", "/cast [@"..SC.SET.TOTTarget..",modifier:alt] [help] [@targettarget, help][@none,@="..SC.SET.TOTTarget.."] "..SC_SPELL['TOT'], 1, 1)
CreateMacro("SC_TOT", "INV_MISC_QUESTIONMARK", "/cast [@"..SC.SET.TOTTarget..",modifier:alt] [help] [@targettarget, help][@none,@="..SC.SET.TOTTarget.."] "..GetSpellInfo(SC_SPELL['TOT']), 1, 1)
end
end
end
428,8 → 428,8
end
 
function SliceCommander:TestBF()
if SC.SET.display.BF then
local name = UnitAura("player", SC_SPELL['BF'], nil, "PLAYER")
if SC.SET.display.BFICON then
local name = SliceCommander:UnitAura("player", SC_SPELLID['BF'], "PLAYER")
if name and not SC.OTHER['BF']['obj']:IsVisible() then
SC.OTHER['BF']['obj']:Show()
elseif not name and SC.OTHER['BF']['obj']:IsVisible() then
472,16 → 472,12
local ohPoison = SC.SET.poison.oh
local _, _, _, selected = GetTalentInfo(4, 1, 1)
if not selected and ohPoison == SC_SPELL['LP'] then
ohPoison = SC_SPELL['CRP']
ohPoison = 'CRP'
end
 
local name, _, _, _, _, _, expirationTime = UnitAura("player", mhPoison, nil, "PLAYER")
local name2 = name
local expirationTime2 = expirationTime
if ohPoison ~= 'none' then
name2, _, _, _, _, _, expirationTime2 = UnitAura("player", ohPoison, nil, "PLAYER")
end
 
local name, _, _, _, _, expirationTime = SliceCommander:UnitAura("player", SC_SPELLID[mhPoison], "PLAYER")
local name2, _, _, _, _, expirationTime2 = SliceCommander:UnitAura("player", SC_SPELLID[ohPoison], "PLAYER")
 
local minimalTime = SC.SET.display.DPTIME*60
 
if IsMounted() or ((name and ((expirationTime-SC.tNow) > minimalTime or combat)) and (name2 and ((expirationTime2-SC.tNow) > minimalTime or combat))) then
516,7 → 512,7
 
function SliceCommander:TestSOTD()
if SC.SET.display.SOTD then
local name, _, _, count = UnitAura("player", SC_SPELL['SOTD'], nil, "PLAYER")
local name, _, _, count = SliceCommander:UnitAura("player", SC_SPELLID['SOTD'], "PLAYER")
if name and count >= 29 then
if not SC.OTHER['SOTD']['obj']:IsVisible() then
SC.OTHER['SOTD']['obj']:Show()
536,6 → 532,16
end
end
 
function SliceCommander:UnitAura(target, spell, filter)
local i, name, icon, count, debuffType, duration, expirationTime, unitCaster, canStealOrPurge, nameplateShowPersonal, spellId, canApplyAura, isBossDebuff, isCastByPlayer, nameplateShowAll, timeMod
i = 1
repeat
name, icon, count, debuffType, duration, expirationTime, unitCaster, canStealOrPurge, nameplateShowPersonal, spellId, canApplyAura, isBossDebuff, isCastByPlayer, nameplateShowAll, timeMod = UnitAura(target, i, filter)
i = i+1
until not name or spellId == spell
return name, icon, count, debuffType, duration, expirationTime, unitCaster, canStealOrPurge, nameplateShowPersonal, spellId, canApplyAura, isBossDebuff, isCastByPlayer, nameplateShowAll, timeMod
end
 
function SliceCommander:Latency()
local _
SC.tNow = GetTime()
546,11 → 552,11
end
 
function SliceCommander:Energy()
VTimerEnergy:SetValue(UnitPower("player", SPELL_POWER_ENERGY))
VTimerEnergy:SetMinMaxValues(0,UnitPowerMax("player", SPELL_POWER_ENERGY))
VTimerEnergy:SetValue(UnitPower("player", Enum.PowerType.Energy))
VTimerEnergy:SetMinMaxValues(0,UnitPowerMax("player", Enum.PowerType.Energy))
VTimerEnergyTxt:SetText(VTimerEnergy:GetValue())
 
if UnitPowerMax("player", SPELL_POWER_ENERGY) == UnitPower("player", SPELL_POWER_ENERGY) and not UnitAffectingCombat("player") then
if UnitPowerMax("player", Enum.PowerType.Energy) == UnitPower("player", Enum.PowerType.Energy) and not UnitAffectingCombat("player") then
SliceCommander:SetTransparency(SC.SET.EnergyTrans)
else
SliceCommander:SetTransparency(SC.SET.FrameOpacity)
591,7 → 597,7
function SliceCommander:Pandemic(BAR, current)
if SC.SET.Pandemic and BAR['pandemic'] then
local timers = BAR['pandemictimer']
local maxCP = UnitPowerMax("player", SPELL_POWER_COMBO_POINTS)
local maxCP = UnitPowerMax("player", Enum.PowerType.ComboPoints)
if maxCP > 6 then
maxCP = 5
end
677,8 → 683,8
local last = BAR['expire']
local spellname = {}
BAR['expire'] = 0
for i, v in ipairs(BAR.subbar) do
_, _, _, _, _, duration, expire = UnitAura("player", SC_SPELL[v], nil, "PLAYER")
for k, v in pairs(BAR.subbar) do
_, _, _, _, duration, expire = SliceCommander:UnitAura("player", k, "PLAYER")
if expire ~= nil then
if SC.SET.RB[v] then
table.insert(spellname, SC.SET.RB[v])
trunk/Core/Settings.lua
279,6 → 279,23
}
end
 
function SliceCommander:getShortcutSetting(sc_categ, sub_categ, spell)
return {
order = SliceCommander:getOrder(),
type = "execute",
name = SC_SPELL[spell],
func = function() AceConfigDialog:SelectGroup(sc_categ, sub_categ, spell) end,
}
end
 
function SliceCommander:getShortcutHeader()
return {
order = SliceCommander:getOrder(),
name = L["Shortcut"],
type = "header"
}
end
 
function SliceCommander:InitTable()
local SC_OptionsTable = {}
 
288,64 → 305,64
type = "group",
childGroups = "tab",
args = {
SoundCombat = {
order = SliceCommander:getOrder(),
name = L["Sound Combat"],
desc = L["Disable sounds out of combat"],
type = "toggle",
set = function(info,val) SC.SET.SoundCombat = val end,
get = function(info) return SC.SET.SoundCombat end
},
SoundChannel = {
order = SliceCommander:getOrder(),
name = L["Sound channel"],
desc = L["Choose the sound channel with which you want to play SliceCommander sounds. 'MASTER' must be use if you want to ear sounds when sound is disable. Other channels should be use if you want o lower volume."],
type = "select",
values = function()
local returnArray = {
["Master"] = "Master",
["SFX"] = "SFX",
["Ambience"] = "Ambience",
["Music"] = "Music",
}
return returnArray
end,
set = function(info,val)
SC.SET.soundChannel = val
end,
get = function(info) return SC.SET.soundChannel end
},
SoundVolume = {
order = SliceCommander:getOrder(),
name = L["Sound Volume"],
desc = L["Warning: It will change the sound channel volume. If other sounds are played with this channel it will also change their volume."],
type = "range",
min = 0,
max = 1,
step = 0.05,
bigStep = 0.1,
set = function(info,val)
SliceCommander:ChangeVolume(val)
end,
get = function(info) return tonumber(SliceCommander:GetVolume()) end,
isPercent = true
},
SoundSpell = {
order = SliceCommander:getOrder(),
name = L["Enable spell sound notitication"],
desc = L["Each spell will have full sound personalization in their respective settings."],
type = "toggle",
set = function(info,val)
SC.SET.SpellSound = val
SliceCommander:StaticPopup_Show('CONFIG_RL')
end,
get = function(info)
if SC.SET.SpellSound == nil then
SC.SET.SpellSound = false
SoundCombat = {
order = SliceCommander:getOrder(),
name = L["Sound Combat"],
desc = L["Disable sounds out of combat"],
type = "toggle",
set = function(info,val) SC.SET.SoundCombat = val end,
get = function(info) return SC.SET.SoundCombat end
},
SoundChannel = {
order = SliceCommander:getOrder(),
name = L["Sound channel"],
desc = L["Choose the sound channel with which you want to play SliceCommander sounds. 'MASTER' must be use if you want to ear sounds when sound is disable. Other channels should be use if you want o lower volume."],
type = "select",
values = function()
local returnArray = {
["Master"] = "Master",
["SFX"] = "SFX",
["Ambience"] = "Ambience",
["Music"] = "Music",
}
return returnArray
end,
set = function(info,val)
SC.SET.soundChannel = val
end,
get = function(info) return SC.SET.soundChannel end
},
SoundVolume = {
order = SliceCommander:getOrder(),
name = L["Sound Volume"],
desc = L["Warning: It will change the sound channel volume. If other sounds are played with this channel it will also change their volume."],
type = "range",
min = 0,
max = 1,
step = 0.05,
bigStep = 0.1,
set = function(info,val)
SliceCommander:ChangeVolume(val)
end,
get = function(info) return tonumber(SliceCommander:GetVolume()) end,
isPercent = true
},
SoundSpell = {
order = SliceCommander:getOrder(),
name = L["Enable spell sound notitication"],
desc = L["Each spell will have full sound personalization in their respective settings."],
type = "toggle",
set = function(info,val)
SC.SET.SpellSound = val
SliceCommander:StaticPopup_Show('CONFIG_RL')
end,
get = function(info)
if SC.SET.SpellSound == nil then
SC.SET.SpellSound = false
end
return SC.SET.SpellSound
end
return SC.SET.SpellSound
end
},
},
}
}
 
355,114 → 372,278
type = "group",
args = {--Display setting
displayDescription = SliceCommander:getDisplayDescriptionSetting(),
CV = SliceCommander:getSpellCDSettings('CV'),
TOT = {
name = SC_SPELL['TOT'],
General = {
order = SliceCommander:getOrder(),
name = L["General settings"],
type = "group",
order = SliceCommander:getOrder(),
childGroups = "tree",
args = {
TOTShow = SliceCommander:getShowSetting('TOT'),
TOTPos = SliceCommander:getPosSetting('TOT'),
TOTColor = SliceCommander:getColorSetting('TOT'),
TOTTarget = {
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_CP = SliceCommander:getShortcutSetting("SliceCommander_General", "General", "CP"),
Shortcut_HEALTH = SliceCommander:getShortcutSetting("SliceCommander_General", "General", "HEALTH"),
Shortcut_THEALTH = SliceCommander:getShortcutSetting("SliceCommander_General", "General", "THEALTH"),
Shortcut_THREAT = SliceCommander:getShortcutSetting("SliceCommander_General", "General", "THREAT"),
CP = {
order = SliceCommander:getOrder(),
name = L["Taget name"],
desc = L["Write a macro which Tricks the target if it is friendly, if not the target of target. Except if a modifier is down the Tricks will target the player name specify here."],
type = "input",
set = function(info,val)
SC.SET.TOTTarget = val
SliceCommander:CreateTOTMacro()
end,
get = function(info) return SC.SET.TOTTarget end
name = SC_SPELL['CP'],
type = "group",
args = {
Bar = SliceCommander:getShowSetting('CP'),
Pos = SliceCommander:getPosSetting('CP'),
standart = {
order = SliceCommander:getOrder(),
name = string.format(L["%s Settings"], L['Standard']),
type = "header"
},
standardCP1 = SliceCommander:getCPColorSetting(5, 1),
standardCP2 = SliceCommander:getCPColorSetting(5, 2),
standardCP3 = SliceCommander:getCPColorSetting(5, 3),
standardCP4 = SliceCommander:getCPColorSetting(5, 4),
standardCP5 = SliceCommander:getCPColorSetting(5, 5),
DS = SliceCommander:getHeaderSetting('DS'),
DSCP1 = SliceCommander:getCPColorSetting(6, 1),
DSCP2 = SliceCommander:getCPColorSetting(6, 2),
DSCP3 = SliceCommander:getCPColorSetting(6, 3),
DSCP4 = SliceCommander:getCPColorSetting(6, 4),
DSCP5 = SliceCommander:getCPColorSetting(6, 5),
DSCP6 = SliceCommander:getCPColorSetting(6, 6),
}
},
}
},
FE = SliceCommander:getSpellSettings('FE'),
AC = SliceCommander:getSpellSettings('AC'),
kickHeader = {
order = SliceCommander:getOrder(),
name = SC_SPELL['KI'],
type = "group",
args = {
ShowKI = SliceCommander:getShowSetting('KI'),
ColorKI = SliceCommander:getColorSetting('KI'),
PosKI = SliceCommander:getPosSetting('KI'),
HeaderKINotification = {
HEALTH = {
order = SliceCommander:getOrder(),
name = L["Warning settings"],
type = "header"
name = SC_SPELL['HEALTH'],
type = "group",
args = {
Bar = SliceCommander:getShowSetting('HEALTH'),
Pos = SliceCommander:getPosSetting('HEALTH'),
healthPercentage = {
order = SliceCommander:getOrder(),
name = L["Show HP Value"],
desc = L["Show HP value rather than health percentage."],
type = "toggle",
set = function(info,val)
SC.SET.HEALTH.value = val
SliceCommander:HealthBar('HEALTH')
end,
get = function(info) return SC.SET.HEALTH.value end
},
healthCombat = {
order = SliceCommander:getOrder(),
name = L["Hide out of combat"],
desc = L["Hide health bar when you are not in combat."],
type = "toggle",
set = function(info,val)
SC.SET.HEALTH.HideCombat = val
SliceCommander:HealthBar('HEALTH')
end,
get = function(info) return SC.SET.HEALTH.HideCombat end
},
MidHealthUnder = {
order = SliceCommander:getOrder(),
name = L["Sound under 50% health"],
desc = L["The sound play when your health reach 50% health"],
type = "select",
dialogControl = 'LSM30_Sound',
values = LSM:HashTable("sound"),
set = function(info,val)
SC.SET.HEALTH.MidUnder = val
end,
get = function(info)
return SC.SET.HEALTH.MidUnder
end
},
LowHealthUnder = {
order = SliceCommander:getOrder(),
name = L["Sound under 35% health"],
desc = L["The sound play when your health reach 35% health"],
type = "select",
dialogControl = 'LSM30_Sound',
values = LSM:HashTable("sound"),
set = function(info,val)
SC.SET.HEALTH.LowUnder = val
end,
get = function(info)
return SC.SET.HEALTH.LowUnder
end
},
}
},
kickEnable = {
THEALTH = {
order = SliceCommander:getOrder(),
name = L["Enable kick warning"],
desc = L["If enable, a warning message will be display when you succeed to interrupts spellcasting."],
type = "toggle",
set = function(info,val) SC.SET.kickEnable = val end,
get = function(info) return SC.SET.kickEnable end
name = SC_SPELL['THEALTH'],
type = "group",
args = {
Bar = SliceCommander:getShowSetting('THEALTH'),
Pos = SliceCommander:getPosSetting('THEALTH'),
healthPercentage = {
order = SliceCommander:getOrder(),
name = L["Show HP Value"],
desc = L["Show HP value rather than health percentage."],
type = "toggle",
set = function(info,val)
SC.SET.THEALTH.value = val
SliceCommander:HealthBar('THEALTH')
end,
get = function(info) return SC.SET.THEALTH.value end
},
healthCombat = {
order = SliceCommander:getOrder(),
name = L["Hide out of combat"],
desc = L["Hide health bar when you are not in combat."],
type = "toggle",
set = function(info,val)
SC.SET.THEALTH.HideCombat = val
SliceCommander:HealthBar('THEALTH')
end,
get = function(info) return SC.SET.THEALTH.HideCombat end
},
}
},
kickChannel = {
THREAT = {
order = SliceCommander:getOrder(),
name = L["Channel"],
desc = L["Choose which Channel the success message will be send to. Only one message is send. Then Channel priority order is Instance > Raid > Pary > Say."],
type = "multiselect",
values = {
['INSTANCE_CHAT'] = L["Instance"],
['RAID'] = L["Raid"],
['PARTY'] = L["Party"],
['SAY'] = L["Say"]
},
set = function(info, key, val) SC.SET.kickChannel[key] = val end,
get = function(info, key) return SC.SET.kickChannel[key] end
name = SC_SPELL['THREAT'],
type = "group",
args = {
Bar = SliceCommander:getShowSetting('THREAT'),
Pos = SliceCommander:getPosSetting('THREAT'),
ThreatGroupOnly = {--Show Threat bar only in group
order = SliceCommander:getOrder(),
name = L["Threat bar only in group"],
desc = L["Display the Threat bar only if you are in a group or a raid"],
type = "toggle",
width = "full",
set = function(info,val)
SC.SET.ThreatGroupOnly = val
end,
get = function(info) return SC.SET.ThreatGroupOnly end
},
}
},
kickMessage = {
}
},
Skills = {
order = SliceCommander:getOrder(),
name = L["Skills"],
type = "group",
childGroups = "tree",
args = {
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_CV = SliceCommander:getShortcutSetting("SliceCommander_General", "Skills", "CV"),
Shortcut_TOT = SliceCommander:getShortcutSetting("SliceCommander_General", "Skills", "TOT"),
Shortcut_FE = SliceCommander:getShortcutSetting("SliceCommander_General", "Skills", "FE"),
Shortcut_KI = SliceCommander:getShortcutSetting("SliceCommander_General", "Skills", "KI"),
Shortcut_VAN = SliceCommander:getShortcutSetting("SliceCommander_General", "Skills", "VAN"),
Shortcut_KS = SliceCommander:getShortcutSetting("SliceCommander_General", "Skills", "KS"),
Shortcut_CS = SliceCommander:getShortcutSetting("SliceCommander_General", "Skills", "CS"),
Shortcut_COS = SliceCommander:getShortcutSetting("SliceCommander_General", "Skills", "COS"),
CV = SliceCommander:getSpellCDSettings('CV'),
TOT = {
name = SC_SPELL['TOT'],
type = "group",
order = SliceCommander:getOrder(),
name = L["Warning message"],
desc = L["The warning message which will be display when you kick is successful."],
type = "input",
width = "full",
set = function(info,val) SC.SET.kickMessage = val end,
get = function(info) return SC.SET.kickMessage end
args = {
TOTShow = SliceCommander:getShowSetting('TOT'),
TOTPos = SliceCommander:getPosSetting('TOT'),
TOTColor = SliceCommander:getColorSetting('TOT'),
TOTTarget = {
order = SliceCommander:getOrder(),
name = L["Taget name"],
desc = L["Write a macro which Tricks the target if it is friendly, if not the target of target. Except if a modifier is down the Tricks will target the player name specify here."],
type = "input",
set = function(info,val)
SC.SET.TOTTarget = val
SliceCommander:CreateTOTMacro()
end,
get = function(info) return SC.SET.TOTTarget end
},
}
},
kickSpell = {
FE = SliceCommander:getSpellCDSettings('FE'),
KI = {
order = SliceCommander:getOrder(),
name = L["Add spell"],
desc = L["Add kicked spell at the start of the message."],
type = "toggle",
set = function(info,val) SC.SET.kickSpell = val end,
get = function(info) return SC.SET.kickSpell end
name = SC_SPELL['KI'],
type = "group",
args = {
ShowKI = SliceCommander:getShowSetting('KI'),
ColorKI = SliceCommander:getColorSetting('KI'),
PosKI = SliceCommander:getPosSetting('KI'),
HeaderKINotification = {
order = SliceCommander:getOrder(),
name = L["Warning settings"],
type = "header"
},
kickEnable = {
order = SliceCommander:getOrder(),
name = L["Enable kick warning"],
desc = L["If enable, a warning message will be display when you succeed to interrupts spellcasting."],
type = "toggle",
set = function(info,val) SC.SET.kickEnable = val end,
get = function(info) return SC.SET.kickEnable end
},
kickChannel = {
order = SliceCommander:getOrder(),
name = L["Channel"],
desc = L["Choose which Channel the success message will be send to. Only one message is send. Then Channel priority order is Instance > Raid > Pary > Say."],
type = "multiselect",
values = {
['INSTANCE_CHAT'] = L["Instance"],
['RAID'] = L["Raid"],
['PARTY'] = L["Party"],
['SAY'] = L["Say"]
},
set = function(info, key, val) SC.SET.kickChannel[key] = val end,
get = function(info, key) return SC.SET.kickChannel[key] end
},
kickMessage = {
order = SliceCommander:getOrder(),
name = L["Warning message"],
desc = L["The warning message which will be display when you kick is successful."],
type = "input",
width = "full",
set = function(info,val) SC.SET.kickMessage = val end,
get = function(info) return SC.SET.kickMessage end
},
kickSpell = {
order = SliceCommander:getOrder(),
name = L["Add spell"],
desc = L["Add kicked spell at the start of the message."],
type = "toggle",
set = function(info,val) SC.SET.kickSpell = val end,
get = function(info) return SC.SET.kickSpell end
},
}
},
VAN = SliceCommander:getCDSettings('VAN'),
KS = SliceCommander:getSpellCDSettings('KS'),
CS = SliceCommander:getSpellSettings('CS'),
COS = SliceCommander:getSpellCDSettings('COS'),
SPR = SliceCommander:getSpellCDSettings('SPR'),
}
},
CD = SliceCommander:getCDSettings('CD'),
MD = SliceCommander:getCDSettings('MD'),
DFA = SliceCommander:getCDSettings('DFA'),
VAN = SliceCommander:getCDSettings('VAN'),
KS = SliceCommander:getSpellCDSettings('KS'),
CS = SliceCommander:getSpellSettings('CS'),
MAI = SliceCommander:getSpellSettings('MAI'),
COS = SliceCommander:getSpellCDSettings('COS'),
FOTD = {
Talents = {
order = SliceCommander:getOrder(),
name = SC_SPELL['FOTD'],
name = L["Talents"],
type = "group",
childGroups = "tree",
args = {
Show = SliceCommander:getShowSetting('FOTD'),
Pos = SliceCommander:getPosSetting('FOTD'),
Color = SliceCommander:getColorSetting('FOTD'),
Icon = {--Shadow of the destroyer icon
order = SliceCommander:getOrder(),
name = string.format(L["%s icon"], SC_SPELL['SOTD']),
desc = string.format(L["%s icon. It's only display when stack reach 30. There is a counter on it."], SC_SPELL['SOTD']),
type = "toggle",
set = function(info,val)
SC.SET.display.SOTD = val
end,
get = function(info)
return SC.SET.display.SOTD
end
},
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_CD = SliceCommander:getShortcutSetting("SliceCommander_General", "Talents", "CD"),
Shortcut_MD = SliceCommander:getShortcutSetting("SliceCommander_General", "Talents", "MD"),
CD = SliceCommander:getCDSettings('CD'),
MD = SliceCommander:getCDSettings('MD'),
}
},
TalentsPVP = {
order = SliceCommander:getOrder(),
name = L["PVP Talents"],
type = "group",
childGroups = "tree",
args = {
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_DFA = SliceCommander:getShortcutSetting("SliceCommander_General", "TalentsPVP", "DFA"),
DFA = SliceCommander:getCDSettings('DFA'),
}
}
}
}
 
472,125 → 653,166
type = "group",
args = {--Display setting
displayDescription = SliceCommander:getDisplayDescriptionSetting(),
KB = SliceCommander:getSpellCDSettings('KB'),
BA = SliceCommander:getSpellSettings('BA'),
ST = SliceCommander:getSpellSettings('ST'),
RUP = SliceCommander:getSpellSettings('RUP'),
GAR = SliceCommander:getSpellCDSettings('GAR'),
EX = SliceCommander:getCDSettings('EX'),
TXB = SliceCommander:getSpellCDSettings('TXB'),
VEN = SliceCommander:getSpellCDSettings('VEN'),
ENV = SliceCommander:getSpellSettings('ENV'),
HEM = SliceCommander:getSpellSettings('HEM'),
EP = SliceCommander:getSpellSettings('EP'),
SUB = SliceCommander:getSpellSettings('SUB'),
SS = SliceCommander:getSpellCDSettings('SS'),
EV = SliceCommander:getSpellCDSettings('EV'),
DP = SliceCommander:getSpellSettings('DP'),
EnergySetting = SliceCommander:getEnergyMarkerSettings(1),
POISON = {
name = string.format(L["%s Settings"], L["Poisons"]),
General = {
order = SliceCommander:getOrder(),
name = L["General settings"],
type = "group",
order = SliceCommander:getOrder(),
childGroups = "tree",
args = {
DPIconShow = {
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_EnergySetting = {
order = SliceCommander:getOrder(),
name = L["Show poison icon"],
desc = string.format(L["Display the %s icon when the timer left on your poison go under specified time. If you are in combat it only display the icon when it fade out."], SC_SPELL['DP']),
type = "toggle",
set = function(info,val)
SC.SET.display.DPICON = val
end,
get = function(info) return SC.SET.display.DPICON end
type = "execute",
name = L["Energy bar Settings"],
func = function() AceConfigDialog:SelectGroup("SliceCommander_Assassination", "General", "EnergySetting") end,
},
DPTimeCheck = {
Shortcut_POISON = {
order = SliceCommander:getOrder(),
name = L["Minimal time"],
desc = L["In minutes"],
type = "range",
min = 0,
max = 59,
step = 1,
bigStep = 5,
set = function(info,val)
if strmatch(val,"%d") then
SC.SET.display.DPTIME = val
else
SC.SET.display.DPTIME = 10
end
end,
get = function(info) return SC.SET.display.DPTIME end
type = "execute",
name = string.format(L["%s Settings"], L["Poisons"]),
func = function() AceConfigDialog:SelectGroup("SliceCommander_Assassination", "General", "POISON") end,
},
DPButtonEnable = {
EnergySetting = SliceCommander:getEnergyMarkerSettings(1),
POISON = {
name = string.format(L["%s Settings"], L["Poisons"]),
type = "group",
order = SliceCommander:getOrder(),
name = L["Enable poison button"],
desc = L["Enable poison button has no effect if poison icon is not shown. If it is enable there is two restrinction: You can't click through the area where the icon was when the icon is hide in combat and the button does not work when the icon is shown in combat."],
type = "toggle",
set = function(info,val)
SC.SET.display.DPBUT = val
end,
get = function(info) return SC.SET.display.DPBUT end
},
DPSound = {
order = SliceCommander:getOrder(),
name = string.format(L["%s Sound"], SC_SPELL['DP']),
desc = string.format(L["%s Sound. It has no effect if %s is not display."], SC_SPELL['DP'], SC_SPELL['DP']),
type = "select",
dialogControl = 'LSM30_Sound',
values = LSM:HashTable("sound"),
set = function(info,val)
SC.SET.DPSound = val
end,
get = function(info) return SC.SET.DPSound end
},
displayDescriptionChekcedSpec = {
order = SliceCommander:getOrder(),
name = L["displayDescriptionChekcedSpec"],
fontSize = "medium",
type = "description"
},
Lethal = {
order = SliceCommander:getOrder(),
name = L["Lethal poison"],
type = "select",
values = function()
return { [SC_SPELL['DP']] = SC_SPELL['DP'], [SC_SPELL['WP']] = SC_SPELL['WP'] }
end,
set = function(info,val)
SC.OTHER['POISON']['obj'].button:SetAttribute("spell1", val)
SC.SET.poison.mh = val
end,
get = function(info)
return SC.SET.poison.mh
end
},
Utility = {
order = SliceCommander:getOrder(),
name = L["Utility poison"],
type = "select",
values = function()
return { ['none'] = L["None"], [SC_SPELL['CRP']] = SC_SPELL['CRP'], [SC_SPELL['LP']] = SC_SPELL['LP'] }
end,
set = function(info,val)
SC.OTHER['POISON']['obj'].button:SetAttribute("spell2", val)
local aSpec = GetSpecialization()
if aSpec == 1 and val == SC_SPELL['LP'] then--POISONS
local _, _, _, selected = GetTalentInfo(4, 1, 1)
if not selected then
SC.OTHER['POISON']['obj'].button:SetAttribute("spell2", SC_SPELL['CRP'])
args = {
DPIconShow = {
order = SliceCommander:getOrder(),
name = L["Show poison icon"],
desc = string.format(L["Display the %s icon when the timer left on your poison go under specified time. If you are in combat it only display the icon when it fade out."], SC_SPELL['DP']),
type = "toggle",
set = function(info,val)
SC.SET.display.DPICON = val
end,
get = function(info) return SC.SET.display.DPICON end
},
DPTimeCheck = {
order = SliceCommander:getOrder(),
name = L["Minimal time"],
desc = L["In minutes"],
type = "range",
min = 0,
max = 59,
step = 1,
bigStep = 5,
set = function(info,val)
if strmatch(val,"%d") then
SC.SET.display.DPTIME = val
else
SC.SET.display.DPTIME = 10
end
end,
get = function(info) return SC.SET.display.DPTIME end
},
DPButtonEnable = {
order = SliceCommander:getOrder(),
name = L["Enable poison button"],
desc = L["Enable poison button has no effect if poison icon is not shown. If it is enable there is two restrinction: You can't click through the area where the icon was when the icon is hide in combat and the button does not work when the icon is shown in combat."],
type = "toggle",
set = function(info,val)
SC.SET.display.DPBUT = val
end,
get = function(info) return SC.SET.display.DPBUT end
},
DPSound = {
order = SliceCommander:getOrder(),
name = string.format(L["%s Sound"], SC_SPELL['DP']),
desc = string.format(L["%s Sound. It has no effect if %s is not display."], SC_SPELL['DP'], SC_SPELL['DP']),
type = "select",
dialogControl = 'LSM30_Sound',
values = LSM:HashTable("sound"),
set = function(info,val)
SC.SET.DPSound = val
end,
get = function(info) return SC.SET.DPSound end
},
displayDescriptionChekcedSpec = {
order = SliceCommander:getOrder(),
name = L["displayDescriptionChekcedSpec"],
fontSize = "medium",
type = "description"
},
Lethal = {
order = SliceCommander:getOrder(),
name = L["Lethal poison"],
type = "select",
values = function()
return { ['DP'] = SC_SPELL['DP'], ['WP'] = SC_SPELL['WP'] }
end,
set = function(info,val)
SC.OTHER['POISON']['obj'].button:SetAttribute("spell1", SC_SPELL[val])
SC.SET.poison.mh = val
end,
get = function(info)
return SC.SET.poison.mh
end
end
if val == 'none' then
SC.OTHER['POISON']['obj'].button:SetAttribute("spell2", nil)
end
SC.SET.poison.oh = val
end,
get = function(info)
return SC.SET.poison.oh
end
},
Utility = {
order = SliceCommander:getOrder(),
name = L["Utility poison"],
type = "select",
values = function()
return { ['CRP'] = SC_SPELL['CRP'] }
end,
set = function(info,val)
SC.SET.poison.oh = val
end,
get = function(info)
return SC.SET.poison.oh
end
},
}
},
}
},
Skills = {
order = SliceCommander:getOrder(),
name = L["Skills"],
type = "group",
childGroups = "tree",
args = {
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_RUP = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Skills", "RUP"),
Shortcut_GAR = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Skills", "GAR"),
Shortcut_VEN = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Skills", "VEN"),
Shortcut_ENV = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Skills", "ENV"),
Shortcut_SS = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Skills", "SS"),
Shortcut_DP = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Skills", "DP"),
Shortcut_EVA = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Skills", "EVA"),
RUP = SliceCommander:getSpellSettings('RUP'),
GAR = SliceCommander:getSpellCDSettings('GAR'),
VEN = SliceCommander:getSpellCDSettings('VEN'),
ENV = SliceCommander:getSpellSettings('ENV'),
SS = SliceCommander:getSpellSettings('SS'),
DP = SliceCommander:getSpellSettings('DP'),
EVA = SliceCommander:getSpellCDSettings('EVA'),
}
},
Talents = {
order = SliceCommander:getOrder(),
name = L["Talents"],
type = "group",
childGroups = "tree",
args = {
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_EX = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Talents", "EX"),
Shortcut_TXB = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Talents", "TXB"),
Shortcut_EP = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Talents", "EP"),
Shortcut_SUB = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Talents", "SUB"),
Shortcut_BLS = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Talents", "BLS"),
Shortcut_MA = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Talents", "MA"),
Shortcut_CT = SliceCommander:getShortcutSetting("SliceCommander_Assassination", "Talents", "CT"),
EX = SliceCommander:getCDSettings('EX'),
TXB = SliceCommander:getSpellCDSettings('TXB'),
EP = SliceCommander:getSpellSettings('EP'),
SUB = SliceCommander:getSpellSettings('SUB'),
BLS = SliceCommander:getSpellSettings('BLS'),
MA = SliceCommander:getSpellSettings('MA'),
CT = SliceCommander:getSpellSettings('CT'),
}
}
}
}
 
600,112 → 822,144
type = "group",
args = {
displayDescription = SliceCommander:getDisplayDescriptionSetting(),
CDB = SliceCommander:getSpellCDSettings('CDB'),
LD = SliceCommander:getSpellSettings('LD'),
SND = SliceCommander:getSpellSettings('SND'),
GS = SliceCommander:getSpellSettings('GS'),
RB = {
name = SC_SPELL['RB'],
type = "group",
General = {
order = SliceCommander:getOrder(),
args = SliceCommander_TableMerge(
SliceCommander:getSpellSettings('RB').args,
{
replaceName = {
order = SliceCommander:getOrder(),
name = L["Replace spell name with each following spell text"],
desc = L["Each active buff actually up will be displayed in the spell name."],
type = "toggle",
set = function(info,val)
SC.SET.display.RBName = val
end,
get = function(info) return SC.SET.display.RBName end
},
JR = SliceCommander:getRBSetting('JR'),
GM = SliceCommander:getRBSetting('GM'),
SIW = SliceCommander:getRBSetting('SIW'),
TB = SliceCommander:getRBSetting('TB'),
BT = SliceCommander:getRBSetting('BT'),
BS = SliceCommander:getRBSetting('BS')
}
)
},
BF = {
order = SliceCommander:getOrder(),
name = SC_SPELL['BF'],
name = L["General settings"],
type = "group",
childGroups = "tree",
args = {
BFShow = {
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_EnergySetting = {
order = SliceCommander:getOrder(),
name = string.format(L["Show %s icon"], SC_SPELL['BF']),
desc = string.format(L["Display the %s icon when enbale"], SC_SPELL['BF']),
width = "full",
type = "toggle",
set = function(info,val)
SC.SET.display.BF = val
end,
get = function(info) return SC.SET.display.BF end
}
type = "execute",
name = L["Energy bar Settings"],
func = function() AceConfigDialog:SelectGroup("SliceCommander_Outlaw", "General", "EnergySetting") end,
},
EnergySetting = SliceCommander:getEnergyMarkerSettings(2),
}
},
AR = {
Skills = {
order = SliceCommander:getOrder(),
name = SC_SPELL['AR'],
name = L["Skills"],
type = "group",
childGroups = "tree",
args = {
ARShow = SliceCommander:getShowSetting('AR'),
ARPos = SliceCommander:getPosSetting('AR'),
ARColor = SliceCommander:getColorSetting('AR'),
ARCDShow = SliceCommander:getShowSetting('ARCD'),
ARCDColor = SliceCommander:getColorSetting('ARCD'),
ARMarioMod = {
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_RB = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Skills", "RB"),
Shortcut_BF = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Skills", "BF"),
Shortcut_AR = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Skills", "AR"),
Shortcut_BE = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Skills", "BE"),
Shortcut_GH = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Skills", "GH"),
Shortcut_OP = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Skills", "OP"),
Shortcut_RIP = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Skills", "RIP"),
RB = {
name = SC_SPELL['RB'],
type = "group",
order = SliceCommander:getOrder(),
name = L["Enable Mario mod"],
desc = L["Enable mario star music during Adrenaline rush buff"],
type = "toggle",
set = function(info,val)
if val then
SliceCommander:PlaySoundReal('Mario')
SC.BARS['AR']['sound']['applied'] = 'Mario'
else
if SC.previousSound then
StopSound(SC.previousSound)
end
SC.BARS['AR']['sound']['applied'] = 'None'
end
SC.SET.ARMarioMod = val
end,
get = function(info) return SC.SET.ARMarioMod end
}
args = SliceCommander_TableMerge(
SliceCommander:getSpellSettings('RB').args,
{
replaceName = {
order = SliceCommander:getOrder(),
name = L["Replace spell name with each following spell text"],
desc = L["Each active buff actually up will be displayed in the spell name."],
type = "toggle",
set = function(info,val)
SC.SET.display.RBName = val
end,
get = function(info) return SC.SET.display.RBName end
},
SC = SliceCommander:getRBSetting('SC'),
GM = SliceCommander:getRBSetting('GM'),
RP = SliceCommander:getRBSetting('RP'),
TB = SliceCommander:getRBSetting('TB'),
BT = SliceCommander:getRBSetting('BT'),
BS = SliceCommander:getRBSetting('BS')
}
)
},
BF = {
order = SliceCommander:getOrder(),
name = SC_SPELL['BF'],
type = "group",
args = {
BFShow = SliceCommander:getShowSetting('AR'),
BFPos = SliceCommander:getPosSetting('AR'),
BFColor = SliceCommander:getColorSetting('AR'),
BFCDShow = SliceCommander:getShowSetting('ARCD'),
BFCDColor = SliceCommander:getColorSetting('ARCD'),
BFIcon = {
order = SliceCommander:getOrder(),
name = string.format(L["Show %s icon"], SC_SPELL['BF']),
desc = string.format(L["Display the %s icon when enbale"], SC_SPELL['BF']),
width = "full",
type = "toggle",
set = function(info,val)
SC.SET.display.BFICON = val
end,
get = function(info) return SC.SET.display.BFICON end
}
}
},
AR = {
order = SliceCommander:getOrder(),
name = SC_SPELL['AR'],
type = "group",
args = {
ARShow = SliceCommander:getShowSetting('AR'),
ARPos = SliceCommander:getPosSetting('AR'),
ARColor = SliceCommander:getColorSetting('AR'),
ARCDShow = SliceCommander:getShowSetting('ARCD'),
ARCDColor = SliceCommander:getColorSetting('ARCD'),
ARMarioMod = {
order = SliceCommander:getOrder(),
name = L["Enable Mario mod"],
desc = L["Enable mario star music during Adrenaline rush buff"],
type = "toggle",
set = function(info,val)
if val then
SliceCommander:PlaySoundReal('Mario')
SC.BARS['AR']['sound']['applied'] = 'Mario'
else
if SC.previousSound then
StopSound(SC.previousSound)
end
SC.BARS['AR']['sound']['applied'] = 'None'
end
SC.SET.ARMarioMod = val
end,
get = function(info) return SC.SET.ARMarioMod end
}
}
},
BE = SliceCommander:getSpellCDSettings('BE'),
GH = SliceCommander:getCDSettings('GH'),
OP = SliceCommander:getSpellSettings('OP'),
RIP = SliceCommander:getSpellCDSettings('RIP'),
GG = SliceCommander:getSpellCDSettings('GG'),
}
},
CB = SliceCommander:getCDSettings('CB'),
BE = SliceCommander:getCDSettings('BE'),
KSP = SliceCommander:getCDSettings('KSP'),
GH = SliceCommander:getCDSettings('GH'),
OP = SliceCommander:getSpellSettings('OP'),
BB = {
Talents = {
order = SliceCommander:getOrder(),
name = SC_SPELL['BB'],
name = L["Talents"],
type = "group",
childGroups = "tree",
args = {
BBShow = {
order = SliceCommander:getOrder(),
name = string.format(L["Show %s icon"], SC_SPELL['BB']),
desc = string.format(L["Display the %s icon when enbale"], SC_SPELL['BB']),
width = "full",
type = "toggle",
set = function(info,val)
SC.SET.display.BB = val
end,
get = function(info) return SC.SET.display.BB end
}
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_AC = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Talents", "AC"),
Shortcut_SND = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Talents", "SND"),
Shortcut_GS = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Talents", "GS"),
Shortcut_KSP = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Talents", "KSP"),
Shortcut_LD = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Talents", "LD"),
Shortcut_BR = SliceCommander:getShortcutSetting("SliceCommander_Outlaw", "Talents", "BR"),
AC = SliceCommander:getSpellSettings('AC'),
SND = SliceCommander:getSpellSettings('SND'),
GS = SliceCommander:getSpellCDSettings('GS'),
KSP = SliceCommander:getCDSettings('KSP'),
LD = SliceCommander:getSpellSettings('LD'),
BR = SliceCommander:getSpellCDSettings('BR'),
}
},
PA = SliceCommander:getCDSettings('PA'),
GSWW = SliceCommander:getSpellSettings('GSWW'),
RI = SliceCommander:getSpellCDSettings('RI'),
EnergySetting = SliceCommander:getEnergyMarkerSettings(2),
}
}
}
 
715,171 → 969,163
type = "group",
args = {--Display setting
displayDescription = SliceCommander:getDisplayDescriptionSetting(),
GB = SliceCommander:getSpellCDSettings('GB'),
SD = SliceCommander:getSpellCDSettings('SD'),
SB = SliceCommander:getSpellCDSettings('SB'),
NB = SliceCommander:getSpellSettings('NB'),
SOD = SliceCommander:getSpellCDSettings('SOD'),
SUB = SliceCommander:getSpellSettings('SUB'),
SS = SliceCommander:getSpellCDSettings('SS'),
EV = SliceCommander:getSpellCDSettings('EV'),
EnergySetting = SliceCommander:getEnergyMarkerSettings(3),
General = {
order = SliceCommander:getOrder(),
name = L["General settings"],
type = "group",
childGroups = "tree",
args = {
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_EnergySetting = {
order = SliceCommander:getOrder(),
type = "execute",
name = L["Energy bar Settings"],
func = function() AceConfigDialog:SelectGroup("SliceCommander_Sublety", "General", "EnergySetting") end,
},
EnergySetting = SliceCommander:getEnergyMarkerSettings(3),
}
},
Skills = {
order = SliceCommander:getOrder(),
name = L["Skills"],
type = "group",
childGroups = "tree",
args = {
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_SD = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Skills", "SD"),
Shortcut_SB = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Skills", "SB"),
Shortcut_NB = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Skills", "NB"),
Shortcut_SOD = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Skills", "SOD"),
Shortcut_SS = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Skills", "SS"),
Shortcut_EVA = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Skills", "EVA"),
SD = SliceCommander:getSpellCDSettings('SD'),
SB = SliceCommander:getSpellCDSettings('SB'),
NB = SliceCommander:getSpellSettings('NB'),
SOD = SliceCommander:getSpellCDSettings('SOD'),
SS = SliceCommander:getSpellCDSettings('SS'),
EVA = SliceCommander:getSpellCDSettings('EVA'),
}
},
Talents = {
order = SliceCommander:getOrder(),
name = L["Talents"],
type = "group",
childGroups = "tree",
args = {
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_AC = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Talents", "AC"),
Shortcut_SUB = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Talents", "SUB"),
Shortcut_SHT = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Talents", "SHT"),
Shortcut_STH = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Talents", "STH"),
Shortcut_STH = SliceCommander:getShortcutSetting("SliceCommander_Sublety", "Talents", "FW"),
AC = SliceCommander:getSpellSettings('AC'),
SUB = SliceCommander:getSpellSettings('SUB'),
SHT = SliceCommander:getSpellCDSettings('SHT'),
STH = SliceCommander:getCDSettings('STH'),
FW = SliceCommander:getSpellSettings('FW'),
}
}
}
}
 
SC_OptionsTable["Complementary"] = {
name = L["Complementary settings"],
name = L["Old settings"],
handler = SliceCommander,
type = "group",
args = {--Display setting
displayDescription = SliceCommander:getDisplayDescriptionSetting(),
CP = {
General = {
order = SliceCommander:getOrder(),
name = SC_SPELL['CP'],
name = L["General settings"],
type = "group",
childGroups = "tree",
args = {
Bar = SliceCommander:getShowSetting('CP'),
Pos = SliceCommander:getPosSetting('CP'),
standart = {
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_FOTD = SliceCommander:getShortcutSetting("SliceCommander_Complementary", "General", "FOTD"),
Shortcut_MAI = SliceCommander:getShortcutSetting("SliceCommander_Complementary", "General", "MAI"),
FOTD = {
order = SliceCommander:getOrder(),
name = string.format(L["%s Settings"], L['Standard']),
type = "header"
name = SC_SPELL['FOTD'],
type = "group",
args = {
Show = SliceCommander:getShowSetting('FOTD'),
Pos = SliceCommander:getPosSetting('FOTD'),
Color = SliceCommander:getColorSetting('FOTD'),
Icon = {--Shadow of the destroyer icon
order = SliceCommander:getOrder(),
name = string.format(L["%s icon"], SC_SPELL['SOTD']),
desc = string.format(L["%s icon. It's only display when stack reach 30. There is a counter on it."], SC_SPELL['SOTD']),
type = "toggle",
set = function(info,val)
SC.SET.display.SOTD = val
end,
get = function(info)
return SC.SET.display.SOTD
end
},
}
},
standardCP1 = SliceCommander:getCPColorSetting(5, 1),
standardCP2 = SliceCommander:getCPColorSetting(5, 2),
standardCP3 = SliceCommander:getCPColorSetting(5, 3),
standardCP4 = SliceCommander:getCPColorSetting(5, 4),
standardCP5 = SliceCommander:getCPColorSetting(5, 5),
DS = SliceCommander:getHeaderSetting('DS'),
DSCP1 = SliceCommander:getCPColorSetting(6, 1),
DSCP2 = SliceCommander:getCPColorSetting(6, 2),
DSCP3 = SliceCommander:getCPColorSetting(6, 3),
DSCP4 = SliceCommander:getCPColorSetting(6, 4),
DSCP5 = SliceCommander:getCPColorSetting(6, 5),
DSCP6 = SliceCommander:getCPColorSetting(6, 6),
ANT = SliceCommander:getHeaderSetting('ANT'),
ANTCP1 = SliceCommander:getCPColorSetting(10, 1),
ANTCP2 = SliceCommander:getCPColorSetting(10, 2),
ANTCP3 = SliceCommander:getCPColorSetting(10, 3),
ANTCP4 = SliceCommander:getCPColorSetting(10, 4),
ANTCP5 = SliceCommander:getCPColorSetting(10, 5),
ANTCP6 = SliceCommander:getCPColorSetting(10, 6),
ANTCP7 = SliceCommander:getCPColorSetting(10, 7),
ANTCP8 = SliceCommander:getCPColorSetting(10, 8),
ANTCP8 = SliceCommander:getCPColorSetting(10, 9),
ANTCP8 = SliceCommander:getCPColorSetting(10, 10),
MAI = SliceCommander:getSpellSettings('MAI'),
}
},
HEALTH = {
Assassination = {
order = SliceCommander:getOrder(),
name = SC_SPELL['HEALTH'],
name = L["Assassination settings"],
type = "group",
childGroups = "tree",
args = {
Bar = SliceCommander:getShowSetting('HEALTH'),
Pos = SliceCommander:getPosSetting('HEALTH'),
healthPercentage = {
order = SliceCommander:getOrder(),
name = L["Show HP Value"],
desc = L["Show HP value rather than health percentage."],
type = "toggle",
set = function(info,val)
SC.SET.HEALTH.value = val
SliceCommander:HealthBar('HEALTH')
end,
get = function(info) return SC.SET.HEALTH.value end
},
healthCombat = {
order = SliceCommander:getOrder(),
name = L["Hide out of combat"],
desc = L["Hide health bar when you are not in combat."],
type = "toggle",
set = function(info,val)
SC.SET.HEALTH.HideCombat = val
SliceCommander:HealthBar('HEALTH')
end,
get = function(info) return SC.SET.HEALTH.HideCombat end
},
MidHealthUnder = {
order = SliceCommander:getOrder(),
name = L["Sound under 50% health"],
desc = L["The sound play when your health reach 50% health"],
type = "select",
dialogControl = 'LSM30_Sound',
values = LSM:HashTable("sound"),
set = function(info,val)
SC.SET.HEALTH.MidUnder = val
end,
get = function(info)
return SC.SET.HEALTH.MidUnder
end
},
LowHealthUnder = {
order = SliceCommander:getOrder(),
name = L["Sound under 35% health"],
desc = L["The sound play when your health reach 35% health"],
type = "select",
dialogControl = 'LSM30_Sound',
values = LSM:HashTable("sound"),
set = function(info,val)
SC.SET.HEALTH.LowUnder = val
end,
get = function(info)
return SC.SET.HEALTH.LowUnder
end
},
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_KB = SliceCommander:getShortcutSetting("SliceCommander_Complementary", "Assassination", "KB"),
Shortcut_BA = SliceCommander:getShortcutSetting("SliceCommander_Complementary", "Assassination", "BA"),
Shortcut_ST = SliceCommander:getShortcutSetting("SliceCommander_Complementary", "Assassination", "ST"),
KB = SliceCommander:getSpellCDSettings('KB'),
BA = SliceCommander:getSpellSettings('BA'),
ST = SliceCommander:getSpellSettings('ST'),
}
},
THEALTH = {
Outlaw = {
order = SliceCommander:getOrder(),
name = SC_SPELL['THEALTH'],
name = L["Outlaw settings"],
type = "group",
childGroups = "tree",
args = {
Bar = SliceCommander:getShowSetting('THEALTH'),
Pos = SliceCommander:getPosSetting('THEALTH'),
healthPercentage = {
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_CDB = SliceCommander:getShortcutSetting("SliceCommander_Complementary", "Outlaw", "CDB"),
Shortcut_BB = SliceCommander:getShortcutSetting("SliceCommander_Complementary", "Outlaw", "BB"),
Shortcut_GSWW = SliceCommander:getShortcutSetting("SliceCommander_Complementary", "Outlaw", "GSWW"),
CDB = SliceCommander:getSpellCDSettings('CDB'),
BB = {
order = SliceCommander:getOrder(),
name = L["Show HP Value"],
desc = L["Show HP value rather than health percentage."],
type = "toggle",
set = function(info,val)
SC.SET.THEALTH.value = val
SliceCommander:HealthBar('THEALTH')
end,
get = function(info) return SC.SET.THEALTH.value end
name = SC_SPELL['BB'],
type = "group",
args = {
BBShow = {
order = SliceCommander:getOrder(),
name = string.format(L["Show %s icon"], SC_SPELL['BB']),
desc = string.format(L["Display the %s icon when enbale"], SC_SPELL['BB']),
width = "full",
type = "toggle",
set = function(info,val)
SC.SET.display.BB = val
end,
get = function(info) return SC.SET.display.BB end
}
}
},
healthCombat = {
order = SliceCommander:getOrder(),
name = L["Hide out of combat"],
desc = L["Hide health bar when you are not in combat."],
type = "toggle",
set = function(info,val)
SC.SET.THEALTH.HideCombat = val
SliceCommander:HealthBar('THEALTH')
end,
get = function(info) return SC.SET.THEALTH.HideCombat end
},
GSWW = SliceCommander:getSpellSettings('GSWW'),
}
},
THREAT = {
Subtlety = {
order = SliceCommander:getOrder(),
name = SC_SPELL['THREAT'],
name = L["Subtlety settings"],
type = "group",
childGroups = "tree",
args = {
Bar = SliceCommander:getShowSetting('THREAT'),
Pos = SliceCommander:getPosSetting('THREAT'),
ThreatGroupOnly = {--Show Threat bar only in group
order = SliceCommander:getOrder(),
name = L["Threat bar only in group"],
desc = L["Display the Threat bar only if you are in a group or a raid"],
type = "toggle",
width = "full",
set = function(info,val)
SC.SET.ThreatGroupOnly = val
end,
get = function(info) return SC.SET.ThreatGroupOnly end
},
Shortcut = SliceCommander:getShortcutHeader(),
Shortcut_GB = SliceCommander:getShortcutSetting("SliceCommander_Complementary", "Subtlety", "GB"),
GB = SliceCommander:getSpellCDSettings('GB'),
}
},
}
}
}
 
1196,7 → 1442,7
SetDefaultOpttion = AceConfigDialog:AddToBlizOptions("SliceCommander_Sublety",L["Subtlety settings"],"SliceCommander "..GetAddOnMetadata("SliceCommander", "Version"))
SetDefaultOpttion.default = function() SliceCommander:ResetOptions() end
 
SetDefaultOpttion = AceConfigDialog:AddToBlizOptions("SliceCommander_Complementary",L["Complementary settings"],"SliceCommander "..GetAddOnMetadata("SliceCommander", "Version"))
SetDefaultOpttion = AceConfigDialog:AddToBlizOptions("SliceCommander_Complementary",L["Old settings"],"SliceCommander "..GetAddOnMetadata("SliceCommander", "Version"))
SetDefaultOpttion.default = function() SliceCommander:ResetOptions() end
 
SetDefaultOpttion = AceConfigDialog:AddToBlizOptions("SliceCommander_Sound",L["Sound settings"],"SliceCommander "..GetAddOnMetadata("SliceCommander", "Version"))
trunk/Core/Event.lua
52,9 → 52,9
SliceCommander:ChangeAnchor()
end
 
function SliceCommander:UNIT_SPELLCAST_START(_, unit, spell)
function SliceCommander:UNIT_SPELLCAST_START(_, unit, _, spellId)
if unit == "player" and SC.SET.displayGCD then
local start, dur = GetSpellCooldown(spell)
local start, dur = GetSpellCooldown(spellId)
if dur and dur > 0 and dur <= 1.5 then
SC.OTHER['AS']['expire'] = start+dur
SC.OTHER['AS']['obj']:SetMinMaxValues(0, dur)
66,7 → 66,7
function SliceCommander:UNIT_MAXPOWER(_, UnitId, PowyerType)
if SC.initDone and UnitId == "player" and PowyerType == "COMBO_POINTS" then
--Update CP Bar
local maxCP = UnitPowerMax("player", SPELL_POWER_COMBO_POINTS)
local maxCP = UnitPowerMax("player", Enum.PowerType.ComboPoints)
 
for i = 1, maxCP do
SC.BARS['CP']['obj'].combos[i].bg:SetVertexColor(unpack(SC.SET.CP[maxCP][i]))
87,16 → 87,10
 
local aSpec = GetSpecialization()
if aSpec == 1 then--POISONS
SC.OTHER['POISON']['obj'].button:SetAttribute("spell1", SC.SET.poison.mh)
SC.OTHER['POISON']['obj'].button:SetAttribute("spell1", SC_SPELL[SC.SET.poison.mh])
SC.OTHER['POISON']['obj'].button:SetAttribute("spell2", SC_SPELL[SC.SET.poison.oh])
if SC.SET.poison.oh == 'none' then
SC.OTHER['POISON']['obj'].button:SetAttribute("spell2", nil)
else
local _, _, _, selected = GetTalentInfo(4, 1, 1)
if selected then
SC.OTHER['POISON']['obj'].button:SetAttribute("spell2", SC.SET.poison.oh)
else
SC.OTHER['POISON']['obj'].button:SetAttribute("spell2", SC_SPELL['CRP'])
end
end
end
end
trunk/Core/Config.lua
127,7 → 127,7
 
function SliceCommander:InitBar()
SC.BARS['CP']['obj'] = SliceCommander:CPFrame()--create Combo Point bar
local maxCP = UnitPowerMax("player", SPELL_POWER_COMBO_POINTS)
local maxCP = UnitPowerMax("player", Enum.PowerType.ComboPoints)
 
for i = 1, maxCP do
SC.BARS['CP']['obj'].combos[i].bg:SetVertexColor(unpack(SC.SET.CP[maxCP][i]))
149,10 → 149,12
SC.BARS['DFA']['obj'].icon:SetTexture("Interface\\Icons\\spell_rogue_deathfromabove")
SC.BARS['CVCD']['obj'].icon:SetTexture("Interface\\Icons\\ability_rogue_crimsonvial")
SC.BARS['KI']['obj'].icon:SetTexture("Interface\\Icons\\ability_kick")
SC.BARS['COSCD']['obj'].icon:SetTexture("Interface\\Icons\\spell_shadow_nethercloak")
SC.BARS['EVACD']['obj'].icon:SetTexture("Interface\\Icons\\spell_shadow_shadowward")
SC.BARS['SPRCD']['obj'].icon:SetTexture("Interface\\Icons\\ability_rogue_sprint")
SC.BARS['SSCD']['obj'].icon:SetTexture("Interface\\Icons\\ability_rogue_shadowstep")
SC.BARS['EVCD']['obj'].icon:SetTexture("Interface\\Icons\\spell_shadow_shadowward")
SC.BARS['COSCD']['obj'].icon:SetTexture("Interface\\Icons\\spell_shadow_nethercloak")
 
 
--ASSASSINATION
SC.BARS['VENCD']['obj'].icon:SetTexture("Interface\\Icons\\Ability_Rogue_Deadliness")
SC.BARS['EX']['obj'].icon:SetTexture("Interface\\Icons\\ability_deathwing_bloodcorruption_earth")
164,18 → 166,22
SC.BARS['ARCD']['obj'].icon:SetTexture("Interface\\Icons\\Spell_Shadow_ShadowWordDominate")
SC.BARS['KSP']['obj'].icon:SetTexture("Interface\\Icons\\Ability_Rogue_Murderspree")
SC.BARS['GH']['obj'].icon:SetTexture("Interface\\Icons\\ability_rogue_grapplinghook")
SC.BARS['CB']['obj'].icon:SetTexture("Interface\\Icons\\ability_rogue_cannonballbarrage")
SC.BARS['PA']['obj'].icon:SetTexture("Interface\\Icons\\achievement_character_human_male")
SC.BARS['BE']['obj'].icon:SetTexture("Interface\\Icons\\inv_weapon_rifle_01")
SC.BARS['BECD']['obj'].icon:SetTexture("Interface\\Icons\\inv_weapon_rifle_01")
SC.BARS['RB']['obj'].icon:SetTexture("Interface\\Icons\\ability_rogue_rollthebones")
SC.BARS['CDBCD']['obj'].icon:SetTexture("Interface\\Icons\\inv_sword_1h_artifactskywall_d_01dual")
SC.BARS['RICD']['obj'].icon:SetTexture("Interface\\Icons\\ability_parry")
SC.BARS['BFCD']['obj'].icon:SetTexture("Interface\\Icons\\Ability_Warrior_PunishingBlow")
SC.BARS['GSCD']['obj'].icon:SetTexture("Interface\\Icons\\ability_creature_cursed_02")
SC.BARS['BRCD']['obj'].icon:SetTexture("Interface\\Icons\\ability_arakkoa_spinning_blade")
SC.BARS['RIPCD']['obj'].icon:SetTexture("Interface\\Icons\\ability_parry")
SC.BARS['GGCD']['obj'].icon:SetTexture("Interface\\Icons\\ability_gouge")
 
--SUBTLETY
SC.BARS['SDCD']['obj'].icon:SetTexture("Interface\\Icons\\Ability_Rogue_Shadowdance")
SC.BARS['SBCD']['obj'].icon:SetTexture("Interface\\Icons\\inv_knife_1h_grimbatolraid_d_03")
SC.BARS['GBCD']['obj'].icon:SetTexture("Interface\\Icons\\inv_knife_1h_artifactfangs_d_01")
SC.BARS['SODCD']['obj'].icon:SetTexture("Interface\\Icons\\spell_shadow_rune")
SC.BARS['SHTCD']['obj'].icon:SetTexture("Interface\\Icons\\ability_rogue_throwingspecialization")
SC.BARS['STH']['obj'].icon:SetTexture("Interface\\Icons\\ability_rogue_sinistercalling")
 
SliceCommander:DisableIcon(SC.BARS['THREAT']['obj'], 110)
SliceCommander:DisableIcon(SC.BARS['HEALTH']['obj'], 100)
263,9 → 269,9
function SliceCommander:SetSparks()
local spec = GetSpecialization()
 
SC.Spark[1]:SCPoint("TOPLEFT", VTimerEnergy, "TOPLEFT", ((SC.SET.Energy[spec][1] / UnitPowerMax("player", SPELL_POWER_ENERGY) * SC.SET.Width)-1), 0)
SC.Spark[2]:SCPoint("TOPLEFT", VTimerEnergy, "TOPLEFT", ((SC.SET.Energy[spec][2] / UnitPowerMax("player", SPELL_POWER_ENERGY) * SC.SET.Width)-1), 0)
SC.Spark[3]:SCPoint("TOPLEFT", VTimerEnergy, "TOPLEFT", ((SC.SET.Energy[spec][3] / UnitPowerMax("player", SPELL_POWER_ENERGY) * SC.SET.Width)-1), 0)
SC.Spark[1]:SCPoint("TOPLEFT", VTimerEnergy, "TOPLEFT", ((SC.SET.Energy[spec][1] / UnitPowerMax("player", Enum.PowerType.Energy) * SC.SET.Width)-1), 0)
SC.Spark[2]:SCPoint("TOPLEFT", VTimerEnergy, "TOPLEFT", ((SC.SET.Energy[spec][2] / UnitPowerMax("player", Enum.PowerType.Energy) * SC.SET.Width)-1), 0)
SC.Spark[3]:SCPoint("TOPLEFT", VTimerEnergy, "TOPLEFT", ((SC.SET.Energy[spec][3] / UnitPowerMax("player", Enum.PowerType.Energy) * SC.SET.Width)-1), 0)
end
 
function SliceCommander:LockCkecked(checked)
319,7 → 325,7
 
function SliceCommander:SetWidth(w)
local pxMargin = 1
local maxCP = UnitPowerMax("player", SPELL_POWER_COMBO_POINTS)
local maxCP = UnitPowerMax("player", Enum.PowerType.ComboPoints)
if SC.SET.skin then
pxMargin = 7
end
429,7 → 435,7
 
SC.BARS['CP']['obj']:SCHeight(h)
SC.BARS['CP']['obj'].comboText:SCHeight(h)
local maxCP = UnitPowerMax("player", SPELL_POWER_COMBO_POINTS)
local maxCP = UnitPowerMax("player", Enum.PowerType.ComboPoints)
for i = 1, maxCP do
SC.BARS['CP']['obj'].combos[i]:SCHeight(h)
SliceCommander:SetSizeBorder(0, h, SC.BARS['CP']['obj'].combos[i].border)
466,13 → 472,27
if _G['SC'].version < '7.18' then
_G['SC'].SET.Pos['ES'] = nil--REMOVE ENVELOPPING SHADOW
_G['SC'].BARS['ES'] = nil
_G['SC'].SET.poison.mh = SC_SPELL['DP']--REMOVE AGONIZING POISON
_G['SC'].SET.Pos['AP'] = nil
_G['SC'].BARS['AP'] = nil
_G['SC'].SET.Pos['AP'] = nil
_G['SC'].BARS['SOD']['pandemic'] = nil--SYMBOL OF DEATH NOW HAS LONGER CD
_G['SC'].BARS['SOD']['pandemictimer'] = nil
_G['SC'].BARS['SOD']['pandemicobj'] = nil
end
--if _G['SC'].version < '8.00' then
_G['SC'].SET.Pos['CB'] = nil--REMOVE CANONBALL BARAGE
_G['SC'].BARS['CB'] = nil
_G['SC'].SET.Pos['HEM'] = nil--REMOVE Hemorrhage
_G['SC'].BARS['HEM'] = nil
_G['SC'].SET.Pos['PA'] = nil--REMOVE Parley
_G['SC'].BARS['PA'] = nil
_G['SC'].SET.poison.mh = 'DP'--USING ID
_G['SC'].SET.poison.oh = 'CRP'--USING ID
_G['SC'].SET.CP[10] = nil--RMOVED Anticipation
_G['SC'].SET.RB['SC'] = 'SS'
_G['SC'].SET.RB['RP'] = 'Crit'
_G['SC'].SET.Pos['STHCD'] = nil--REMOVE CANONBALL BARAGE
_G['SC'].BARS['STHCD'] = nil
--end
_G['SC'].version = GetAddOnMetadata("SliceCommander", "Version")
end
end
519,8 → 539,8
end
 
function SliceCommander:Global()
SliceCommander:DisplaySpells({'CP', 'THREAT', 'CS', 'KS', 'KSCD', 'FOTD', 'CV', 'CVCD', 'TOT', 'FE', 'SSCD', 'SUB', 'CD', 'AC', 'MD', 'DFA', 'Poison', 'SOTD', 'MAI' })
SliceCommander:NotDisplaySpells({'HEALTH', 'THEALTH', 'VAN', 'KI', 'EV', 'EVCD', 'COS', 'COSCD', 'SS'})
SliceCommander:DisplaySpells({'CP', 'THREAT', 'CS', 'KS', 'KSCD', 'FOTD', 'CV', 'CVCD', 'TOT', 'FE', 'SSCD', 'SUB', 'CD', 'AC', 'MD', 'DFA', 'Poison', 'SOTD', 'MAI', 'FECD'})
SliceCommander:NotDisplaySpells({'HEALTH', 'THEALTH', 'VAN', 'KI', 'COS', 'COSCD', 'EVA', 'EVACD', 'SPR', 'SPRCD', 'SS'})
 
_G['SC'].orderBar = _G['SC'].maxPos
_G['SC'].orderCDBar = _G['SC'].maxCDPos
529,40 → 549,41
SC.SET.Pos.CP = -1
end
 
SliceCommander:OrderSpells({'FOTD', 'CV', 'FE', 'SUB', 'AC', 'MAI', 'SS', 'EV', 'COS'})
SliceCommander:OrderCDs({'CVCD', 'TOT', 'VAN', 'SSCD', 'CD', 'MD', 'DFA', 'THREAT', 'HEALTH', 'THEALTH', 'CS', 'KS', 'KSCD', 'KI', 'EVCD', 'COSCD'})
SliceCommander:OrderSpells({'FOTD', 'CV', 'FE', 'SUB', 'AC', 'MAI', 'COS', 'EVA', 'SPR', 'SS'})
SliceCommander:OrderCDs({'CVCD', 'TOT', 'VAN', 'SSCD', 'CD', 'MD', 'DFA', 'THREAT', 'HEALTH', 'THEALTH', 'CS', 'KS', 'KSCD', 'KI', 'COSCD', 'EVACD', 'SPRCD', 'FECD'})
end
 
function SliceCommander:Assassination()
SliceCommander:DisplaySpells({'RUP', 'GAR', 'GARCD', 'VEN', 'VENCD', 'ENV', 'HEM', 'EP', 'DPICON', 'DPBUT', 'EX', 'KB', 'KBCD', 'BA', 'ST', 'TXB', 'TXBCD'})
SliceCommander:DisplaySpells({'RUP', 'GAR', 'GARCD', 'VEN', 'VENCD', 'ENV', 'EP', 'DPICON', 'DPBUT', 'EX', 'KB', 'KBCD', 'BA', 'ST', 'TXB', 'TXBCD', 'BLS', 'MA', 'CT'})
SliceCommander:NotDisplaySpells({'DP'})
 
_G['SC'].orderBar = 0
_G['SC'].orderCDBar = -1
 
SliceCommander:OrderSpells({'GAR', 'RUP', 'ENV', 'KB', 'BA', 'ST', 'HEM', 'VEN', 'DP', 'EP', 'TXB'})
SliceCommander:OrderSpells({'GAR', 'RUP', 'ENV', 'KB', 'BA', 'ST', 'VEN', 'DP', 'EP', 'TXB', 'BLS', 'MA', 'CT'})
SliceCommander:OrderCDs({'VENCD', 'KBCD', 'EX', 'GARCD', 'TXBCD'})
end
 
function SliceCommander:Outlaw()
SliceCommander:DisplaySpells({'SND', 'RB', 'AR', 'ARCD', 'CDB', 'CDBCD', 'KSP', 'GS', 'GH', 'CB', 'BE', 'BF', 'OP', 'GSWW', 'BB', 'LD'})
SliceCommander:NotDisplaySpells({'PA', 'RI', 'RICD'})
SliceCommander:DisplaySpells({'SND', 'RB', 'AR', 'ARCD', 'CDB', 'CDBCD', 'KSP', 'GS', 'GH', 'BE', 'BECD', 'BF', 'BFCD', 'OP', 'GSWW', 'BB', 'LD', 'GSCD', 'BRCD'})
SliceCommander:NotDisplaySpells({'BFICON', 'BR', 'RIP', 'RIPCD', 'GG', 'GGCD'})
 
_G['SC'].orderBar = 0
_G['SC'].orderCDBar = -1
 
SliceCommander:OrderSpells({'SND', 'RB', 'AR', 'GS', 'OP', 'CDB', 'GSWW', 'RI'})
SliceCommander:OrderCDs({'BE', 'ARCD', 'KSP', 'CB', 'GH', 'PA', 'CDBCD', 'LD', 'RICD'})
SliceCommander:OrderSpells({'SND', 'RB', 'AR', 'GS', 'OP', 'CDB', 'GSWW', 'BF', 'BR', 'RIP'})
SliceCommander:OrderCDs({'BECD', 'BE', 'ARCD', 'BFCD', 'KSP', 'GH', 'CDBCD', 'LD', 'GSCD', 'BRCD', 'RIPCD', 'GG', 'GGCD'})
end
 
function SliceCommander:Subtlety()
SliceCommander:DisplaySpells({'SD', 'SDCD', 'SB', 'SBCD', 'NB', 'SOD', 'GB', 'GBCD', 'SODCD' })
SliceCommander:DisplaySpells({'SD', 'SDCD', 'SB', 'SBCD', 'NB', 'SOD', 'GB', 'GBCD', 'SODCD', 'SHT', 'SHTCD', 'STH'})
SliceCommander:NotDisplaySpells({'FW'})
 
_G['SC'].orderBar = 0
_G['SC'].orderCDBar = -1
 
SliceCommander:OrderSpells({'GB', 'NB', 'SOD', 'SD', 'SB'})
SliceCommander:OrderCDs({'GBCD', 'SDCD', 'SBCD', 'SODCD'})
SliceCommander:OrderSpells({'GB', 'NB', 'SOD', 'SD', 'SB', 'SHT', 'FW'})
SliceCommander:OrderCDs({'GBCD', 'SDCD', 'SBCD', 'SODCD', 'SHTCD', 'STH'})
 
end
 
597,23 → 618,23
function SliceCommander:SetRB()
if SC.SET.RB == nil then
SC.SET.RB = {
['JR'] = 'SaS',
['SC'] = 'SS',
['GM'] = 'AS',
['SIW'] = 'Crit',
['RP'] = 'Crit',
['TB'] = 'CDR',
['BT'] = 'NRJ',
['BS'] = 'CP+'
}
SC.SET.display.RBName = true
SC.BARS['RB'].subbar = {
'JR',
'GM',
'SIW',
'TB',
'BT',
'BS'
}
end
SC.BARS['RB'].subbar = {
[SC_SPELLID['SC']] = 'SC',
[SC_SPELLID['GM']] = 'GM',
[SC_SPELLID['RP']] = 'RP',
[SC_SPELLID['TB']] = 'TB',
[SC_SPELLID['BT']] = 'BT',
[SC_SPELLID['BS']] = 'BS'
}
end
 
function SliceCommander:TestValueOptions()
747,26 → 768,12
}
}
end
if SC.SET.CP[10] == nil then
SC.SET.CP[10] = {
[1] = {.33, .63, .33},
[2] = {.46, .63, .35},
[3] = {.65, .63, .35},
[4] = {.65, .42, .31},
[5] = {.69, .31, .31},
[6] = {.5, .5, .5},
[7] = {.5, .5, .5},
[8] = {.5, .5, .5},
[9] = {.5, .5, .5},
[10] = {.5, .5, .5},
}
end
if SC.SET.energyColor == nil then
SC.SET.energyColor = {.92, .92, .92}
end
if SC.SET.poison.mh == nil or SC.SET.poison.oh == nil then
SC.SET.poison.mh = SC_SPELL['DP']
SC.SET.poison.oh = SC_SPELL['LP']
SC.SET.poison.mh = 2818--DP
SC.SET.poison.oh = 108211--LP
end
if SC.SET.font == nil then
SC.SET.font = "Friz Quadrata TT"
895,6 → 902,9
if SC.BARS['FE'] == nil then--Feint
SC.BARS['FE'] = {['color'] = {.15, .42, .68}}
end
if SC.BARS['FECD'] == nil then--Feint CD
SC.BARS['FECD'] = {['color'] = {.15, .42, .68}}
end
if SC.BARS['KI'] == nil then--Kick
SC.BARS['KI'] = {['color'] = {.42, .46, .51}}
end
929,18 → 939,24
if SC.BARS['TOT'] == nil then--Tricks of the Trade
SC.BARS['TOT'] = {['color'] = {.3, .3, 1}}
end
if SC.BARS['EV'] == nil then--Evasion
SC.BARS['EV'] = {['color'] = {.42, .46, .51}}
end
if SC.BARS['EVCD'] == nil then--Evasion CD
SC.BARS['EVCD'] = {['color'] = {.42, .46, .51}}
end
if SC.BARS['COS'] == nil then--Cloak of Shadows
SC.BARS['COS'] = {['color'] = {.52, .18, .54}}
SC.BARS['COS'] = {['color'] = {.2, .4, .53}}
end
if SC.BARS['COSCD'] == nil then--Cloak of Shadows CD
SC.BARS['COSCD'] = {['color'] = {.52, .18, .54}}
SC.BARS['COSCD'] = {['color'] = {.12, .32, .45}}
end
if SC.BARS['EVA'] == nil then--Evasion
SC.BARS['EVA'] = {['color'] = {.42, .46, .51}}
end
if SC.BARS['EVACD'] == nil then--Evasion CD
SC.BARS['EVACD'] = {['color'] = {.42, .46, .51}}
end
if SC.BARS['SPR'] == nil then--Sprint
SC.BARS['SPR'] = {['color'] = {.83, .51, .27}}
end
if SC.BARS['SPRCD'] == nil then--Sprint CD
SC.BARS['SPRCD'] = {['color'] = {.83, .51, .27}}
end
end
 
function SliceCommander:InitAssassinationBarArray()
967,9 → 983,6
if SC.BARS['EX'] == nil then--Exsanguinate
SC.BARS['EX'] = {['color'] = {.83, .27, .27}}
end
if SC.BARS['HEM'] == nil then--Hemorrhage
SC.BARS['HEM'] = {['color'] = {.66, .22, .47}}
end
if SC.BARS['DP'] == nil then--Deadly Poison
SC.BARS['DP'] = {['color'] = {.27, .68, .23}}
end
1000,6 → 1013,19
if SC.BARS['VENCD'] == nil then--Vendetta CD
SC.BARS['VENCD'] = {['color'] = {.71, .4, .15}}
end
if SC.BARS['BLS'] == nil then--Blindside
SC.BARS['BLS'] = {['color'] = {.52, .38, .75}}
end
if SC.BARS['MA'] == nil then--Master Assassin
SC.BARS['MA'] = {['color'] = {.42, .46, .51}}
end
if SC.BARS['CT'] == nil then--Crimson Tempest
SC.BARS['CT'] = {['color'] = {.71, .15, .15}}
end
SC.BARS['CT']['tick'] = {
['obj'] = {},
['value'] = 2
}
end
 
function SliceCommander:InitOutlawBarArray()--http://paletton.com/#uid=60s0u0klqqvbNEzh9uFpomItmi0
1024,8 → 1050,8
if SC.BARS['GS'] == nil then--Ghostly Strike
SC.BARS['GS'] = {['color'] = {.81, .27, .3}}
end
if SC.BARS['CB'] == nil then--Cannonball Barrage
SC.BARS['CB'] = {['color'] = {.65, .22, .48}}
if SC.BARS['GSCD'] == nil then--Ghostly Strike CD
SC.BARS['GSCD'] = {['color'] = {.81, .27, .3}}
end
if SC.BARS['OP'] == nil then--Opportunity
SC.BARS['OP'] = {['color'] = {.83, .73, .27}}
1033,27 → 1059,45
if SC.BARS['GSWW'] == nil then--Greenskin's Waterlogged Wristcuffs
SC.BARS['GSWW'] = {['color'] = {.81, .27, .3}}
end
if SC.BARS['PA'] == nil then--Parley
SC.BARS['PA'] = {['color'] = {.83, .73, .27}}
end
if SC.BARS['GH'] == nil then--Grappling Hook
SC.BARS['GH'] = {['color'] = {.83, .82, .27}}
end
if SC.BARS['BE'] == nil then--Between the Eyes
SC.BARS['BE'] = {['color'] = {.62, .78, .26}}
end
if SC.BARS['BECD'] == nil then--Between the Eyes CD
SC.BARS['BECD'] = {['color'] = {.62, .78, .26}}
end
if SC.BARS['KSP'] == nil then--Killing Spree
SC.BARS['KSP'] = {['color'] = {.27, .68, .23}}
end
if SC.BARS['LD'] == nil then--Loaded Dice
SC.BARS['LD'] = {['color'] = {.63, .52, .38}}
end
if SC.BARS['RI'] == nil then--Riposte
SC.BARS['RI'] = {['color'] = {.42, .46, .51}}
if SC.BARS['BF'] == nil then--Blade Flury
SC.BARS['BF'] = {['color'] = {.66, .22, .47}}
end
if SC.BARS['RICD'] == nil then--Riposte CD
SC.BARS['RICD'] = {['color'] = {.42, .46, .51}}
if SC.BARS['BFCD'] == nil then--Blade Flury CD
SC.BARS['BFCD'] = {['color'] = {.66, .22, .47}}
end
if SC.BARS['BR'] == nil then--Blade Rush
SC.BARS['BR'] = {['color'] = {.99, .99, .56}}
end
if SC.BARS['BRCD'] == nil then--Blade Rush CD
SC.BARS['BRCD'] = {['color'] = {.99, .99, .56}}
end
if SC.BARS['RIP'] == nil then--Riposte
SC.BARS['RIP'] = {['color'] = {.42, .46, .51}}
end
if SC.BARS['RIPCD'] == nil then--Riposte CD
SC.BARS['RIPCD'] = {['color'] = {.42, .46, .51}}
end
if SC.BARS['GG'] == nil then--Gouge
SC.BARS['GG'] = {['color'] = {.81, .27, .3}}
end
if SC.BARS['GGCD'] == nil then--Gouge CD
SC.BARS['GGCD'] = {['color'] = {.81, .27, .3}}
end
end
 
function SliceCommander:InitSubtletyBarArray()--http://paletton.com/#uid=64r0u0kleqtbzEKgVuIpcmGtdhZ
1066,16 → 1110,16
if SC.BARS['NB'] == nil then--Nightblade
SC.BARS['NB'] = {['color'] = {.52, .18, .54}}
end
SC.BARS['NB']['tick'] = {
['obj'] = {},
['value'] = 2
}
if SC.BARS['SOD'] == nil then--Symbols of Death
SC.BARS['SOD'] = {['color'] = {.25, .26, .58}}
end
if SC.BARS['SODCD'] == nil then--Symbols of Death CD
SC.BARS['SODCD'] = {['color'] = {.25, .26, .58}}
end
SC.BARS['NB']['tick'] = {
['obj'] = {},
['value'] = 2
}
if SC.BARS['SB'] == nil then--Shadow Blades
SC.BARS['SB'] = {['color'] = {.19, .58, .39}}
end
1088,6 → 1132,22
if SC.BARS['SDCD'] == nil then--Shadow Dance CD
SC.BARS['SDCD'] = {['color'] = {.12, .32, .45}}
end
if SC.BARS['SHT'] == nil then--Shuriken Tornado
SC.BARS['SHT'] = {['color'] = {.6, .55, .17}}
end
SC.BARS['SHT']['tick'] = {
['obj'] = {},
['value'] = 1
}
if SC.BARS['SHTCD'] == nil then--Shuriken Tornado CD
SC.BARS['SHTCD'] = {['color'] = {.6, .55, .17}}
end
if SC.BARS['STH'] == nil then--Secret Technique
SC.BARS['STH'] = {['color'] = {.52, .18, .54}}
end
if SC.BARS['FW'] == nil then--Find Weakness
SC.BARS['FW'] = {['color'] = {.28, .86, .47}}
end
end
 
function SliceCommander:InitBarArray()
1105,14 → 1165,15
SC.BARS[k]['pandemic'] = false
SC.BARS[k]['expire'] = 0
SC.BARS[k]['name'] = SC_SPELL[k]
SC.BARS[k]['id'] = SC_SPELLID[k]
end
 
local buff = {'FOTD', 'AR', 'SUB', 'EP', 'CV', 'AC', 'FE', 'SND', 'SD', 'SOD', 'SB', 'OP', 'ENV', 'GB', 'GSWW', 'MAI', 'LD', 'SS', 'EV', 'COS', 'RI'}
local buff = {'FOTD', 'AR', 'SUB', 'EP', 'CV', 'AC', 'FE', 'SND', 'SD', 'SOD', 'SB', 'OP', 'ENV', 'GB', 'GSWW', 'MAI', 'LD', 'BF', 'SHT', 'COS', 'EVA', 'SPR', 'BLS', 'MA', 'BR', 'RIP', 'SS'}
for i, v in ipairs(buff) do
SC.BARS[v]['type'] = 1
end
 
local debuff = {'GAR', 'HEM', 'RUP', 'DP', 'KS', 'CS', 'NB', 'VEN', 'GS', 'KB', 'BA', 'ST', 'TXB'}
local debuff = {'GAR', 'RUP', 'DP', 'KS', 'CS', 'NB', 'VEN', 'GS', 'KB', 'BA', 'ST', 'TXB', 'CT', 'BE', 'GG', 'FW'}
for i, v in ipairs(debuff) do
SC.BARS[v]['type'] = 2
end
1122,12 → 1183,13
SC.BARS[v]['type'] = 3
end
 
local cd = {'VAN', 'KSP', 'ARCD', 'CDBCD', 'CVCD', 'MD', 'GH', 'PA', 'CB', 'BE', 'TOT', 'SDCD', 'SBCD', 'VENCD', 'GBCD', 'EX', 'GARCD', 'KBCD', 'KSCD', 'DFA', 'KI', 'TXBCD', 'SODCD', 'EVCD', 'COSCD', 'RICD'}
local cd = {'SS', 'VAN', 'KSP', 'ARCD', 'CDBCD', 'CVCD', 'MD', 'GH', 'BECD', 'TOT', 'SDCD', 'SBCD', 'VENCD', 'GBCD', 'EX', 'GARCD', 'KBCD', 'KSCD', 'DFA', 'KI', 'TXBCD', 'SODCD', 'SHTCD', 'STH', 'COSCD', 'EVACD', 'SPRCD', 'FECD', 'GSCD', 'BRCD', 'RIPCD', 'GGCD', 'SSCD'}
for i, v in ipairs(cd) do
SC.BARS[v]['type'] = 4
end
 
SC.BARS['SDCD']['type'] = 5
SC.BARS['BFCD']['type'] = 5
SC.BARS['SSCD']['type'] = 5
SC.BARS['RB']['type'] = 6
--[[local chargecd = {'SDCD'}
1142,8 → 1204,6
 
local pandemic = {
['GAR'] = '18',
['HEM'] = '20',
['GS'] = '15',
['SND'] = {
[0] = 0,
[1] = 12,
trunk/Core/Object.lua
113,7 → 113,7
VTimerEnergy:SetMinMaxValues(0,100)
VTimerEnergy:SCPoint('CENTER', SliceCommanderFrame, 'CENTER', 0, 0)
VTimerEnergy:SetFrameLevel(1)
VTimerEnergy:SetMinMaxValues(0,UnitPowerMax("player", SPELL_POWER_ENERGY))
VTimerEnergy:SetMinMaxValues(0,UnitPowerMax("player", Enum.PowerType.Energy))
VTimerEnergy:SetDefaultBackdrop()
VTimerEnergy:SetBackdropBorderColor(unpack(SC.V.wColor))
VTimerEnergy:SetBackdropColor(unpack({.1,.1,.1,.7}))
trunk/Libs/AceGUI-3.0/AceGUI-3.0.lua
24,8 → 24,8
-- f:AddChild(btn)
-- @class file
-- @name AceGUI-3.0
-- @release $Id: AceGUI-3.0.lua 1102 2013-10-25 14:15:23Z nevcairiel $
local ACEGUI_MAJOR, ACEGUI_MINOR = "AceGUI-3.0", 34
-- @release $Id: AceGUI-3.0.lua 1177 2018-06-25 12:12:48Z nevcairiel $
local ACEGUI_MAJOR, ACEGUI_MINOR = "AceGUI-3.0", 36
local AceGUI, oldminor = LibStub:NewLibrary(ACEGUI_MAJOR, ACEGUI_MINOR)
 
if not AceGUI then return end -- No upgrade needed
811,3 → 811,221
height = height + rowheight + 3
safecall(content.obj.LayoutFinished, content.obj, nil, height)
end)
 
-- Get alignment method and value. Possible alignment methods are a callback, a number, "start", "middle", "end", "fill" or "TOPLEFT", "BOTTOMRIGHT" etc.
local GetCellAlign = function (dir, tableObj, colObj, cellObj, cell, child)
local fn = cellObj and (cellObj["align" .. dir] or cellObj.align)
or colObj and (colObj["align" .. dir] or colObj.align)
or tableObj["align" .. dir] or tableObj.align
or "CENTERLEFT"
local child, cell, val = child or 0, cell or 0, nil
 
if type(fn) == "string" then
fn = fn:lower()
fn = dir == "V" and (fn:sub(1, 3) == "top" and "start" or fn:sub(1, 6) == "bottom" and "end" or fn:sub(1, 6) == "center" and "middle")
or dir == "H" and (fn:sub(-4) == "left" and "start" or fn:sub(-5) == "right" and "end" or fn:sub(-6) == "center" and "middle")
or fn
val = (fn == "start" or fn == "fill") and 0 or fn == "end" and cell - child or (cell - child) / 2
elseif type(fn) == "function" then
val = fn(child or 0, cell, dir)
else
val = fn
end
 
return fn, max(0, min(val, cell))
end
 
-- Get width or height for multiple cells combined
local GetCellDimension = function (dir, laneDim, from, to, space)
local dim = 0
for cell=from,to do
dim = dim + (laneDim[cell] or 0)
end
return dim + max(0, to - from) * (space or 0)
end
 
--[[ Options
============
Container:
- columns ({col, col, ...}): Column settings. "col" can be a number (<= 0: content width, <1: rel. width, <10: weight, >=10: abs. width) or a table with column setting.
- space, spaceH, spaceV: Overall, horizontal and vertical spacing between cells.
- align, alignH, alignV: Overall, horizontal and vertical cell alignment. See GetCellAlign() for possible values.
Columns:
- width: Fixed column width (nil or <=0: content width, <1: rel. width, >=1: abs. width).
- min or 1: Min width for content based width
- max or 2: Max width for content based width
- weight: Flexible column width. The leftover width after accounting for fixed-width columns is distributed to weighted columns according to their weights.
- align, alignH, alignV: Overwrites the container setting for alignment.
Cell:
- colspan: Makes a cell span multiple columns.
- rowspan: Makes a cell span multiple rows.
- align, alignH, alignV: Overwrites the container and column setting for alignment.
]]
AceGUI:RegisterLayout("Table",
function (content, children)
local obj = content.obj
obj:PauseLayout()
 
local tableObj = obj:GetUserData("table")
local cols = tableObj.columns
local spaceH = tableObj.spaceH or tableObj.space or 0
local spaceV = tableObj.spaceV or tableObj.space or 0
local totalH = (content:GetWidth() or content.width or 0) - spaceH * (#cols - 1)
 
-- We need to reuse these because layout events can come in very frequently
local layoutCache = obj:GetUserData("layoutCache")
if not layoutCache then
layoutCache = {{}, {}, {}, {}, {}, {}}
obj:SetUserData("layoutCache", layoutCache)
end
local t, laneH, laneV, rowspans, rowStart, colStart = unpack(layoutCache)
 
-- Create the grid
local n, slotFound = 0
for i,child in ipairs(children) do
if child:IsShown() then
repeat
n = n + 1
local col = (n - 1) % #cols + 1
local row = ceil(n / #cols)
local rowspan = rowspans[col]
local cell = rowspan and rowspan.child or child
local cellObj = cell:GetUserData("cell")
slotFound = not rowspan
 
-- Rowspan
if not rowspan and cellObj and cellObj.rowspan then
rowspan = {child = child, from = row, to = row + cellObj.rowspan - 1}
rowspans[col] = rowspan
end
if rowspan and i == #children then
rowspan.to = row
end
 
-- Colspan
local colspan = max(0, min((cellObj and cellObj.colspan or 1) - 1, #cols - col))
n = n + colspan
 
-- Place the cell
if not rowspan or rowspan.to == row then
t[n] = cell
rowStart[cell] = rowspan and rowspan.from or row
colStart[cell] = col
 
if rowspan then
rowspans[col] = nil
end
end
until slotFound
end
end
 
local rows = ceil(n / #cols)
 
-- Determine fixed size cols and collect weights
local extantH, totalWeight = totalH, 0
for col,colObj in ipairs(cols) do
laneH[col] = 0
 
if type(colObj) == "number" then
colObj = {[colObj >= 1 and colObj < 10 and "weight" or "width"] = colObj}
cols[col] = colObj
end
 
if colObj.weight then
-- Weight
totalWeight = totalWeight + (colObj.weight or 1)
else
if not colObj.width or colObj.width <= 0 then
-- Content width
for row=1,rows do
local child = t[(row - 1) * #cols + col]
if child then
local f = child.frame
f:ClearAllPoints()
local childH = f:GetWidth() or 0
 
laneH[col] = max(laneH[col], childH - GetCellDimension("H", laneH, colStart[child], col - 1, spaceH))
end
end
 
laneH[col] = max(colObj.min or colObj[1] or 0, min(laneH[col], colObj.max or colObj[2] or laneH[col]))
else
-- Rel./Abs. width
laneH[col] = colObj.width < 1 and colObj.width * totalH or colObj.width
end
extantH = max(0, extantH - laneH[col])
end
end
 
-- Determine sizes based on weight
local scale = totalWeight > 0 and extantH / totalWeight or 0
for col,colObj in pairs(cols) do
if colObj.weight then
laneH[col] = scale * colObj.weight
end
end
 
-- Arrange children
for row=1,rows do
local rowV = 0
 
-- Horizontal placement and sizing
for col=1,#cols do
local child = t[(row - 1) * #cols + col]
if child then
local colObj = cols[colStart[child]]
local cellObj = child:GetUserData("cell")
local offsetH = GetCellDimension("H", laneH, 1, colStart[child] - 1, spaceH) + (colStart[child] == 1 and 0 or spaceH)
local cellH = GetCellDimension("H", laneH, colStart[child], col, spaceH)
 
local f = child.frame
f:ClearAllPoints()
local childH = f:GetWidth() or 0
 
local alignFn, align = GetCellAlign("H", tableObj, colObj, cellObj, cellH, childH)
f:SetPoint("LEFT", content, offsetH + align, 0)
if child:IsFullWidth() or alignFn == "fill" or childH > cellH then
f:SetPoint("RIGHT", content, "LEFT", offsetH + align + cellH, 0)
end
 
if child.DoLayout then
child:DoLayout()
end
 
rowV = max(rowV, (f:GetHeight() or 0) - GetCellDimension("V", laneV, rowStart[child], row - 1, spaceV))
end
end
 
laneV[row] = rowV
 
-- Vertical placement and sizing
for col=1,#cols do
local child = t[(row - 1) * #cols + col]
if child then
local colObj = cols[colStart[child]]
local cellObj = child:GetUserData("cell")
local offsetV = GetCellDimension("V", laneV, 1, rowStart[child] - 1, spaceV) + (rowStart[child] == 1 and 0 or spaceV)
local cellV = GetCellDimension("V", laneV, rowStart[child], row, spaceV)
 
local f = child.frame
local childV = f:GetHeight() or 0
 
local alignFn, align = GetCellAlign("V", tableObj, colObj, cellObj, cellV, childV)
if child:IsFullHeight() or alignFn == "fill" then
f:SetHeight(cellV)
end
f:SetPoint("TOP", content, 0, -(offsetV + align))
end
end
end
 
-- Calculate total height
local totalV = GetCellDimension("V", laneV, 1, #laneV, spaceV)
 
-- Cleanup
for _,v in pairs(layoutCache) do wipe(v) end
 
safecall(obj.LayoutFinished, obj, nil, totalV)
obj:ResumeLayout()
end)
trunk/Libs/AceGUI-3.0/widgets/AceGUIContainer-Window.lua
32,7 → 32,7
end
 
local function closeOnClick(this)
PlaySound(PlaySoundKitID and "gsTitleOptionExit" or 799) -- SOUNDKIT.GS_TITLE_OPTION_EXIT
PlaySound(799) -- SOUNDKIT.GS_TITLE_OPTION_EXIT
this.obj:Hide()
end
 
trunk/Libs/AceGUI-3.0/widgets/AceGUIContainer-TreeGroup.lua
2,10 → 2,12
TreeGroup Container
Container that uses a tree control to switch between groups.
-------------------------------------------------------------------------------]]
local Type, Version = "TreeGroup", 40
local Type, Version = "TreeGroup", 41
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
local WoW80 = select(4, GetBuildInfo()) >= 80000
 
-- Lua APIs
local next, pairs, ipairs, assert, type = next, pairs, ipairs, assert, type
local math_min, math_max, floor = math.min, math.max, floor
162,7 → 164,7
local function FirstFrameUpdate(frame)
local self = frame.obj
frame:SetScript("OnUpdate", nil)
self:RefreshTree()
self:RefreshTree(nil, true)
end
 
local function BuildUniqueValue(...)
300,6 → 302,8
 
["OnRelease"] = function(self)
self.status = nil
self.tree = nil
self.frame:SetScript("OnUpdate", nil)
for k, v in pairs(self.localstatus) do
if k == "groups" then
for k2 in pairs(v) do
388,8 → 392,8
end
end,
 
["RefreshTree"] = function(self,scrollToSelection)
local buttons = self.buttons
["RefreshTree"] = function(self,scrollToSelection,fromOnUpdate)
local buttons = self.buttons
local lines = self.lines
 
for i, v in ipairs(buttons) do
420,6 → 424,12
local maxlines = (floor(((self.treeframe:GetHeight()or 0) - 20 ) / 18))
if maxlines <= 0 then return end
 
-- workaround for lag spikes on WoW 8.0
if WoW80 and self.frame:GetParent() == UIParent and not fromOnUpdate then
self.frame:SetScript("OnUpdate", FirstFrameUpdate)
return
end
 
local first, last
 
scrollToSelection = status.scrollToSelection
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-Button.lua
18,7 → 18,7
-------------------------------------------------------------------------------]]
local function Button_OnClick(frame, ...)
AceGUI:ClearFocus()
PlaySound(PlaySoundKitID and "igMainMenuOption" or 852) -- SOUNDKIT.IG_MAINMENU_OPTION
PlaySound(852) -- SOUNDKIT.IG_MAINMENU_OPTION
frame.obj:Fire("OnClick", ...)
end
 
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-DropDown-Items.lua
1,4 → 1,4
--[[ $Id: AceGUIWidget-DropDown-Items.lua 1161 2017-08-12 14:30:16Z funkydude $ ]]--
--[[ $Id: AceGUIWidget-DropDown-Items.lua 1167 2017-08-29 22:08:48Z funkydude $ ]]--
 
local AceGUI = LibStub("AceGUI-3.0")
 
343,9 → 343,9
if self.disabled then return end
self.value = not self.value
if self.value then
PlaySound(PlaySoundKitID and "igMainMenuOptionCheckBoxOn" or 856) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_ON
PlaySound(856) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_ON
else
PlaySound(PlaySoundKitID and "igMainMenuOptionCheckBoxOff" or 857) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_OFF
PlaySound(857) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_OFF
end
UpdateToggle(self)
self:Fire("OnValueChanged", self.value)
trunk/Libs/AceGUI-3.0/widgets/AceGUIContainer-TabGroup.lua
63,7 → 63,7
-------------------------------------------------------------------------------]]
local function Tab_OnClick(frame)
if not (frame.selected or frame.disabled) then
PlaySound(PlaySoundKitID and "igCharacterInfoTab" or 841) -- SOUNDKIT.IG_CHARACTER_INFO_TAB
PlaySound(841) -- SOUNDKIT.IG_CHARACTER_INFO_TAB
frame.obj:SelectTab(frame.value)
end
end
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-Slider.lua
108,7 → 108,7
end
 
if value then
PlaySound(PlaySoundKitID and "igMainMenuOptionCheckBoxOn" or 856) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_ON
PlaySound(856) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_ON
self.slider:SetValue(value)
self:Fire("OnMouseUp", value)
end
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-CheckBox.lua
1,7 → 1,7
--[[-----------------------------------------------------------------------------
Checkbox Widget
-------------------------------------------------------------------------------]]
local Type, Version = "CheckBox", 23
local Type, Version = "CheckBox", 24
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
26,7 → 26,7
self.text:SetPoint("LEFT", self.checkbg, "RIGHT")
self.text:SetPoint("RIGHT")
else
self.text:SetPoint("LEFT", self.image,"RIGHT", 1, 0)
self.text:SetPoint("LEFT", self.checkbg, "RIGHT", self.image:GetWidth() + 2, 0)
self.text:SetPoint("RIGHT")
end
end
60,9 → 60,9
self:ToggleChecked()
 
if self.checked then
PlaySound(PlaySoundKitID and "igMainMenuOptionCheckBoxOn" or 856) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_ON
PlaySound(856) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_ON
else -- for both nil and false (tristate)
PlaySound(PlaySoundKitID and "igMainMenuOptionCheckBoxOff" or 857) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_OFF
PlaySound(857) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_OFF
end
 
self:Fire("OnValueChanged", self.checked)
203,6 → 203,7
desc:ClearAllPoints()
desc:SetPoint("TOPLEFT", self.checkbg, "TOPRIGHT", 5, -21)
desc:SetWidth(self.frame.width - 30)
desc:SetPoint("RIGHT", self.frame, "RIGHT", -30, 0)
desc:SetJustifyH("LEFT")
desc:SetJustifyV("TOP")
self.desc = desc
trunk/Libs/AceGUI-3.0/widgets/AceGUIContainer-Frame.lua
21,7 → 21,7
Scripts
-------------------------------------------------------------------------------]]
local function Button_OnClick(frame)
PlaySound(PlaySoundKitID and "gsTitleOptionExit" or 799) -- SOUNDKIT.GS_TITLE_OPTION_EXIT
PlaySound(799) -- SOUNDKIT.GS_TITLE_OPTION_EXIT
frame.obj:Hide()
end
 
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-DropDown.lua
1,4 → 1,4
--[[ $Id: AceGUIWidget-DropDown.lua 1161 2017-08-12 14:30:16Z funkydude $ ]]--
--[[ $Id: AceGUIWidget-DropDown.lua 1167 2017-08-29 22:08:48Z funkydude $ ]]--
local AceGUI = LibStub("AceGUI-3.0")
 
-- Lua APIs
381,7 → 381,7
 
local function Dropdown_TogglePullout(this)
local self = this.obj
PlaySound(PlaySoundKitID and "igMainMenuOptionCheckBoxOn" or 856) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_ON
PlaySound(856) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_ON
if self.open then
self.open = nil
self.pullout:Close()
trunk/Libs/AceGUI-3.0/widgets/AceGUIWidget-EditBox.lua
1,7 → 1,7
--[[-----------------------------------------------------------------------------
EditBox Widget
-------------------------------------------------------------------------------]]
local Type, Version = "EditBox", 27
local Type, Version = "EditBox", 28
local AceGUI = LibStub and LibStub("AceGUI-3.0", true)
if not AceGUI or (AceGUI:GetWidgetVersion(Type) or 0) >= Version then return end
 
73,7 → 73,7
local value = frame:GetText()
local cancel = self:Fire("OnEnterPressed", value)
if not cancel then
PlaySound(PlaySoundKitID and "igMainMenuOptionCheckBoxOn" or 856) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_ON
PlaySound(856) -- SOUNDKIT.IG_MAINMENU_OPTION_CHECKBOX_ON
HideButton(self)
end
end
81,23 → 81,21
local function EditBox_OnReceiveDrag(frame)
local self = frame.obj
local type, id, info = GetCursorInfo()
local name
if type == "item" then
self:SetText(info)
self:Fire("OnEnterPressed", info)
ClearCursor()
name = info
elseif type == "spell" then
local name = GetSpellInfo(id, info)
self:SetText(name)
self:Fire("OnEnterPressed", name)
ClearCursor()
name = GetSpellInfo(id, info)
elseif type == "macro" then
local name = GetMacroInfo(id)
name = GetMacroInfo(id)
end
if name then
self:SetText(name)
self:Fire("OnEnterPressed", name)
ClearCursor()
HideButton(self)
AceGUI:ClearFocus()
end
HideButton(self)
AceGUI:ClearFocus()
end
 
local function EditBox_OnTextChanged(frame)
trunk/Libs/AceConfig-3.0/AceConfigDialog-3.0/AceConfigDialog-3.0.lua
1,13 → 1,13
--- AceConfigDialog-3.0 generates AceGUI-3.0 based windows based on option tables.
-- @class file
-- @name AceConfigDialog-3.0
-- @release $Id: AceConfigDialog-3.0.lua 1163 2017-08-14 14:04:39Z nevcairiel $
-- @release $Id: AceConfigDialog-3.0.lua 1169 2018-02-27 16:18:28Z nevcairiel $
 
local LibStub = LibStub
local gui = LibStub("AceGUI-3.0")
local reg = LibStub("AceConfigRegistry-3.0")
 
local MAJOR, MINOR = "AceConfigDialog-3.0", 64
local MAJOR, MINOR = "AceConfigDialog-3.0", 66
local AceConfigDialog, oldminor = LibStub:NewLibrary(MAJOR, MINOR)
 
if not AceConfigDialog then return end
740,7 → 740,7
else
validationErrorPopup(validated)
end
PlaySound(PlaySoundKitID and "igPlayerInviteDecline" or 882) -- SOUNDKIT.IG_PLAYER_INVITE_DECLINE || XXX _DECLINE is actually missing from the table
PlaySound(882) -- SOUNDKIT.IG_PLAYER_INVITE_DECLINE || _DECLINE is actually missing from the table
del(info)
return true
else
1034,6 → 1034,7
entry.value = k
entry.text = GetOptionsMemberValue("name", v, options, path, appName)
entry.icon = GetOptionsMemberValue("icon", v, options, path, appName)
entry.iconCoords = GetOptionsMemberValue("iconCoords", v, options, path, appName)
entry.disabled = CheckOptionDisabled(v, options, path, appName)
tinsert(tree,entry)
if recurse and (v.childGroups or "tree") == "tree" then
1226,6 → 1227,8
radio:SetWidth(width_multiplier * 2)
elseif width == "half" then
radio:SetWidth(width_multiplier / 2)
elseif (type(width) == "number") then
radio:SetWidth(width_multiplier * width)
elseif width == "full" then
radio.width = "fill"
else
1288,6 → 1291,8
control:SetWidth(width_multiplier * 2)
elseif width == "half" then
control:SetWidth(width_multiplier / 2)
elseif (type(width) == "number") then
control:SetWidth(width_multiplier * width)
elseif width == "full" then
control.width = "fill"
else
1324,6 → 1329,8
check:SetWidth(width_multiplier * 2)
elseif width == "half" then
check:SetWidth(width_multiplier / 2)
elseif (type(width) == "number") then
control:SetWidth(width_multiplier * width)
elseif width == "full" then
check.width = "fill"
else
1405,6 → 1412,8
control:SetWidth(width_multiplier * 2)
elseif width == "half" then
control:SetWidth(width_multiplier / 2)
elseif (type(width) == "number") then
control:SetWidth(width_multiplier * width)
elseif width == "full" then
control.width = "fill"
else
trunk/Libs/AceConfig-3.0/AceConfigRegistry-3.0/AceConfigRegistry-3.0.lua
8,10 → 8,10
-- :IterateOptionsTables() (and :GetOptionsTable() if only given one argument) return a function reference that the requesting config handling addon must call with valid "uiType", "uiName".
-- @class file
-- @name AceConfigRegistry-3.0
-- @release $Id: AceConfigRegistry-3.0.lua 1161 2017-08-12 14:30:16Z funkydude $
-- @release $Id: AceConfigRegistry-3.0.lua 1169 2018-02-27 16:18:28Z nevcairiel $
local CallbackHandler = LibStub("CallbackHandler-1.0")
 
local MAJOR, MINOR = "AceConfigRegistry-3.0", 17
local MAJOR, MINOR = "AceConfigRegistry-3.0", 18
local AceConfigRegistry = LibStub:NewLibrary(MAJOR, MINOR)
 
if not AceConfigRegistry then return end
67,6 → 67,7
local opttable={["nil"]=true,["table"]=true, _="table"}
local optbool={["nil"]=true,["boolean"]=true, _="boolean"}
local optboolnumber={["nil"]=true,["boolean"]=true,["number"]=true, _="boolean or number"}
local optstringnumber={["nil"]=true,["string"]=true,["number"]=true, _="string or number"}
 
local basekeys={
type=isstring,
90,7 → 91,7
set=optmethodfalse,
func=optmethodfalse,
arg={["*"]=true},
width=optstring,
width=optstringnumber,
}
 
local typedkeys={
trunk/SliceCommander.toc
1,6 → 1,6
## Interface: 70300
## Interface: 80000
## Author: Tomate
## Version: 7.21
## Version: 8.00
## Title: |cffc14f2cSlice|r|cff40a740Commander|r
## Notes: Energy bar, Combo point bar and rogue timer bar.
## SavedVariables: SC
trunk/Locale/enUS.lua
113,7 → 113,7
L["Assassination settings"] = true
L["Outlaw settings"] = true
L["Subtlety settings"] = true
L["Complementary settings"] = true
L["Old settings"] = true
L["Disable"] = true
L["All spec"] = true
L["Show %s bar CD"] = true
176,4 → 176,8
L["Warning settings"] = true
L["Enable kick warning"] = true
L["Font"] = true
L['Empowered'] = true
\ No newline at end of file +L['Empowered'] = true +L["Shortcut"] = true +L["Skills"] = true +L["Talents"] = true +L["PVP Talents"] = true \ No newline at end of file
trunk/Locale/ruRU.lua
113,7 → 113,7
L["Assassination settings"] = "Assassination settings"
L["Outlaw settings"] = "Outlaw settings"
L["Subtlety settings"] = "Subtlety settings"
L["Complementary settings"] = "Complementary settings"
L["Old settings"] = "Old settings"
L["Disable"] = "Disable"
L["All spec"] = "All spec"
L["Show %s bar CD"] = "Show %s bar CD"
176,4 → 176,8
L["Warning settings"] = "Warning settings"
L["Enable kick warning"] = "Enable kick warning"
L["Font"] = "Font"
L['Empowered'] = "Empowered"
\ No newline at end of file +L['Empowered'] = "Empowered" +L["Shortcut"] = "Shortcut" +L["Skills"] = "Skills" +L["Talents"] = "Talents" +L["PVP Talents"] = "PVP Talents" \ No newline at end of file
trunk/Locale/esES.lua
113,7 → 113,7
L["Assassination settings"] = true
L["Outlaw settings"] = true
L["Subtlety settings"] = true
L["Complementary settings"] = true
L["Old settings"] = true
L["Disable"] = true
L["All spec"] = true
L["Show %s bar CD"] = true
176,4 → 176,8
L["Warning settings"] = true
L["Enable kick warning"] = true
L["Font"] = true
L['Empowered'] = true
\ No newline at end of file +L['Empowered'] = true +L["Shortcut"] = true +L["Skills"] = true +L["Talents"] = true +L["PVP Talents"] = true \ No newline at end of file
trunk/Locale/frFR.lua
113,7 → 113,7
L["Assassination settings"] = "Options d'Assassinat"
L["Outlaw settings"] = "Options de Hors-la-loi"
L["Subtlety settings"] = "Options de Finesse"
L["Complementary settings"] = "Options Complémentaire"
L["Old settings"] = "Options Obsolètes"
L["Disable"] = "Désactivé"
L["All spec"] = "Toutes les spés"
L["Show %s bar CD"] = "Afficher la barre de CD de %s"
176,4 → 176,8
L["Warning settings"] = "Option de l'alerte"
L["Enable kick warning"] = "Activer l'alerte d'anti-cast"
L["Font"] = "Police"
L['Empowered'] = "Empowered"
\ No newline at end of file +L['Empowered'] = "Empowered" +L["Shortcut"] = "Raccourcis" +L["Skills"] = "Capacités" +L["Talents"] = "Talents" +L["PVP Talents"] = "Talents JcJ" \ No newline at end of file
trunk/Locale/spell.lua
1,110 → 1,136
local L = LibStub("AceLocale-3.0"):GetLocale("SliceCommander")
----------------------SPELLID-----------------------
 
SC_SPELL = {}
SC_SPELLID = {}
 
--GLOBAL
SC_SPELL['KS'] = GetSpellInfo(408) --Kidney Shot
SC_SPELL['KSCD'] = GetSpellInfo(408) --Kidney Shot CD
SC_SPELL['CS'] = GetSpellInfo(1833) --Cheap Shot
SC_SPELL['VAN'] = GetSpellInfo(1856) --Vanish
SC_SPELL['FE'] = GetSpellInfo(1966) --Feint
SC_SPELL['TOT'] = GetSpellInfo(57934) --Tricks of the Trade
SC_SPELL['SUB'] = GetSpellInfo(108208)--Subterfuge
SC_SPELL['SS'] = GetSpellInfo(36554) --Shadowstep
SC_SPELL['SSCD'] = GetSpellInfo(36554) --Shadowstep CD
SC_SPELL['CD'] = GetSpellInfo(45181) --Cheated Death
SC_SPELL['AC'] = GetSpellInfo(193538)--Alacrity
SC_SPELL['MD'] = GetSpellInfo(137619)--Marked for Death
SC_SPELL['DFA'] = GetSpellInfo(152150)--Death from Above
SC_SPELL['CV'] = GetSpellInfo(185311)--Crimson Vial
SC_SPELL['CVCD'] = GetSpellInfo(185311)--Crimson Vial CD
SC_SPELL['SOTD'] = GetSpellInfo(109941)--Shadow of the Destroyer
SC_SPELL['FOTD'] = GetSpellInfo(109949)--Fury of the Destroyer
SC_SPELL['MAI'] = GetSpellInfo(235027)--Master Assassin's Initiative
SC_SPELL['KI'] = GetSpellInfo(1766) --Kick
SC_SPELL['EV'] = GetSpellInfo(5277) --Evasion
SC_SPELL['EVCD'] = GetSpellInfo(5277) --Evasion CD
SC_SPELL['COS'] = GetSpellInfo(31224) --Cloak of Shadows
SC_SPELL['COSCD'] = GetSpellInfo(31224) --Cloak of Shadows CD
SC_SPELLID['KS'] = 408 --Kidney Shot
SC_SPELLID['KSCD'] = 408 --Kidney Shot CD
SC_SPELLID['CS'] = 1833 --Cheap Shot
SC_SPELLID['VAN'] = 1856 --Vanish
SC_SPELLID['FE'] = 1966 --Feint
SC_SPELLID['FECD'] = 1966 --Feint CD
SC_SPELLID['TOT'] = 57934 --Tricks of the Trade
SC_SPELLID['SUB'] = 115192 --Subterfuge
SC_SPELLID['SS'] = 36554 --Shadowstep
SC_SPELLID['SSCD'] = 36554 --Shadowstep
SC_SPELLID['CD'] = 45181 --Cheated Death
SC_SPELLID['AC'] = 193538 --Alacrity
SC_SPELLID['MD'] = 137619 --Marked for Death
SC_SPELLID['DFA'] = 152150 --Death from Above
SC_SPELLID['CV'] = 185311 --Crimson Vial
SC_SPELLID['CVCD'] = 185311 --Crimson Vial CD
SC_SPELLID['SOTD'] = 109941 --Shadow of the Destroyer
SC_SPELLID['FOTD'] = 109949 --Fury of the Destroyer
SC_SPELLID['MAI'] = 235027 --Master Assassin's Initiative
SC_SPELLID['KI'] = 1766 --Kick
SC_SPELLID['COS'] = 31224 --Cloak of Shadows
SC_SPELLID['COSCD'] = 31224 --Cloak of Shadows CD
SC_SPELLID['EVA'] = 5277 --Evasion
SC_SPELLID['EVACD'] = 5277 --Evasion CD
SC_SPELLID['SPR'] = 2983 --Sprint
SC_SPELLID['SPRCD'] = 2983 --Sprint CD
 
--OUTLAW
SC_SPELL['SND'] = GetSpellInfo(5171) --Slice and Dice
SC_SPELL['AR'] = GetSpellInfo(13750) --Adrenaline Rush
SC_SPELL['ARCD'] = GetSpellInfo(13750) --Adrenaline Rush CD
SC_SPELL['BF'] = GetSpellInfo(13877) --Blade Flurry
SC_SPELL['KSP'] = GetSpellInfo(51690) --Killing Spree
SC_SPELL['GS'] = GetSpellInfo(196937)--Ghostly Strike
SC_SPELL['GH'] = GetSpellInfo(195457)--Grappling Hook
SC_SPELL['PA'] = GetSpellInfo(199743)--Parley
SC_SPELL['CB'] = GetSpellInfo(185767)--Cannonball Barrage
SC_SPELL['BE'] = GetSpellInfo(199804)--Between the Eyes
SC_SPELL['OP'] = GetSpellInfo(195627)--Opportunity
SC_SPELL['RB'] = GetSpellInfo(193316)--Roll the Bones
SC_SPELL['JR'] = GetSpellInfo(199603)--Jolly Roger
SC_SPELL['GM'] = GetSpellInfo(193358)--Grand Melee
SC_SPELL['SIW'] = GetSpellInfo(193357)--Shark Infested Waters
SC_SPELL['TB'] = GetSpellInfo(193359)--True Bearing
SC_SPELL['BT'] = GetSpellInfo(199600)--Buried Treasure
SC_SPELL['BS'] = GetSpellInfo(193356)--Broadsides
SC_SPELL['CDB'] = GetSpellInfo(202665)--Curse of the Dreadblades
SC_SPELL['CDBCD'] = GetSpellInfo(202665)--Curse of the Dreadblades CD
SC_SPELL['GSWW'] = GetSpellInfo(209423)--Greenskin's Waterlogged Wristcuffs
SC_SPELL['PS'] = GetSpellInfo(185763)--Cannonball Barrage
SC_SPELL['BB'] = GetSpellInfo(202895)--Blunderbuss
SC_SPELL['RT'] = GetSpellInfo(208225)--Run Through
SC_SPELL['LD'] = GetSpellInfo(240837)--Loaded Dice
SC_SPELL['RI'] = GetSpellInfo(199754)--Riposte
SC_SPELL['RICD'] = GetSpellInfo(199754)--Riposte CD
SC_SPELLID['SND'] = 5171 --Slice and Dice
SC_SPELLID['AR'] = 13750 --Adrenaline Rush
SC_SPELLID['ARCD'] = 13750 --Adrenaline Rush CD
SC_SPELLID['BF'] = 13877 --Blade Flurry
SC_SPELLID['BFCD'] = 13877 --Blade Flurry CD
SC_SPELLID['KSP'] = 51690 --Killing Spree
SC_SPELLID['GS'] = 196937 --Ghostly Strike
SC_SPELLID['GSCD'] = 196937 --Ghostly Strike
SC_SPELLID['GH'] = 195457 --Grappling Hook
SC_SPELLID['BE'] = 199804 --Between the Eyes
SC_SPELLID['BECD'] = 199804 --Between the Eyes CD
SC_SPELLID['OP'] = 195627 --Opportunity
SC_SPELLID['RB'] = 193316 --Roll the Bones
SC_SPELLID['SC'] = 199603 --Roll the Bones: Skull and Crossbones
SC_SPELLID['GM'] = 193358 --Roll the Bones: Grand Melee
SC_SPELLID['RP'] = 193357 --Roll the Bones: Ruthless Precision
SC_SPELLID['TB'] = 193359 --Roll the Bones: True Bearing
SC_SPELLID['BT'] = 199600 --Roll the Bones: Buried Treasure
SC_SPELLID['BS'] = 193356 --Roll the Bones: Broadsides
SC_SPELLID['CDB'] = 202665 --Curse of the Dreadblades
SC_SPELLID['CDBCD'] = 202665 --Curse of the Dreadblades CD
SC_SPELLID['GSWW'] = 209423 --Greenskin's Waterlogged Wristcuffs
SC_SPELLID['PS'] = 185763 --Cannonball Barrage
SC_SPELLID['BB'] = 202895 --Blunderbuss
SC_SPELLID['RT'] = 208225 --Run Through
SC_SPELLID['LD'] = 256171 --Loaded Dice
SC_SPELLID['BR'] = 271896 --Blade Rush
SC_SPELLID['BRCD'] = 271877 --Blade Rush CD
SC_SPELLID['RIP'] = 199754 --Riposte
SC_SPELLID['RIPCD'] = 199754 --Riposte CD
SC_SPELLID['GG'] = 1776 --Gouge
SC_SPELLID['GGCD'] = 1776 --Gouge CD
 
--ASSASSINAT
SC_SPELL['HEM'] = GetSpellInfo(16511) --Hemorrhage
SC_SPELL['ENV'] = GetSpellInfo(32645) --Envenom
SC_SPELL['RUP'] = GetSpellInfo(1943) --Rupture
SC_SPELL['GAR'] = GetSpellInfo(703) --Garrote
SC_SPELL['GARCD'] = GetSpellInfo(703) --Garrote CD
SC_SPELL['VEN'] = GetSpellInfo(79140) --Vendetta
SC_SPELL['VENCD'] = GetSpellInfo(79140) --Vendetta CD
SC_SPELL['EP'] = GetSpellInfo(193640)--Elaborate Planning
SC_SPELL['DP'] = GetSpellInfo(2818) --Deadly Poison
SC_SPELL['CRP'] = GetSpellInfo(3408) --Crippling Poison
SC_SPELL['WP'] = GetSpellInfo(8679) --Wound Poison
SC_SPELL['LP'] = GetSpellInfo(108211)--Leeching Poison
SC_SPELL['EX'] = GetSpellInfo(200806)--Exsanguinate
SC_SPELL['KB'] = GetSpellInfo(192759)--Kingsbane
SC_SPELL['KBCD'] = GetSpellInfo(192759)--Kingsbane CD
SC_SPELL['BA'] = GetSpellInfo(192925)--Blood of the Assassinated
SC_SPELL['ST'] = GetSpellInfo(192425)--Surge of Toxins
SC_SPELL['TXB'] = GetSpellInfo(245388)--Toxic Blade
SC_SPELL['TXBCD'] = GetSpellInfo(245388)--Toxic Blade CD
SC_SPELLID['ENV'] = 32645 --Envenom
SC_SPELLID['RUP'] = 1943 --Rupture
SC_SPELLID['GAR'] = 703 --Garrote
SC_SPELLID['GARCD'] = 703 --Garrote CD
SC_SPELLID['VEN'] = 79140 --Vendetta
SC_SPELLID['VENCD'] = 79140 --Vendetta CD
SC_SPELLID['EP'] = 193641 --Elaborate Planning
SC_SPELLID['DP'] = 2823 --Deadly Poison
SC_SPELLID['CRP'] = 3408 --Crippling Poison
SC_SPELLID['WP'] = 8679 --Wound Poison
SC_SPELLID['EX'] = 200806 --Exsanguinate
SC_SPELLID['KB'] = 192759 --Kingsbane
SC_SPELLID['KBCD'] = 192759 --Kingsbane CD
SC_SPELLID['BA'] = 192925 --Blood of the Assassinated
SC_SPELLID['ST'] = 192425 --Surge of Toxins
SC_SPELLID['TXB'] = 245389 --Toxic Blade
SC_SPELLID['TXBCD'] = 245388 --Toxic Blade CD
SC_SPELLID['BLS'] = 121153 --Blindside
SC_SPELLID['MA'] = 256735 --Master Assassin
SC_SPELLID['CT'] = 121411 --Crimson Tempest
 
--SUBLETY
SC_SPELL['SD'] = GetSpellInfo(185313)--Shadow Dance
SC_SPELL['SDCD'] = GetSpellInfo(185313)--Shadow Dance CD
SC_SPELL['SB'] = GetSpellInfo(121471)--Shadow Blades
SC_SPELL['SBCD'] = GetSpellInfo(121471)--Shadow Blades CD
SC_SPELL['NB'] = GetSpellInfo(195452)--Nightblade
SC_SPELL['SOD'] = GetSpellInfo(212283)--Symbols of Death
SC_SPELL['SODCD'] = GetSpellInfo(212283)--Symbols of Death CD
SC_SPELL['GB'] = GetSpellInfo(209782)--Goremaw's Bite
SC_SPELL['GBCD'] = GetSpellInfo(209782)--Goremaw's Bite CD
SC_SPELLID['SD'] = 185422 --Shadow Dance
SC_SPELLID['SDCD'] = 185313 --Shadow Dance CD
SC_SPELLID['SB'] = 121471 --Shadow Blades
SC_SPELLID['SBCD'] = 121471 --Shadow Blades CD
SC_SPELLID['NB'] = 195452 --Nightblade
SC_SPELLID['SOD'] = 212283 --Symbols of Death
SC_SPELLID['SODCD'] = 212283 --Symbols of Death CD
SC_SPELLID['GB'] = 209782 --Goremaw's Bite
SC_SPELLID['GBCD'] = 209782 --Goremaw's Bite CD
SC_SPELLID['SHT'] = 277925 --Shuriken Tornado
SC_SPELLID['SHTCD'] = 277925 --Shuriken Tornado CD
SC_SPELLID['STH'] = 280719 --Secret Technique
SC_SPELLID['FW'] = 91021 --Find Weakness
 
--OTHER
SC_SPELL['CP'] = L["Combo Points"]
SC_SPELL['THREAT'] =L["Threat"]
SC_SPELL['HEALTH'] =L["Your health"]
SC_SPELL['THEALTH']=L["Target health"]
SC_SPELL['ANT'] = GetSpellInfo(114015)--Anticipation
SC_SPELL['DS'] = GetSpellInfo(193531)--Deeper Stratagem
SC_SPELLID['DS'] = 193531 --Deeper Stratagem
SC_SPELLID['CP'] = L["Combo Points"]
SC_SPELLID['THREAT'] = L["Threat"]
SC_SPELLID['HEALTH'] = L["Your health"]
SC_SPELLID['THEALTH']= L["Target health"]
 
 
SC_SPELL = {}
 
--GLOBAL
for k, v in pairs(SC_SPELLID) do
if tonumber(v) ~= nil then
SC_SPELL[k] = GetSpellInfo(v)
else
SC_SPELL[k] = v
end
end
 
--REMOVED SC_SPELL['ANT'] = GetSpellInfo(114015)--Anticipation
--REMOVED SC_SPELL['HEM'] = GetSpellInfo(16511) --Hemorrhage
--REMOVED SC_SPELL['PA'] = GetSpellInfo(199743)--Parley
--REMOVED SC_SPELL['CB'] = GetSpellInfo(185767)--Cannonball Barrage
--REMOVED SC_SPELL['EA'] = GetSpellInfo(113746)--Expose Armor
--REMOVED SC_SPELL['IP'] = GetSpellInfo(157607)--Instant Poison
--REMOVED SC_SPELL['FW'] = GetSpellInfo(91023) --Find Weakness
--REMOVED SC_SPELL['RS'] = GetSpellInfo(84617) --Revealing Strike
--REMOVED SC_SPELL['REC'] = GetSpellInfo(73651) --Recuperate
--REMOVED SC_SPELL['BG'] = GetSpellInfo(84654) --Bandit's Guile
--REMOVED SC_SPELL_BG1 = GetSpellInfo(84745) --Bandit's Guile
--REMOVED SC_SPELL_BG2 = GetSpellInfo(84746) --Bandit's Guile
--REMOVED SC_SPELL_BG3 = GetSpellInfo(84747) --Bandit's Guile
--REMOVED SC_SPELL['DIS'] = GetSpellInfo(111240)--Dispatch
--REMOVED SC_SPELL['BS'] = GetSpellInfo(121153)--Blindside
--REMOVED SC_SPELL['CT'] = GetSpellInfo(121411)--Crimson Tempest
\ No newline at end of file +--REMOVED SC_SPELL['DIS'] = GetSpellInfo(111240)--Dispatch \ No newline at end of file
trunk/Locale/deDE.lua
113,7 → 113,7
L["Assassination settings"] = "Assassination settings"
L["Outlaw settings"] = "Outlaw settings"
L["Subtlety settings"] = "Subtlety settings"
L["Complementary settings"] = "Complementary settings"
L["Old settings"] = "Old settings"
L["Disable"] = "Disable"
L["All spec"] = "All spec"
L["Show %s bar CD"] = "Show %s bar CD"
176,4 → 176,8
L["Warning settings"] = "Warning settings"
L["Enable kick warning"] = "Enable kick warning"
L["Font"] = "Font"
L['Empowered'] = "Empowered"
\ No newline at end of file +L['Empowered'] = "Empowered" +L["Shortcut"] = "Shortcut" +L["Skills"] = "Skills" +L["Talents"] = "Talents" +L["PVP Talents"] = "PVP Talents" \ No newline at end of file
trunk/Locale/zhCN.lua
113,7 → 113,7
L["Assassination settings"] = "Assassination settings"
L["Outlaw settings"] = "Outlaw settings"
L["Subtlety settings"] = "Subtlety settings"
L["Complementary settings"] = "Complementary settings"
L["Old settings"] = "Old settings"
L["Disable"] = "Disable"
L["All spec"] = "All spec"
L["Show %s bar CD"] = "Show %s bar CD"
176,4 → 176,8
L["Warning settings"] = "Warning settings"
L["Enable kick warning"] = "Enable kick warning"
L["Font"] = "Font"
L['Empowered'] = "Empowered"
\ No newline at end of file +L['Empowered'] = "Empowered" +L["Shortcut"] = "Shortcut" +L["Skills"] = "Skills" +L["Talents"] = "Talents" +L["PVP Talents"] = "PVP Talents" \ No newline at end of file