Example #1
0
        /// <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);
        }
Example #2
0
 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);
     }
 }
Example #4
0
 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);
 }
Example #5
0
 /// <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);
 }
Example #6
0
    protected virtual void Awake()
    {
        unitDied         = new UnitDiedEvent();
        dealtDamageEvent = new DealtDamageEvent();
        health           = GetComponent <Health>();
        debuffs          = GetComponent <Debuffs>();

        currentSpeed = baseSpeed;
    }
Example #7
0
        public bool HasDebuff(string debuff)
        {
            if (Debuffs == null || Debuffs.Count == 0)
            {
                return(false);
            }

            return(Debuffs.Any(i => i.Has(debuff)));
        }
Example #8
0
        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);
        }
Example #9
0
        //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);
        }
Example #10
0
        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);
        }
Example #11
0
        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);
        }
Example #12
0
        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}`");
        }
Example #13
0
        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");
        }
Example #14
0
    /// <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);
    }
Example #15
0
        /////////////
        // 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);
        }
Example #16
0
    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();
    }
Example #17
0
	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;
		}
	}
Example #18
0
        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);
        }
Example #19
0
    /// <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
                }
            }
        }
    }
Example #20
0
        /// <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);
            }
        }
Example #21
0
    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();
            }
        }
    }
Example #22
0
        /// <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);
                    }
                }
            }
        }
Example #23
0
        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;
        }
Example #24
0
        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);
        }
    }
Example #26
0
    /// <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);
        }
    }
Example #28
0
        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;
                }
            }
        }
Example #29
0
        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");
        }
Example #30
0
        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
        }
Example #31
0
 public bool HasDebuff(Debuff debuff)
 {
     return(Debuffs.ContainsKey(debuff));
 }