public void DrawIconSkill(float x, float y, float width, float height, IPlayerSkill skill, int index = 1)
        {
            Hud.Texture.GetTexture(skill.SnoPower.NormalIconTextureId).Draw(x, y, width, height, Opacity);
            if (skill.Buff != null)             // 465839
            {
                Hud.Texture.BuffFrameTexture.Draw(x, y, width, height, Opacity);

                double remaining = 0d;          double elapsed = 0d;
                if (skill.CooldownFinishTick > Hud.Game.CurrentGameTick)
                {
                    remaining = (skill.CooldownFinishTick - Hud.Game.CurrentGameTick) / 60.0d;
                    elapsed   = (Hud.Game.CurrentGameTick - skill.CooldownStartTick) / 60.0d;
                    DrawTimeLeftClock(new RectangleF(x, y, width, height), elapsed, remaining);
                    layout = FontWhite.GetTextLayout(remaining.ToString((remaining < 1)? "F1":"F0"));
                }
                else
                {
                    layout = FontWhite.GetTextLayout(" 🞴 ");
                }
                FontWhite.DrawText(layout, x + ((width - (float)Math.Ceiling(layout.Metrics.Width)) / 1.40f), y + ((height - (float)Math.Ceiling(layout.Metrics.Height)) / 1.1f));

                double timeleft = skill.Buff.TimeLeftSeconds[index];
                if (timeleft > 0)
                {
                    layout = FontTimeLeft.GetTextLayout(timeleft.ToString((timeleft < 1)? "F1" : "F0"));
                    FontTimeLeft.DrawText(layout, x + ((width - (float)Math.Ceiling(layout.Metrics.Width)) / 6.0f), y + ((height - (float)Math.Ceiling(layout.Metrics.Height)) / 14.0f));
                }
            }
            else
            {
                Hud.Texture.DebuffFrameTexture.Draw(x, y, width, height, Opacity);
            }
        }
Example #2
0
        public void OnCooldown(IPlayerSkill playerSkill, bool expired)
        {
            if (!expired)
            {
                return;
            }
            if (playerSkill.Player != Hud.Game.Me)
            {
                return;
            }
            if (EnableOnlyWhenIngameSoundIsEnabled && !Hud.Sound.IsIngameSoundEnabled)
            {
                return;
            }

            if (!CoolDownRules.TryGetValue(playerSkill.CurrentSnoPower, out var rule))
            {
                return;
            }
            if (rule == null)
            {
                return;
            }

            ThreadPool.QueueUserWorkItem(state =>
            {
                try
                {
                    rule.SoundPlayer.PlaySync();
                }
                catch (Exception)
                {
                }
            });
        }
Example #3
0
 public void AddNewSkill(IPlayerSkill playerSkill)
 {
     if (!FindSkill(playerSkill))
     {
         _playerSkills.Add(playerSkill);
     }
 }
Example #4
0
        public void OnCooldown(IPlayerSkill snoPower, bool expired)
        {
            if (!expired)
            {
                return;
            }
            if (Hud.Game.IsInTown && !InTown)
            {
                return;
            }
            if (!snoPower.Player.IsMe)
            {
                return;
            }

            if (PowerSnos.Contains(snoPower.SnoPower.Sno))
            {
                var text = PowerCustomNames.ContainsKey(snoPower.SnoPower.Sno)
                    ? PowerCustomNames[snoPower.SnoPower.Sno]
                    : TextFunc(snoPower);

                Hud.Speak(text);
            }

            //Says.Debug(snoPower.SnoPower.Sno, snoPower.SnoPower.NameLocalized, expired);
        }
Example #5
0
 public void DeleteExistSkill(IPlayerSkill playerSkill)
 {
     if (_playerSkills.Count > 1)
     {
         _playerSkills.Remove(playerSkill);
     }
 }
Example #6
0
 public PlayerStats(PlayerStatsData data)
 {
     Speed        = data.Speed;
     PlayerSkill  = SkillGenerator.GeneratePlayerSkill(data.movementSkill);
     AngularForce = data.AngularForce;
     JumpVector   = data.JumpVector;
 }
Example #7
0
        protected override bool Applicable(IController hud, IPlayerSkill skill)
        {
            var resourceAmount = UsePercentage
                ? UseSecondaryResource ? hud.Game.Me.Stats.ResourcePctSec : hud.Game.Me.Stats.ResourcePctPri
                : UseSecondaryResource ? hud.Game.Me.Stats.ResourceCurSec : hud.Game.Me.Stats.ResourceCurPri;

            return(resourceAmount >= MinimumAmount);
        }
Example #8
0
 public PlayerSkillsHolder(IPlayerSkill playerSkill, List <IPlayerSkill> playerSkills = null)
 {
     _playerSkills.Add(playerSkill);
     if (playerSkills != null)
     {
         _playerSkills.AddRange(playerSkills);
     }
 }
