WoWInterface SVN SliceCommander

Compare Revisions

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

Rev 228 → Rev 229

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"))
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
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,
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}))