/// <summary>
/// Remove a Debuff from the Monster
/// </summary>
/// <returns>Whether or not the Debuff existed before removal</returns>
public bool RemoveDebuff(Debuff debuff)
{
bool retBool = Debuffs.ContainsKey(debuff);
Debuffs.Remove(debuff);
return(retBool);
}
public void ApplyAuraJson(JToken json, bool buffs)
{
if (buffs)
{
lock (Buffs)
{
Buffs.Clear();
foreach (var auraJson in json.Children())
{
var aura = new WoWAura();
aura.ApplyJson(auraJson);
Buffs.Add(aura);
}
}
}
else
{
lock (Debuffs)
{
Debuffs.Clear();
foreach (var auraJson in json.Children())
{
var aura = new WoWAura();
aura.ApplyJson(auraJson);
Debuffs.Add(aura);
}
}
}
}
public void ActivateShield(Debuffs debuff)
{
if (Random.Range(0, 1f) > shieldChance)
{
stateMachine.ChangeState(shieldState);
}
}
private void OnAbnormalityShapeChanged()
{
Buffs.RefreshTemplate(R.TemplateSelectors.PlayerAbnormalityTemplateSelector);
SpecBuffs.RefreshTemplate(R.TemplateSelectors.PlayerAbnormalityTemplateSelector);
Debuffs.RefreshTemplate(R.TemplateSelectors.PlayerAbnormalityTemplateSelector);
InfBuffs.RefreshTemplate(R.TemplateSelectors.PlayerAbnormalityTemplateSelector);
SpecInfBuffs.RefreshTemplate(R.TemplateSelectors.PlayerAbnormalityTemplateSelector);
}
/// <summary>
/// Check if a Debuff exists on the monster. Returns stack value of the debuff, 0 if not found.
/// </summary>
/// <returns>Stack value of the debuff, 0 if not found.</returns>
public int GetDebuffStacks(Debuff debuff)
{
if (Debuffs.TryGetValue(debuff, out int value))
{
return(value % 256); // Overflow
}
return(0);
}
protected virtual void Awake()
{
unitDied = new UnitDiedEvent();
dealtDamageEvent = new DealtDamageEvent();
health = GetComponent <Health>();
debuffs = GetComponent <Debuffs>();
currentSpeed = baseSpeed;
}
public bool HasDebuff(string debuff)
{
if (Debuffs == null || Debuffs.Count == 0)
{
return(false);
}
return(Debuffs.Any(i => i.Has(debuff)));
}
public bool Tick()
{
Auras = GetAuras();
if (Auras == null || Auras.Length == 0)
{
return(false);
}
if (Buffs != null)
{
if (BuffsToKeepActive?.Count > 0)
{
foreach (KeyValuePair <string, CastFunction> keyValuePair in BuffsToKeepActive)
{
if (!Buffs.Any(e => e.SpellId != 0 && e.Name.Equals(keyValuePair.Key, StringComparison.OrdinalIgnoreCase)) &&
keyValuePair.Value())
{
return(true);
}
}
}
if (Buffs.Length > 0 && DispellBuffs != null)
{
DispellBuffs();
}
}
if (Debuffs != null)
{
if (DebuffsToKeepActive?.Count > 0)
{
foreach (KeyValuePair <string, CastFunction> keyValuePair in DebuffsToKeepActive)
{
if (!Debuffs.Any(e => e.SpellId != 0 && e.Name.Equals(keyValuePair.Key, StringComparison.OrdinalIgnoreCase)) &&
keyValuePair.Value())
{
return(true);
}
}
}
if (Debuffs.Length > 0 && DispellDebuffs != null)
{
// DispellDebuffs();
}
}
return(false);
}
//Debuffs
private void CreateKnockback()
{
var debuff = new Debuff();
debuff.EffectMethod = () =>
{
_rigidBody.velocity = _rigidBody.velocity.magnitude >= 0.1f ? _rigidBody.velocity * 0.9f : Vector2.zero;
debuff.IsAffected = _rigidBody.velocity.magnitude == 0;
return(0f);
};
Debuffs.Add(DebuffType.Knockback, debuff);
}
public bool Tick(bool forceUpdate = false)
{
if (DateTime.Now - LastBuffUpdate > MinUpdateTime ||
forceUpdate)
{
Buffs = GetBuffs();
Debuffs = GetDebuffs();
LastBuffUpdate = DateTime.Now;
}
if (BuffsToKeepActive?.Count > 0 && Buffs != null)
{
foreach (KeyValuePair <string, CastFunction> keyValuePair in BuffsToKeepActive)
{
if (!Buffs.Any(e => e.Equals(keyValuePair.Key, StringComparison.OrdinalIgnoreCase)))
{
if (keyValuePair.Value.Invoke())
{
return(true);
}
}
}
}
if (Buffs?.Count > 0 && DispellBuffs != null)
{
DispellBuffs.Invoke();
}
if (DebuffsToKeepActive?.Count > 0 && Debuffs != null)
{
foreach (KeyValuePair <string, CastFunction> keyValuePair in DebuffsToKeepActive)
{
if (!Debuffs.Any(e => e.Equals(keyValuePair.Key, StringComparison.OrdinalIgnoreCase)))
{
if (keyValuePair.Value.Invoke())
{
return(true);
}
}
}
}
if (Debuffs?.Count > 0 && DispellDebuffs != null)
{
DispellDebuffs.Invoke();
}
return(false);
}
public bool RemoveDebuff(string debuff)
{
if (HasDebuff(debuff))
{
var idx = Debuffs.FindIndex(i => i.Has(debuff));
var buffobj = Debuffs[idx];
lock (Debuffs)
buffobj.OnEnded(this, buffobj);
return(true);
}
return(false);
}
public async Task GetDebuff([Remainder] string name)
{
Debuff find = Debuffs.GetSpecificDebuff(name);
if (find == null)
{
await Context.Channel.SendMessageAsync($"`No Debuff Found`");
return;
}
string text = "";
text += $"Name : {find.Name}\nCountdown : {find.Countdown}\nDescription : {find.Tech}";
await Context.Channel.SendMessageAsync($"`{text}`");
}
public async Task AddingDebuffs(string name, int value, int countdown, [Remainder] string desc)
{
if (!IsHavingThisRole((SocketGuildUser)Context.User, "Developer") &&
!IsHavingThisRole((SocketGuildUser)Context.User, "Quiz Manager"))
{
return;
}
Debuff debuff = Debuffs.CreatingDebuff(name, desc, value, countdown);
if (debuff == null)
{
await Context.Channel.SendMessageAsync("FAILED TO MAKE DEBUFF");
return;
}
await Context.Channel.SendMessageAsync("DEBUFF HAS BEEN MADE");
}
/// <summary>
/// Gera strings dos botões
/// </summary>
/// <param name="buff">buff que ocorre quando o botão é pressionado</param>
/// <param name="debuff">debuff que ocorre quando o botão é pressionado</param>
/// <returns></returns>
public String GenerateButtonText(Buffs buff, Debuffs debuff)
{
string buffStr, debuffStr;
switch (buff)
{
case Buffs.moreLife:
buffStr = "starting with one more life";
break;
case Buffs.moreSpeed:
buffStr = "faster movement speed";
break;
case Buffs.dealMoreDamage:
buffStr = "higher damage";
break;
default:
Debug.LogError("Buff inválido");
buffStr = "";
break;
}
switch (debuff)
{
case Debuffs.lessLife:
debuffStr = "Start with one less life";
break;
case Debuffs.lessSpeed:
debuffStr = "Sacrifice movement speed";
break;
case Debuffs.lessFireRate:
debuffStr = "Sacrifice fire rate";
break;
default:
Debug.LogError("Debuff inválido");
debuffStr = "";
break;
}
return(debuffStr + " for the blessing of " + buffStr);
}
/////////////
// Debuffs //
/////////////
/// <summary>
/// Attempt to add a Debuff to the Monster
/// </summary>
/// <param name="debuff">The Debuff to add</param>
/// <param name="stacks">How many times to add the Debuff (1 to 16)</param>
/// <returns>Whether or not the debuff was successfully added</returns>
public bool AddDebuff(Debuff debuff, int stacks)
{
if (stacks < 1 || stacks > 16)
{
throw new ArgumentOutOfRangeException("Stacks must be within range 1 - 16. Found: " + stacks);
}
// Slow doesn't stack
if (debuff == Debuff.Slow)
{
// The highest stacked slow takes over
if (Debuffs.TryGetValue(debuff, out int value))
{
if (value < stacks)
{
Debuffs[debuff] = stacks;
}
}
else
{
Debuffs.Add(debuff, stacks);
}
// Slow clears the Haste buff
RemoveBuff(Buff.Haste);
// TODO: Determine what bool to return is stacks is lower than current value
return(true);
}
// Fear stacks
if (debuff == Debuff.Fear)
{
if (Debuffs.TryGetValue(debuff, out int value))
{
Debuffs[debuff] += stacks;
}
else
{
Debuffs[debuff] = stacks;
}
return(true);
}
throw new ArgumentException("Invalid debuff supplied: " + debuff);
}
private void OnValidate()
{
//Validate Debuffs
for (int i = 0; i < BattleStats.Immunities.Stats.Length; i++)
{
if (BattleStats.Immunities.Stats[i] != Stat.None && !Debuffs.Contains(BattleStats.Immunities.Stats[i]))
{
List <Stat> temp = BattleStats.Immunities.Stats.ToList();
temp.RemoveAt(i);
i--;
BattleStats.Immunities.Stats = temp.ToArray();
}
}
//Serialize Stat Pools
BattleStats.Immunities.BuffPool = Debuffs.Where(x => !BattleStats.Immunities.Stats.Contains(x)).ToArray();
BattleStats.AppliedEffects.BuffPool = All.Where(x => !BattleStats.AppliedEffects.Stats.Contains(x)).ToArray();
}
public void ApplyDebuff(Debuffs debuff, float modifier, float duration)
{
PlayerMovement control = GetComponent<PlayerMovement>();
m_DebuffTimers[debuff] = duration;
switch (debuff)
{
case Debuffs.Stun:
control.enabled = false;
GetComponent<Rigidbody2D>().velocity = Vector2.zero;
m_DebuffGracePeriodTime = m_DebuffGracePeriod + duration;
break;
case Debuffs.Slow:
control._fMoveSpeed = Mathf.Min(m_MovementSpeed * modifier, control._fMoveSpeed);
break;
default:
break;
}
}
private void CreateStun()
{
var debuff = new Debuff();
debuff.EffectMethod = () =>
{
debuff.IsAffected = debuff.Duration >= Time.time;
if (debuff.IsAffected)
{
return(1f);
}
else
{
return(0f);
}
};
Debuffs.Add(DebuffType.Stun, debuff);
}
/// <summary>
/// Gera todos os efeitos dos botões
/// </summary>
public void GenerateChoices()
{
//define buffs e debuffs
for (int i = 0; i < this.choiceButtons.Count; i++)
{
Button btn = this.choiceButtons[i];
//regera buffs e debuffs até que eles não sejam incompatíveis
while (true)
{
Buffs buff = RandomizeBuff();
Debuffs debuff = RandomizeDebuff();
bool isRepeated = false;
for (int j = 0; j < i; j++)
{
if (this.choiceBuffs[this.choiceButtons[j]] == buff && this.choiceDebuffs[this.choiceButtons[j]] == debuff)
{
isRepeated = true;
break;
}
}
if (isRepeated)
{
continue;
}
//checa se buff e debuff são incompatíveis
if (!(
(buff == Buffs.moreLife && debuff == Debuffs.lessLife) ||
(buff == Buffs.moreSpeed && debuff == Debuffs.lessSpeed)
))
{
//atualiza dicionários de efeitos
choiceBuffs.Add(btn, buff);
choiceDebuffs.Add(btn, debuff);
btn.transform.GetComponentInChildren <Text>().text = GenerateButtonText(buff, debuff); //gera texto do botão
break; //sai do while
}
}
}
}
/// <summary>
/// 回合结束
/// </summary>
public void TurnEnd()
{
TurnEndEvent?.Invoke();
List <string> temp = new List <string>();
foreach (var item in Debuffs)
{
item.Value.BuffDecrease(1);
if (item.Value.BuffLastTurn == 0)
{
item.Value.BuffEnd(this);
temp.Add(item.Key);
}
}
foreach (var item in temp)
{
Debuffs.Remove(item);
}
}
public void Damage(float damageVal, Debuffs debuff = Debuffs.none)
{
if (!invulnerable)
{
TookDamage?.Invoke(debuff);
Instantiate(hurtParticle, transform.position, transform.rotation);
currentHealth -= damageVal;
if (healthbar != null)
{
healthbar.value = currentHealth;
}
if (currentHealth <= 0)
{
Die();
}
}
}
/// <summary>
/// 获得Debuff
/// </summary>
/// <param name="buff">debuff种类</param>
/// <param name="lastTurn">debuff持续时间</param>
public void GainBuff(Buff buff, int lastTurn)
{
if (buff.IsPower)
{
if (!Powers.ContainsKey(buff.BuffName))
{
Powers.Add(buff.BuffName, buff);
Powers[buff.BuffName].BuffIncrease(lastTurn);
buff.BuffStart(this);
}
else
{
Powers[buff.BuffName].BuffIncrease(lastTurn);
if (Powers[buff.BuffName].BuffLastTurn == 0)
{
Powers[buff.BuffName].BuffEnd(this);
Powers.Remove(buff.BuffName);
}
}
}
else
{
if (buff.IsDebuff)
{
PreGainDebuffEvent?.Invoke();
if (!Debuffs.ContainsKey(buff.BuffName))
{
PreGainNewDebuffEvent?.Invoke();
Debuffs.Add(buff.BuffName, buff);
Debuffs[buff.BuffName].BuffIncrease(lastTurn);
buff.BuffStart(this);
}
else
{
Debuffs[buff.BuffName].BuffIncrease(lastTurn);
}
}
}
}
public virtual void Update()
{
ChangeEnergy((ShipStats.EnergyRegenRate * StatBonuses[StatBonusTypes.EnergyRegen] / (1 + Debuffs[DebuffTypes.EnergyRegen] * DebuffHandlerModel.EffectValues[DebuffTypes.EnergyRegen])) * (TimeKeeper.MsSinceInitialization - lastTimeStamp));
//Energy rate given in energy/millisecond
foreach (var w in _weapons)
{
w.Update();
}
if (DoCombatUpdates)
{
Debuffs.Update(TimeKeeper.MsSinceInitialization);
Shields.Update(TimeKeeper.MsSinceInitialization);
if (combatUpdateTimeout + TimeOfLastCollision < TimeKeeper.MsSinceInitialization)
{
DoCombatUpdates = false;
}
}
lastTimeStamp = TimeKeeper.MsSinceInitialization;
}
public async Task AddingDebuffToItem(ulong id, string debuffname)
{
if (!IsHavingThisRole((SocketGuildUser)Context.User, "Developer") &&
!IsHavingThisRole((SocketGuildUser)Context.User, "Quiz Manager"))
{
return;
}
Item select = Drops.GetSpecificItem(id);
if (select == null)
{
return;
}
Debuff debuff = Debuffs.GetSpecificDebuff(debuffname);
if (debuff == null)
{
return;
}
select.Debuffs.Add(debuff);
await Context.Channel.SendMessageAsync("ADDING BUFF SUCCESS");
}
/// <summary>
/// 获得Debuff
/// </summary>
/// <param name="buff">debuff种类</param>
/// <param name="lastTurn">debuff持续时间</param>
public void GainBuff(Buff buff, int lastTurn)
{
if (PreGainDebuffEvent != null)
{
PreGainDebuffEvent();
}
if (Debuffs.ContainsKey(buff.BuffName))
{
Debuffs[buff.BuffName].BuffLastTurn += lastTurn;
}
else
{
if (PreGainNewDebuffEvent != null)
{
PreGainNewDebuffEvent();
}
Debuffs.Add(buff.BuffName, buff);
buff.BuffStart(this);
}
}
/// <summary>
/// Aplica o efeito do debuff
/// </summary>
/// <param name="effect">debuff</param>
public void ApplyDebuff(Debuffs effect)
{
switch (effect)
{
case Debuffs.lessLife:
PlayerHealth.maxHp--;
PlayerHealth.RegenerateHp(PlayerHealth.maxHp);
break;
case Debuffs.lessSpeed:
PlayerMovement.DecreaseSpeed();
break;
case Debuffs.lessFireRate:
PlayerShooting.fireRate += 0.1f;
break;
default:
Debug.LogError("Debuff inválido");
break;
}
}
/// <summary>
/// 回合结束
/// </summary>
public void TurnEnd()
{
if (TurnEndEvent != null)
{
TurnEndEvent();
}
List <string> temp = new List <string>();
foreach (var item in Debuffs)
{
item.Value.BuffLastTurn--;
if (item.Value.BuffLastTurn == 0)
{
item.Value.BuffEnd(this);
temp.Add(item.Key);
}
}
foreach (var item in temp)
{
Debuffs.Remove(item);
}
}
public static void HandleMessagesTick()
{
if (IPC.Active)
{
try
{
switch ((State)IPC.State)
{
case State.Idle:
return;
case State.GetMaterials:
IPC.SetObjectBuf(Materials.Get());
break;
case State.GetWeaponsRanged:
IPC.SetObjectBuf(WeaponsRanged.Get());
break;
case State.GetWeaponsMelee:
IPC.SetObjectBuf(WeaponsMelee.Get());
break;
case State.GetApparels:
IPC.SetObjectBuf(Apparels.Get());
break;
case State.GetBuildingsFromMaterials:
IPC.SetObjectBuf(BuildingsFromMaterials.Get());
break;
case State.GetAnimals:
IPC.SetObjectBuf(Animals.Get());
break;
case State.GetDebuffs:
IPC.SetObjectBuf(Debuffs.Get());
break;
case State.GetDrugs:
IPC.SetObjectBuf(Drugs.Get());
break;
case State.GetFoods:
IPC.SetObjectBuf(Foods.Get());
break;
case State.GetActiveIncidents:
IPC.StringBuf = ActiveIncidents.Get();
break;
case State.GetPawnsHeddifs:
IPC.StringBuf = PawnsHeddifs.Get();
break;
case State.GetBodyParts:
IPC.SetObjectBuf(BodyParts.Get());
break;
case State.GetFacilities:
IPC.SetObjectBuf(Facilities.Get());
break;
case State.GetPlants:
IPC.SetObjectBuf(Plants.Get());
break;
case State.GetBackstorys:
IPC.SetObjectBuf(Backstorys.Get());
break;
case State.GetTraits:
IPC.SetObjectBuf(Traits.Get());
break;
case State.GetCEAmmos:
IPC.SetObjectBuf(CEAmmos.Get());
break;
case State.GetTools:
IPC.SetObjectBuf(Tools.Get());
break;
case State.BuildingStuffDump:
new BuildingStuffDump();
break;
case State.WeaponApparelDump:
IPC.StringBuf = WeaponApparelDump.Get();
break;
case State.InjectDll:
IPC.StringBuf = InjectDll.GetResult(IPC.GetObjectBuf <InjectParameters>());
break;
case State.GcCollect:
GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced);
GC.WaitForPendingFinalizers();
Log.Warning($"[RimHelperProxy] GC.Collect() called!");
break;
default:
throw new Exception($"UnknownState: {IPC.State}");
}
}
catch (Exception e)
{
Log.Error($"[HandleMessagesTick] Exception: {e.Message}");
Log.Error($"[HandleMessagesTick] StackTrace: {e.StackTrace}");
}
finally
{
IPC.State = (int)State.Idle;
}
}
}
public override void Initialize()
{
Aimsharp.DebugMode();
Aimsharp.PrintMessage("Ice Series: Assassination Rogue - v 1.0", Color.Blue);
Aimsharp.PrintMessage("These macros can be used for manual control:", Color.Blue);
Aimsharp.PrintMessage("/xxxxx Potions", Color.Blue);
Aimsharp.PrintMessage("--Toggles using buff potions on/off.", Color.Blue);
Aimsharp.PrintMessage(" ");
Aimsharp.PrintMessage("/xxxxx SaveCooldowns", Color.Blue);
Aimsharp.PrintMessage("--Toggles the use of big cooldowns on/off.", Color.Blue);
Aimsharp.PrintMessage(" ");
Aimsharp.PrintMessage("/xxxxx AOE", Color.Blue);
Aimsharp.PrintMessage("--Toggles AOE mode on/off.", Color.Blue);
//Aimsharp.PrintMessage(" ");
// Aimsharp.PrintMessage("/xxxxx Prepull 10", Color.Blue);
// Aimsharp.PrintMessage("--Starts the prepull actions.", Color.Blue);
// Aimsharp.PrintMessage(" ");
Aimsharp.PrintMessage("--Replace xxxxx with first 5 letters of your addon, lowercase.", Color.Blue);
Aimsharp.Latency = 50;
Aimsharp.QuickDelay = 125;
Aimsharp.SlowDelay = 250;
MajorPower = GetDropDown("Major Power");
TopTrinket = GetDropDown("Top Trinket");
BotTrinket = GetDropDown("Bot Trinket");
RacialPower = GetDropDown("Racial Power");
Spellbook.Add(MajorPower);
if (RacialPower == "Orc")
{
Spellbook.Add("Blood Fury");
}
if (RacialPower == "Troll")
{
Spellbook.Add("Berserking");
}
if (RacialPower == "Dark Iron Dwarf")
{
Spellbook.Add("Fireblood");
}
if (RacialPower == "Mag'har Orc")
{
Spellbook.Add("Ancestral Call");
}
if (RacialPower == "Lightforged Draenei")
{
Spellbook.Add("Light's Judgment");
}
if (RacialPower == "Bloodelf")
{
Spellbook.Add("Arcane Torrent");
}
Spellbook.Add("Stealth");
Spellbook.Add("Garrote");
Spellbook.Add("Rupture");
Spellbook.Add("Exsanguinate");
Spellbook.Add("Toxic Blade");
Spellbook.Add("Vendetta");
Spellbook.Add("Marked for Death");
Spellbook.Add("Vanish");
Spellbook.Add("Crimson Tempest");
Spellbook.Add("Envenom");
Spellbook.Add("Fan of Knives");
Spellbook.Add("Blindside");
Spellbook.Add("Mutilate");
Buffs.Add("Bloodlust");
Buffs.Add("Heroism");
Buffs.Add("Time Warp");
Buffs.Add("Ancient Hysteria");
Buffs.Add("Netherwinds");
Buffs.Add("Drums of Rage");
Buffs.Add("Lifeblood");
Buffs.Add("Memory of Lucid Dreams");
Buffs.Add("Reckless Force");
Buffs.Add("Guardian of Azeroth");
Buffs.Add("Stealth");
Buffs.Add("Subterfuge");
Buffs.Add("Vanish");
Buffs.Add("Master Assassin");
Buffs.Add("Blindside");
Debuffs.Add("Razor Coral");
Debuffs.Add("Conductive Ink");
Debuffs.Add("Shiver Venom");
Debuffs.Add("Rupture");
Debuffs.Add("Garrote");
Debuffs.Add("Deadly Poison");
Debuffs.Add("Crippling Poison");
Debuffs.Add("Wound Poison");
Debuffs.Add("Vendetta");
Debuffs.Add("Toxic Blade");
Items.Add(TopTrinket);
Items.Add(BotTrinket);
Items.Add(GetDropDown("Potion Type"));
Macros.Add("TopTrink", "/use 13");
Macros.Add("BotTrink", "/use 14");
Macros.Add("potion", "/use " + GetDropDown("Potion Type"));
CustomCommands.Add("Potions");
CustomCommands.Add("SaveCooldowns");
CustomCommands.Add("AOE");
// CustomCommands.Add("Prepull");
}
public override void Initialize()
{
Aimsharp.PrintMessage("Vid Frost Deathknight 1.00", Color.Yellow);
Aimsharp.PrintMessage("These macros can be used for manual control:", Color.Yellow);
Aimsharp.PrintMessage("/xxxxx Potions --Toggles using buff potions on/off.", Color.Blue);
Aimsharp.PrintMessage("/xxxxx SaveCooldowns --Toggles the use of big cooldowns on/off.", Color.Blue);
Aimsharp.PrintMessage("/xxxxx noaoe --Toggles to turn off PVE AOE on/off.", Color.Orange);
Aimsharp.PrintMessage("/xxxxx savepp -- Toggles the use of prepull", Color.Orange);
Aimsharp.PrintMessage("/xxxxx StormBolt --Queues Storm Bolt up to be used on the next GCD.", Color.Red);
Aimsharp.PrintMessage("/xxxxx RallyingCry --Queues Rallying Cry up to be used on the next GCD.", Color.Red);
Aimsharp.PrintMessage("/xxxxx IntimidatingShout --Queues Intimidating SHout up to be used on the next GCD.", Color.Red);
Aimsharp.PrintMessage("/xxxxx Bladestorm --Queues Bladestorm up to be used on the next GCD.", Color.Red);
Aimsharp.PrintMessage("/xxxxx pvp --Toggles PVP Mode.", Color.Red);
Aimsharp.PrintMessage("/xxxxx Burst --Toggles Burst for pvp on.", Color.Red);
Aimsharp.Latency = 100;
Aimsharp.QuickDelay = 125;
MajorPower = GetDropDown("Major Power");
RacialPower = GetDropDown("Racial Power");
FiveLetters = GetString("First 5 Letters of the Addon:");
#region Spells
if (RacialPower == "Orc")
{
Spellbook.Add("Blood Fury");
}
if (RacialPower == "Troll")
{
Spellbook.Add("Berserking");
}
if (RacialPower == "Dark Iron Dwarf")
{
Spellbook.Add("Fireblood");
}
if (RacialPower == "Mag'har Orc")
{
Spellbook.Add("Ancestral Call");
}
if (RacialPower == "Lightforged Draenei")
{
Spellbook.Add("Light's Judgment");
}
Spellbook.Add("Howling BLast");
Spellbook.Add("Obliterate");
Spellbook.Add("Frost Strike");
Spellbook.Add("Remorseless Winter");
Spellbook.Add("Anti-Magic Shell");
Spellbook.Add("Breath of Sindragosa");
Spellbook.Add("Glacial Advance");
#endregion
#region Buffs/Procs
Buffs.Add("Icy Talons");
Buffs.Add("Pillar of Frost");
Buffs.Add("Breath of Sindragosa");
Buffs.Add("Empowered Rune Weapon");
Buffs.Add("Cold Heart");
Buffs.Add("Unholy Strength");
Buffs.Add("Reckless Force");
Buffs.Add("Seething Rage");
#endregion
#region Debuffs
Debuffs.Add("Frost Fever");
Debuffs.Add("Razor Ice");
#endregion
}
public bool HasDebuff(Debuff debuff)
{
return(Debuffs.ContainsKey(debuff));
}