Example #9
0
        public void Paint(IPlayerSkill skill, RectangleF rect)
        {
            if (skill == null)
            {
                return;
            }

            var texture = Hud.Texture.GetTexture(skill.SnoPower.NormalIconTextureId);

            if (texture != null)
            {
                texture.Draw(rect.X, rect.Y, rect.Width, rect.Height);
            }

            if (skill.BuffIsActive)
            {
                var ActiveTime = 0.0d;
                for (var i = 2; i >= 0; i--)
                {
                    ActiveTime = skill.Buff.TimeLeftSeconds[i];
                    if (ActiveTime > 0)
                    {
                        break;
                    }
                }

                if (ActiveTime > 0)
                {
                    var bufftext       = ActiveTime.ToString(ActiveTime > 3.0f ? "F0" : "F1", CultureInfo.InvariantCulture);
                    var bufftextLayout = BuffFont.GetTextLayout(bufftext);
                    BuffFont.DrawText(bufftextLayout, rect.X, rect.Y);
                }
            }

            var remainingSeconds = (skill.CooldownFinishTick - Hud.Game.CurrentGameTick) / 60.0d;

            if (skill != null && skill.SnoPower.Sno == Hud.Sno.SnoPowers.Wizard_Archon.Sno && skill.BuffIsActive)
            {
                var ActiveTime = skill.Buff.TimeLeftSeconds[2];

                if (ActiveTime > 0)
                {
                    remainingSeconds = skill.CalculateCooldown(skill.Rune == 3.0? 100 : 120) - 20 + ActiveTime;
                }
            }

            if (remainingSeconds <= 0)
            {
                return;
            }

            var text       = remainingSeconds.ToString(remainingSeconds > 3.0f ? "F0" : "F1", CultureInfo.InvariantCulture);
            var textLayout = CDFont.GetTextLayout(text);
            var x          = rect.X + rect.Width - (float)Math.Ceiling(textLayout.Metrics.Width);
            var y          = rect.Y + rect.Height - textLayout.Metrics.Height;

            CDFont.DrawText(textLayout, x, y);
        }
Example #10
0
        public IPlayerSkill SwapCurrentSkill(IPlayerSkill swapThis, IPlayerSkill toThis)
        {
            var skillIndex = FindSkillIndex(swapThis);
            var skill      = _playerSkills[skillIndex];

            _playerSkills[skillIndex] = toThis;
            CurrentSkill = toThis;
            return(skill);
        }
        protected override bool Applicable(IController hud, IPlayerSkill skill)
        {
            var resourceType    = skill.SnoPower.ResourceCostTypeByRune[skill.Rune == 255 ? 0 : skill.Rune];
            var resourcePercent = resourceType == PowerResourceCostType.primary
                ? hud.Game.Me.Stats.ResourcePctPri
                : hud.Game.Me.Stats.ResourcePctSec;

            return(resourcePercent >= minimumResourcePercent);
        }
Example #12
0
        public IPlayerSkill SwitchSkill(IPlayerSkill switchThis)
        {
            var skillIndex = FindSkillIndex(switchThis);

            skillIndex++;
            skillIndex   = skillIndex < _playerSkills.Count ? skillIndex : 0;
            CurrentSkill = _playerSkills[skillIndex];
            return(_playerSkills[skillIndex]);
        }
Example #13
0
        protected override bool Applicable(IController hud, IPlayerSkill skill)
        {
            if (watch.ElapsedMilliseconds <= IntervalInMs)
            {
                return(false);
            }

            watch.Restart();
            return(true);
        }
Example #14
0
        public void PaintWorld(WorldLayer layer)
        {
            if (!Hud.Game.IsInTown)
            {
                return;
            }
            if (Hud.Render.UiHidden)
            {
                return;
            }
            if ((Hud.Game.MapMode == MapMode.WaypointMap) || (Hud.Game.MapMode == MapMode.ActMap) || (Hud.Game.MapMode == MapMode.Map))
            {
                return;
            }

            IPlayerSkill hoveredSkill = null;

            foreach (var skill in Hud.Game.Me.Powers.CurrentSkills)
            {
                var ui = Hud.Render.GetPlayerSkillUiElement(skill.Key);
                if (Hud.Window.CursorInsideRect(ui.Rectangle.X, ui.Rectangle.Y, ui.Rectangle.Width, ui.Rectangle.Height))
                {
                    hoveredSkill = skill;
                    break;
                }
            }

            if (hoveredSkill == null)
            {
                return;
            }

            var range = Hud.Game.Me.GetPowerTagValue(hoveredSkill.CurrentSnoPower, 329808);

            if (range <= 0)
            {
                return;
            }

            var elementalType = hoveredSkill.ElementalType;

            if (elementalType < 0)
            {
                return;
            }

            var currentDecorator = DecoratorsByElementalType[elementalType];

            foreach (var subDecorator in currentDecorator.GetDecorators <GroundCircleDecorator>())
            {
                subDecorator.Radius = range;
            }

            currentDecorator.Paint(layer, null, Hud.Game.Me.FloorCoordinate, null);
        }
Example #15
0
        protected override bool Applicable(IController hud, IPlayerSkill skill)
        {
            var selectedMonster = hud.Game.SelectedMonster2 ?? hud.Game.SelectedMonster1;

            if (selectedMonster is null)
            {
                return(false);
            }

            var eliteTargeted = selectedMonster.Rarity == ActorRarity.Champion || selectedMonster.Rarity == ActorRarity.Rare ||
                                selectedMonster.Rarity == ActorRarity.Unique || selectedMonster.Rarity == ActorRarity.Boss;

            return(eliteTargeted || (IncludeShocktower && hud.Game.AliveMonsters.Any(monster => monster.SnoActor.Sno == ActorSnoEnum._x1_pand_ext_ordnance_tower_shock_a)));
        }
Example #16
0
        protected override bool Applicable(IController hud, IPlayerSkill skill)
        {
            var correctRune              = skill.RuneNameEnglish.Equals(Rune);
            var mateWithNameInGame       = hud.Game.Players.Any(p => p.HeroName.Equals(MateWithName));
            var bossIsSpawnedCorrect     = hud.Game.Monsters.Any(monster => monster.Rarity == ActorRarity.Boss) == BossIsSpawned;
            var numberOfDhsInGameCorrect = hud.Game.Players
                                           .Where(player => !player.IsMe)
                                           .Count(player => player.HeroClassDefinition.HeroClass == HeroClass.DemonHunter) ==
                                           NumberOfDhsInGame;
            var correctSpecialArea = hud.Game.SpecialArea == SpecialArea;


            return(correctRune && bossIsSpawnedCorrect && numberOfDhsInGameCorrect && correctSpecialArea && mateWithNameInGame);
        }
Example #17
0
        private bool AllowedToCast(IPlayerSkill skill)
        {
            var sno = skill.SnoPower.Sno;
            var now = DateTimeOffset.Now.ToUnixTimeMilliseconds();

            if (!lastSkillExectuion.ContainsKey(sno))
            {
                lastSkillExectuion.Add(sno, now);
                return(true);
            }

            var lastExecutionTime = lastSkillExectuion[sno];

            return(now - lastExecutionTime >= MINIMUM_CAST_DELTA);
        }
Example #18
0
        protected override bool Applicable(IController hud, IPlayerSkill skill)
        {
            if (!hud.Game.Me.Powers.BuffIsActive(hud.Sno.SnoPowers.ConventionOfElements.Sno))
            {
                return(false);
            }

            var buff         = hud.Game.Me.Powers.GetBuff(hud.Sno.SnoPowers.ConventionOfElements.Sno);
            var elementIndex = CoeElementToIndex[Element];

            if (buff.IconCounts[elementIndex] == 0)
            {
                return(false);
            }

            return(buff.TimeLeftSeconds[elementIndex] < TimeLeft / 1000.0);
        }
Example #19
0
 private void UpdateSkills(IPlayer me)
 {
     _simulacrumSkill = null;
     _boneArmorSkill  = null;
     //_energyArmorSkill = null;
     me.Powers.UsedSkills.ForEach(skill =>
     {
         if (skill.SnoPower.Sno == 465350)
         {
             _simulacrumSkill = skill;
         }
         if (skill.SnoPower.Sno == 466857)
         {
             _boneArmorSkill = skill;
         }
         //if (skill.SnoPower.Sno == 86991) _energyArmorSkill = skill;
     });
 }
Example #20
0
        private Sprite FindSpriteBySkillName(IPlayerSkill skill)
        {
            if (skill == null)
            {
                return(Sprites[0]);
            }
            var type = skill.GetType();

            Sprite newSprite = Sprites[0];

            foreach (var sprite in Sprites)
            {
                if (type.Name.Contains(sprite.name))
                {
                    return(sprite);
                }
            }
            return(newSprite);
        }
        public override bool Invoke(IController hud, IPlayerSkill skill)
        {
            if (skill.IsOnCooldown)
            {
                return(false);
            }

            var resourceCostType = skill.SnoPower.ResourceCostTypeByRune[skill.Rune == 255 ? 0 : skill.Rune];
            var currentResource  = resourceCostType == PowerResourceCostType.primary
                ? hud.Game.Me.Stats.ResourceCurPri
                : hud.Game.Me.Stats.ResourceCurSec;

            if (currentResource < skill.GetResourceRequirement(skill.ResourceCost))
            {
                return(false);
            }

            skill.Cast();
            return(true);
        }
        protected override bool Applicable(IController hud, IPlayerSkill skill)
        {
            if (!(hud.Game.Players
                  .FirstOrDefault(player =>
                                  !player.IsMe && (player.HeroClassDefinition.HeroClass == Class || Class == HeroClass.None) &&
                                  player.Powers.BuffIsActive(hud.Sno.SnoPowers.ConventionOfElements.Sno))
                  ?.Powers.GetBuff(hud.Sno.SnoPowers.ConventionOfElements.Sno) is IBuff coe))
            {
                return(false);
            }

            var elementIndex = SnoPowerList.CoeElementToIndex[Element];

            if (coe.IconCounts[elementIndex] == 0)
            {
                return(false);
            }

            return(coe.TimeLeftSeconds[elementIndex] < TimeLeft / 1000.0);
        }
Example #23
0
        public void Cast(IPlayerSkill skill)
        {
            if (!settings.SnoToDefinitionGroups.TryGetValue(skill.SnoPower.Sno, out var definitionGroupsForSkill))
            {
                return;
            }

            if (!definitionGroupsForSkill.active || !AllowedToCast(skill) || !Settings.KeyToActive[skill.Key])
            {
                return;
            }

            var applicableGroup =
                definitionGroupsForSkill.definitionGroups.FirstOrDefault(definitionGroup =>
                                                                         definitionGroup.Applicable(settings.Hud, skill));

            if (applicableGroup?.Invoke(settings.Hud, skill) ?? false)
            {
                lastSkillExectuion[applicableGroup.sno] = DateTimeOffset.Now.ToUnixTimeMilliseconds();
            }
        }
Example #24
0
 private void UpdateSkills(IPlayer me)
 {
     _archonSkill      = null;
     _magicWeaponSkill = null;
     _energyArmorSkill = null;
     me.Powers.UsedSkills.ForEach(skill =>
     {
         if (skill.SnoPower.Sno == 134872)
         {
             _archonSkill = skill;
         }
         if (skill.SnoPower.Sno == 76108)
         {
             _magicWeaponSkill = skill;
         }
         if (skill.SnoPower.Sno == 86991)
         {
             _energyArmorSkill = skill;
         }
     });
 }
Example #25
0
        public void Paint(IPlayerSkill skill, RectangleF rect)
        {
            if (skill == null)
            {
                return;
            }

            if (TextureOpacity > 0)
            {
                var texture = Hud.Texture.GetTexture(skill.SnoPower.NormalIconTextureId);
                if (texture != null)
                {
                    texture.Draw(rect.X, rect.Y, rect.Width, rect.Height, TextureOpacity);
                }
            }

            if (skill.IsOnCooldown && (skill.CooldownFinishTick > Hud.Game.CurrentGameTick))
            {
                var remaining = (skill.CooldownFinishTick - Hud.Game.CurrentGameTick) / 60.0d;
                var text      = remaining > 1.0f ? remaining.ToString("F0", CultureInfo.InvariantCulture) : remaining.ToString("F1", CultureInfo.InvariantCulture);

                var textLayout = CooldownFont.GetTextLayout(text);
                DrawTimeLeftClock(rect, (Hud.Game.CurrentGameTick - skill.CooldownStartTick) / 60.0d, (skill.CooldownFinishTick - Hud.Game.CurrentGameTick) / 60.0d);
                CooldownFont.DrawText(textLayout, rect.X + (rect.Width - (float)Math.Ceiling(textLayout.Metrics.Width)) / 2.0f, rect.Y + (rect.Height - textLayout.Metrics.Height) / 2);
            }

            var rune = skill.Rune;

            if (rune == byte.MaxValue)
            {
                rune = 0;
            }
            else
            {
                rune += 1;
            }
        }
 public static void Cast(this IPlayerSkill skill)
 {
     InputSimulator.PressKey(Settings.Keybinds[(int)skill.Key]);
 }
Example #27
0
 public static bool CanUse(this IPlayerSkill skill)
 {
     return(!skill.IsOnCooldown &&
            skill.ResourceCost <= skill.Player.Stats.ResourceCurPri
            );
 }
 public PlayerSkillController(IPlayerSkill playerSkill)
 {
     _playerSkillManager = (PlayerSkillManager)playerSkill;
 }
Example #29
0
        public void Paint(IPlayerSkill skill, RectangleF rect)
        {
            if (skill == null)
            {
                return;
            }

            if (TextureOpacity > 0)
            {
                var texture = Hud.Texture.GetTexture(skill.SnoPower.NormalIconTextureId);
                if (texture != null)
                {
                    texture.Draw(rect.X, rect.Y, rect.Width, rect.Height, TextureOpacity);
                }
            }

            if (skill.IsOnCooldown && (skill.CooldownFinishTick > Hud.Game.CurrentGameTick))
            {
                var remaining = (skill.CooldownFinishTick - Hud.Game.CurrentGameTick) / 60.0d;
                var text      = remaining > 1.0f ? remaining.ToString("F0", CultureInfo.InvariantCulture) : remaining.ToString("F1", CultureInfo.InvariantCulture);

                var textLayout = CooldownFont.GetTextLayout(text);
                CooldownFont.DrawText(textLayout, rect.X + (rect.Width - (float)Math.Ceiling(textLayout.Metrics.Width)) / 2.0f, rect.Y + (rect.Height - textLayout.Metrics.Height) / 2);
            }

            if (!EnableSkillDpsBar || skill.SnoPower.ElementalDamageTypesByRune == null)
            {
                return;
            }

            var elite = Hud.Game.IsEliteOnScreen || Hud.Game.IsGoblinOnScreen;

            if (Hud.Game.IsInTown)
            {
                if (_lastTownEliteSimulation.TimerTest(3000))
                {
                    elite = true;
                    if (_lastTownEliteSimulation.TimerTest(6000))
                    {
                        _lastTownEliteSimulation.Restart();
                    }
                }
            }

            var rune = skill.Rune;

            if (rune == byte.MaxValue)
            {
                rune = 0;
            }
            else
            {
                rune += 1;
            }
            var elementalType = skill.ElementalType;

            if (elementalType == -1)
            {
                return;
            }

            var resourceCost           = skill.ResourceCost;
            var weaponDamageMultiplier = skill.WeaponDamageMultiplier;

            if (weaponDamageMultiplier != -1)
            {
                var dotSeconds = skill.DotSeconds;

                uint powerSno = skill.SnoPower.Sno;
                if (powerSno == 102573)
                {
                    powerSno = 109560;                     // summon zombie dogs fix
                }
                if (powerSno == 123208)
                {
                    powerSno = 362118;                     // mystic ally fix
                }
                var skillBonus     = 1 + skill.DamageBonus;
                var elementalBonus = 1 + skill.ElementalDamageBonus;
                var eliteBonus     = 1 + (elite ? Hud.Game.Me.Offense.BonusToElites : 0);

                var skillBonusTotal = skillBonus * elementalBonus * eliteBonus;

                double plainBonusTotal = 1;
                foreach (var bonus in Hud.Game.Me.Offense.PlainDamageBonuses)
                {
                    plainBonusTotal *= (1 + bonus.Item2);
                }

                var weaponDamage = Hud.Game.Me.Offense.MainHandIsActive ? Hud.Game.Me.Offense.WeaponDamageMainHand : Hud.Game.Me.Offense.WeaponDamageSecondHand;
                var attackSpeed  = Hud.Game.Me.Offense.MainHandIsActive ? Hud.Game.Me.Offense.AttackSpeedMainHand : Hud.Game.Me.Offense.AttackSpeedOffHand;

                var skillDamage = weaponDamage * (weaponDamageMultiplier / 100) * skillBonusTotal * plainBonusTotal;
                var skillDps    = skillDamage;
                if (dotSeconds > 0)
                {
                    skillDps /= dotSeconds;
                }
                else
                {
                    skillDps *= attackSpeed;
                }

                var textLayout = SkillDamageFont.GetTextLayout(BasePlugin.ValueToString(skillDamage, ValueFormat.LongNumber));
                SkillDamageFont.DrawText(textLayout, rect.Left, rect.Bottom - textLayout.Metrics.Height + 1);

                var rHeight = rect.Height * 0.33f;
                var rTop    = rect.Bottom + rHeight * 0.1f;

                SkillDpsBackgroundBrushesByElementalType[elementalType].DrawRectangle(rect.Left, rTop, rect.Width, rHeight);

                textLayout = SkillDpsFont.GetTextLayout(BasePlugin.ValueToString(skillDps, ValueFormat.LongNumber));
                SkillDpsFont.DrawText(textLayout, rect.Left + (rect.Width - textLayout.Metrics.Width) / 2, rTop + (rHeight - textLayout.Metrics.Height) / 2);

                if (skillBonusTotal > 1)
                {
                    var bonusFont = elite ? DamageBonusEliteFont : DamageBonusFont;
                    textLayout = bonusFont.GetTextLayout("+" + (skillBonusTotal * 100 - 100).ToString("F0") + "%");
                    bonusFont.DrawText(textLayout, rect.Left, rect.Top - 1);
                }

                if (EnableDetailedDpsHint && Hud.Window.CursorInsideRect(rect.Left, rect.Top, rect.Width, rect.Height))
                {
                    var plainBonusText = "";
                    var plainBonuses   = Hud.Game.Me.Offense.PlainDamageBonuses.ToList();
                    if (plainBonuses.Count > 0)
                    {
                        plainBonusText = "\nPLAIN BONUSES: +" + (plainBonusTotal * 100 - 100).ToString("F0", CultureInfo.InvariantCulture) + "%\n";
                        foreach (var bonus in plainBonuses)
                        {
                            plainBonusText += "\t" + (bonus.Item2 * 100).ToString("F0", CultureInfo.InvariantCulture) + "% " + bonus.Item1.Icons[0].TitleLocalized + "\n";
                        }
                    }

                    var hint =
                        "WEAPON DAMAGE: " + BasePlugin.ValueToString(weaponDamage, ValueFormat.LongNumber) + " (" + (Hud.Game.Me.Offense.MainHandIsActive ? "left" : "right") + " hand)\n" +
                        (Hud.Game.Me.Offense.MainHandIsActive ?
                         "\t" + (Hud.Game.Me.Offense.WeaponBaseDamageMinAmainHand / 2 + Hud.Game.Me.Offense.WeaponBaseDamageMaxAmainHand / 2).ToString("F0", CultureInfo.InvariantCulture) + " (" + Hud.Game.Me.Offense.WeaponBaseDamageMinAmainHand.ToString("F0", CultureInfo.InvariantCulture) + "-" + Hud.Game.Me.Offense.WeaponBaseDamageMaxAmainHand.ToString("F0", CultureInfo.InvariantCulture) + ")\n" :
                         "\t" + (Hud.Game.Me.Offense.WeaponBaseDamageMinAoffHand / 2 + Hud.Game.Me.Offense.WeaponBaseDamageMaxAoffHand / 2).ToString("F0", CultureInfo.InvariantCulture) + " (" + Hud.Game.Me.Offense.WeaponBaseDamageMinAoffHand.ToString("F0", CultureInfo.InvariantCulture) + "-" + Hud.Game.Me.Offense.WeaponBaseDamageMaxAoffHand.ToString("F0", CultureInfo.InvariantCulture) + ")\n") +
                        (((Hud.Game.Me.Offense.DamageMin > 0) || (Hud.Game.Me.Offense.DamageMax > 0)) ?
                         ((Hud.Game.Me.Offense.DamageMin > 0) || (Hud.Game.Me.Offense.DamageMax > 0) ? "\t+ damage from armor: " + Hud.Game.Me.Offense.DamageMin.ToString("F0", CultureInfo.InvariantCulture) + "-" + Hud.Game.Me.Offense.DamageMax.ToString("F0", CultureInfo.InvariantCulture) + "\n" : "") +
                         (Hud.Game.Me.Offense.MainHandIsActive ?
                          "\t= " + (Hud.Game.Me.Offense.WeaponBaseDamageMinBmainHand / 2 + Hud.Game.Me.Offense.WeaponBaseDamageMaxBmainHand / 2).ToString("F0", CultureInfo.InvariantCulture) + " (" + Hud.Game.Me.Offense.WeaponBaseDamageMinBmainHand.ToString("F0", CultureInfo.InvariantCulture) + "-" + Hud.Game.Me.Offense.WeaponBaseDamageMaxBmainHand.ToString("F0", CultureInfo.InvariantCulture) + ")\n" :
                          "\t= " + (Hud.Game.Me.Offense.WeaponBaseDamageMinBoffHand / 2 + Hud.Game.Me.Offense.WeaponBaseDamageMaxBoffHand / 2).ToString("F0", CultureInfo.InvariantCulture) + " (" + Hud.Game.Me.Offense.WeaponBaseDamageMinBoffHand.ToString("F0", CultureInfo.InvariantCulture) + "-" + Hud.Game.Me.Offense.WeaponBaseDamageMaxBoffHand.ToString("F0", CultureInfo.InvariantCulture) + ")\n")
                        : "") +
                        "\tincreased by main stat: " +
                        (Hud.Game.Me.Offense.MainHandIsActive ?
                         "" + BasePlugin.ValueToString((Hud.Game.Me.Offense.WeaponBaseDamageMinBmainHand / 2 + Hud.Game.Me.Offense.WeaponBaseDamageMaxBmainHand / 2) * (1 + Hud.Game.Me.Stats.MainStat / 100), ValueFormat.LongNumber) + " (" + BasePlugin.ValueToString(Hud.Game.Me.Offense.WeaponBaseDamageMinBmainHand * (1 + Hud.Game.Me.Stats.MainStat / 100), ValueFormat.LongNumber) + "-" + BasePlugin.ValueToString(Hud.Game.Me.Offense.WeaponBaseDamageMaxBmainHand * (1 + Hud.Game.Me.Stats.MainStat / 100), ValueFormat.LongNumber) + ")\n" :
                         "" + BasePlugin.ValueToString((Hud.Game.Me.Offense.WeaponBaseDamageMinBoffHand / 2 + Hud.Game.Me.Offense.WeaponBaseDamageMaxBoffHand / 2) * (1 + Hud.Game.Me.Stats.MainStat / 100), ValueFormat.LongNumber) + " (" + BasePlugin.ValueToString(Hud.Game.Me.Offense.WeaponBaseDamageMinBoffHand * (1 + Hud.Game.Me.Stats.MainStat / 100), ValueFormat.LongNumber) + "-" + BasePlugin.ValueToString(Hud.Game.Me.Offense.WeaponBaseDamageMaxBoffHand * (1 + Hud.Game.Me.Stats.MainStat / 100), ValueFormat.LongNumber) + ")\n") +
                        "\tincreased by crit: " +
                        (Hud.Game.Me.Offense.MainHandIsActive ?
                         "" + BasePlugin.ValueToString((Hud.Game.Me.Offense.WeaponBaseDamageMinBmainHand / 2 + Hud.Game.Me.Offense.WeaponBaseDamageMaxBmainHand / 2) * (1 + Hud.Game.Me.Stats.MainStat / 100) * (1 + Hud.Game.Me.Offense.CriticalHitChance / 100 * Hud.Game.Me.Offense.CritDamage / 100), ValueFormat.LongNumber) + " (" + BasePlugin.ValueToString(Hud.Game.Me.Offense.WeaponBaseDamageMinBmainHand * (1 + Hud.Game.Me.Stats.MainStat / 100) * (1 + Hud.Game.Me.Offense.CriticalHitChance / 100 * Hud.Game.Me.Offense.CritDamage / 100), ValueFormat.LongNumber) + "-" + BasePlugin.ValueToString(Hud.Game.Me.Offense.WeaponBaseDamageMaxBmainHand * (1 + Hud.Game.Me.Stats.MainStat / 100) * (1 + Hud.Game.Me.Offense.CriticalHitChance / 100 * Hud.Game.Me.Offense.CritDamage / 100), ValueFormat.LongNumber) + ")\n" :
                         "" + BasePlugin.ValueToString((Hud.Game.Me.Offense.WeaponBaseDamageMinBoffHand / 2 + Hud.Game.Me.Offense.WeaponBaseDamageMaxBoffHand / 2) * (1 + Hud.Game.Me.Stats.MainStat / 100) * (1 + Hud.Game.Me.Offense.CriticalHitChance / 100 * Hud.Game.Me.Offense.CritDamage / 100), ValueFormat.LongNumber) + " (" + BasePlugin.ValueToString(Hud.Game.Me.Offense.WeaponBaseDamageMinBoffHand * (1 + Hud.Game.Me.Stats.MainStat / 100) * (1 + Hud.Game.Me.Offense.CriticalHitChance / 100 * Hud.Game.Me.Offense.CritDamage / 100), ValueFormat.LongNumber) + "-" + BasePlugin.ValueToString(Hud.Game.Me.Offense.WeaponBaseDamageMaxBoffHand * (1 + Hud.Game.Me.Stats.MainStat / 100) * (1 + Hud.Game.Me.Offense.CriticalHitChance / 100 * Hud.Game.Me.Offense.CritDamage / 100), ValueFormat.LongNumber) + ")\n") +
                        ((Hud.Game.Me.Offense.WeaponDamageIncreasedBySkills > 0) ?
                         "\tincreased by skills: " +
                         (Hud.Game.Me.Offense.MainHandIsActive ?
                          "" + BasePlugin.ValueToString((Hud.Game.Me.Offense.WeaponBaseDamageMinBmainHand / 2 + Hud.Game.Me.Offense.WeaponBaseDamageMaxBmainHand / 2) * (1 + Hud.Game.Me.Stats.MainStat / 100) * (1 + Hud.Game.Me.Offense.CriticalHitChance / 100 * Hud.Game.Me.Offense.CritDamage / 100) * (1 + Hud.Game.Me.Offense.WeaponDamageIncreasedBySkills), ValueFormat.LongNumber) + " (" + BasePlugin.ValueToString(Hud.Game.Me.Offense.WeaponBaseDamageMinBmainHand * (1 + Hud.Game.Me.Stats.MainStat / 100) * (1 + Hud.Game.Me.Offense.CriticalHitChance / 100 * Hud.Game.Me.Offense.CritDamage / 100) * (1 + Hud.Game.Me.Offense.WeaponDamageIncreasedBySkills), ValueFormat.LongNumber) + "-" + BasePlugin.ValueToString(Hud.Game.Me.Offense.WeaponBaseDamageMaxBmainHand * (1 + Hud.Game.Me.Stats.MainStat / 100) * (1 + Hud.Game.Me.Offense.CriticalHitChance / 100 * Hud.Game.Me.Offense.CritDamage / 100) * (1 + Hud.Game.Me.Offense.WeaponDamageIncreasedBySkills), ValueFormat.LongNumber) + ")\n" :
                          "" + BasePlugin.ValueToString((Hud.Game.Me.Offense.WeaponBaseDamageMinBoffHand / 2 + Hud.Game.Me.Offense.WeaponBaseDamageMaxBoffHand / 2) * (1 + Hud.Game.Me.Stats.MainStat / 100) * (1 + Hud.Game.Me.Offense.CriticalHitChance / 100 * Hud.Game.Me.Offense.CritDamage / 100) * (1 + Hud.Game.Me.Offense.WeaponDamageIncreasedBySkills), ValueFormat.LongNumber) + " (" + BasePlugin.ValueToString(Hud.Game.Me.Offense.WeaponBaseDamageMinBoffHand * (1 + Hud.Game.Me.Stats.MainStat / 100) * (1 + Hud.Game.Me.Offense.CriticalHitChance / 100 * Hud.Game.Me.Offense.CritDamage / 100) * (1 + Hud.Game.Me.Offense.WeaponDamageIncreasedBySkills), ValueFormat.LongNumber) + "-" + BasePlugin.ValueToString(Hud.Game.Me.Offense.WeaponBaseDamageMaxBoffHand * (1 + Hud.Game.Me.Stats.MainStat / 100) * (1 + Hud.Game.Me.Offense.CriticalHitChance / 100 * Hud.Game.Me.Offense.CritDamage / 100) * (1 + Hud.Game.Me.Offense.WeaponDamageIncreasedBySkills), ValueFormat.LongNumber) + ")\n")
                        : "") +
                        "\nTOTAL BONUS: +" + (skillBonusTotal * 100 - 100).ToString("F0", CultureInfo.InvariantCulture) + "%\n" +
                        "\t" + (skill.ElementalDamageBonus * 100).ToString("F0", CultureInfo.InvariantCulture) + "% elemental\n" +
                        "\t" + (skill.DamageBonus * 100).ToString("F0", CultureInfo.InvariantCulture) + "% skill\n" +
                        (elite ? "\t" + (Hud.Game.Me.Offense.BonusToElites * 100).ToString("F0", CultureInfo.InvariantCulture) + "% elite\n" : "") +
                        plainBonusText +
                        "\n'" + skill.SnoPower.NameLocalized + "' / '" + skill.RuneNameLocalized + "' does " + weaponDamageMultiplier.ToString("F0", CultureInfo.InvariantCulture) + "% weapon damage" + (dotSeconds > 0 ? " over " + dotSeconds.ToString("F1", CultureInfo.InvariantCulture) + " seconds" : "") + "\n" +
                        "\tDMG: " + BasePlugin.ValueToString(skillDamage, ValueFormat.LongNumber) + " (= " + BasePlugin.ValueToString(weaponDamage, ValueFormat.LongNumber) + " * " + (weaponDamageMultiplier.ToString("F0", CultureInfo.InvariantCulture)) + "% + " + (skillBonusTotal * 100 - 100).ToString("F0", CultureInfo.InvariantCulture) + "% + " + (plainBonusTotal * 100 - 100).ToString("F0", CultureInfo.InvariantCulture) + "%)\n" +
                        "\tDPS: " + BasePlugin.ValueToString(skillDps, ValueFormat.LongNumber) + " (= " + BasePlugin.ValueToString(skillDamage, ValueFormat.LongNumber) + (dotSeconds > 0 ? " / " + dotSeconds.ToString("F1", CultureInfo.InvariantCulture) + " seconds" : " * " + attackSpeed.ToString("F2", CultureInfo.InvariantCulture) + " attack/s") + ")" +
                        ((resourceCost != -1) ? "\n\nResource cost\n\tdefault: " + BasePlugin.ValueToString(Math.Abs(resourceCost), ValueFormat.NormalNumberNoDecimal) + " " + (resourceCost > 0 ? Hud.Game.Me.HeroClassDefinition.PrimaryResourceName : Hud.Game.Me.HeroClassDefinition.SecondaryResourceName) + "\n\treal: " + BasePlugin.ValueToString(skill.GetResourceRequirement(), ValueFormat.NormalNumber) + " " + (resourceCost > 0 ? Hud.Game.Me.HeroClassDefinition.PrimaryResourceName : Hud.Game.Me.HeroClassDefinition.SecondaryResourceName) : "");
                    Hud.Render.SetHint(hint, "tooltip-bottom-right");
                }
            }
            else
            {
                if (resourceCost != -1)
                {
                    if (Hud.Window.CursorInsideRect(rect.Left, rect.Top, rect.Width, rect.Height))
                    {
                        Hud.Render.SetHint("Resource cost\n\tdefault: " + BasePlugin.ValueToString(Math.Abs(resourceCost), ValueFormat.NormalNumberNoDecimal) + " " + (resourceCost > 0 ? Hud.Game.Me.HeroClassDefinition.PrimaryResourceName : Hud.Game.Me.HeroClassDefinition.SecondaryResourceName) + "\n\treal: " + BasePlugin.ValueToString(skill.GetResourceRequirement(), ValueFormat.NormalNumber) + " " + (resourceCost > 0 ? Hud.Game.Me.HeroClassDefinition.PrimaryResourceName : Hud.Game.Me.HeroClassDefinition.SecondaryResourceName), "tooltip-bottom-right");
                    }
                }
            }
        }
Example #30
0
 protected override bool Applicable(IController hud, IPlayerSkill skill)
 {
     return(hud.Game.AliveMonsters.Count(mon => IsElite(mon) && mon.CentralXyDistanceToMe <= Range) >= MinimumAmount);
 }