コード例 #1
0
 public void OnNewArea(bool newGame, ISnoArea area)
 {
     if (newGame)
     {
         _lastNewGame.Restart();
     }
 }
コード例 #2
0
        public void BeforeRender()
        {
            if (!Enabled)
            {
                return;
            }
            if (!Hud.Game.IsInGame)
            {
                return;
            }

            var captureOn = Hud.Render.ParagonLevelUpSplashTextUiElement.Visible &&
                            !string.IsNullOrEmpty(Hud.MyBattleTag) &&
                            _lastNewGame.TimerTest(10 * 1000);

            if (!captureOn)
            {
                if (StopRenderingWhenCapturing && !Hud.Render.IsRenderEnabled)
                {
                    // turn back
                    Hud.Render.IsRenderEnabled = true;
                }
                return;
            }

            if (StopRenderingWhenCapturing && Hud.Render.IsRenderEnabled)
            {
                // turn off and wait a cycle before first capture so HUD can disappear properly
                Hud.Render.IsRenderEnabled = false;
                return;
            }

            var paragonLevel = Hud.Game.Me.CurrentLevelParagon;

            if (_lastLevelUp.TimerTest(120 * 1000))
            {
                _lastLevelUp.Restart();
                _lastLevelUpDelay = null;
                _lastLevelUpLimiter.Restart();

                Hud.TextLog.Log("levelup_paragon_" + Hud.MyBattleTag, paragonLevel.ToString("D", CultureInfo.InvariantCulture));
            }
            if ((_lastLevelUpDelay == null || _lastLevelUpDelay.TimerTest(DelayBetweenFrames)) && !_lastLevelUpLimiter.TimerTest(8 * 1000))
            {
                if (_lastLevelUpDelay == null)
                {
                    _lastLevelUpDelay = Hud.Time.CreateWatch();
                }

                _lastLevelUpDelay.Restart();
                try
                {
                    var fileName = Hud.MyBattleTag + "_" + Hud.Game.Me.HeroId.ToString("D", CultureInfo.InvariantCulture) + "_" + Hud.Game.Me.HeroName + "_" + Hud.Time.Now.ToString("yyyyMMddHHmmssfff", CultureInfo.InvariantCulture) + "_" + paragonLevel.ToString("D", CultureInfo.InvariantCulture) + ".jpg";
                    Hud.Render.CaptureScreenToFile(SubFolderName, fileName);
                }
                catch (Exception) { }
                finally { }
            }
        }
コード例 #3
0
        public override void Load(IController hud)
        {
            base.Load(hud);
            //Turn labels on and off
            ShowIgnorePain = false;
            //ShowOculus = true;



            //Horizontal and Vertical label positions.
            YPos = 0.65f;
            XPos = 0.5f;

            SizeModifier = 1f;
            TextSize     = 8;
            JumpDistance = 1.07f;
            NumRows      = 1;

            //Label size is based on a percentage of screen width/height
            _labelWidthPercentage  = 0.040f;
            _labelHeightPercentage = 0.018f;

            //Vertical distance between labels
            YPosIncrement = 0.021f;

            //If true labels are always shown
            Debug          = false;
            SmoothMovement = true;
            SmoothSpeed    = 0.05f;
            debugWatch     = Hud.Time.CreateWatch();
            debugWatch.Restart();

            BorderBrush = Hud.Render.CreateBrush(150, 30, 30, 30, 0);

            //BackgroundBrushIP = Hud.Render.CreateBrush(100, 100, 225, 100, 0);   // Ignore Pain


            Labels = new List <Label>();

            //Labels.Add(new Label("神目指环", 402461, 2, BackgroundBrushOC, ShowOculus));


            _jumpCount = 1;
            _yPosTemp  = YPos;
            _xPosTemp  = XPos;
            if (NumRows < 1)
            {
                NumRows = 1;
            }
        }
コード例 #4
0
        public void AfterCollect()
        {
            if (!Hud.Game.IsInGame)
            {
                return;
            }
            if (Hud.Game.IsInTown)
            {
                return;
            }

            // TODO : greed & whyrmshire portals
            //408679	MarkerLocation_GoblinPortalIn
            // 393030	p1_Greed_Portal
            // 405750	p1_Greed_PortalMonsterSummon	Invisible portal summoner
            //408679	MarkerLocation_GoblinPortalIn

            //var goblins = Hud.Game.AliveMonsters.Where(x => x.SnoMonster.Priority == MonsterPriority.goblin && x.GetData<SoundAlert<IMonster>>() == null && x.SnoActor.Sno != 410572 && x.SnoActor.Sno != 410574);
            var goblins = Hud.Game.AliveMonsters.Where(x => SnoMapping.ContainsKey(x.SnoMonster.Sno) && x.GetData <SoundAlert <IMonster> >() == null);

            //Says.Debug(string.Join(" ", goblins.Select(g => g.SnoMonster.Sno)));
            if (goblins.Count() > 1)
            {
                if (!lastPack.IsRunning || lastPack.TimerTest(180000)) // 3 minutes
                {
                    lastPack.Restart();
                    SoundAlertManagerPlugin.Register <IMonster>(goblins.First(), GoblinPack);
                }
            }
            else
            {
                foreach (var goblin in goblins)
                {
                    SoundAlert <IMonster> soundAlert;
                    if (!SnoMapping.TryGetValue(goblin.SnoActor.Sno, out soundAlert))
                    {
                        soundAlert = DefaultGoblin;
                    }
                    SoundAlertManagerPlugin.Register <IMonster>(goblin, soundAlert);
                }
            }
        }
コード例 #5
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");
                    }
                }
            }
        }
コード例 #6
0
        public void PaintTopInGame(ClipState clipState)
        {
            if (Hud.Render.UiHidden)
            {
                return;
            }
            if (clipState != ClipState.BeforeClip)
            {
                return;
            }
            if (Hud.Game.Me.PortraitUiElement.Rectangle == null)
            {
                return;
            }
            var uiRect = Hud.Game.Me.PortraitUiElement.Rectangle;


            if (Hud.Game.Me.CurrentLevelNormal == 70)
            {
                ParagonPercentage = string.Format(CultureInfo.InvariantCulture, "{0:0.##}%", (Hud.Game.Me.CurrentLevelParagonFloat - Hud.Game.Me.CurrentLevelParagon) * 100);
            }
            else if (Hud.Game.Me.CurrentLevelNormal < 70)
            {
                ParagonPercentage = string.Format(CultureInfo.InvariantCulture, "{0:0.##}%", Convert.ToSingle(Hud.Game.Me.CurrentLevelNormal) / 70 * 100);
            }



            if (ParagonPercentageOnTheRight & DisplayParagonPercentage)
            {
                ParagonPercentageDecorator.Paint(uiRect.Left + uiRect.Width * 0.71f, uiRect.Top + uiRect.Height * 0.79f, uiRect.Width * 0.48f, uiRect.Height * 0.14f, HorizontalAlign.Center);
            }
            else if (DisplayParagonPercentage)
            {
                ParagonPercentageDecorator.Paint(uiRect.Left + uiRect.Width * -0.18f, uiRect.Top + uiRect.Height * 0.79f, uiRect.Width * 0.48f, uiRect.Height * 0.14f, HorizontalAlign.Center);
            }
            ;


            foreach (var player in Hud.Game.Players.OrderBy(p => p.PortraitIndex))
            {
                if (player == null)
                {
                    continue;
                }
                if (player.PortraitUiElement == null)
                {
                    continue;
                }
                if (player.PortraitUiElement.Rectangle == null)
                {
                    continue;
                }
                var portrait = player.PortraitUiElement.Rectangle;

                GRlevel  = player.HighestHeroSoloRiftLevel;
                SheetDPS = player.Offense.SheetDps;
                EHP      = player.Defense.EhpCur;
                Class    = (IsZDPS(player)) ? "Z " + player.HeroClassDefinition.HeroClass  : player.HeroClassDefinition.HeroClass.ToString();;
                var Nemo = player.Powers.GetBuff(318820);
                if (Nemo == null || !Nemo.Active)
                {
                    Nemesis = "";
                }
                else
                {
                    Nemesis = " [Nemesis]";
                }
                var Unit = player.Powers.GetBuff(318769);
                if (Unit == null || !Unit.Active)
                {
                    Unity = "";
                }
                else
                {
                    Unity = " [Unity]";
                }
                var MyUnit = Hud.Game.Me.Powers.GetBuff(318769);


                if (player.CurrentLevelNormal == 70 && ShowGreaterRiftMaxLevel)
                {
                    var grk     = Hud.Inventory.GetSnoItem(2835237830);
                    var texture = Hud.Texture.GetItemTexture(grk);

                    HighestSoloRiftLevelDecorator.Paint(portrait.Left + portrait.Width * 0.26f, portrait.Top + portrait.Height * 0.2f, portrait.Width * 0.5f, portrait.Height * 0.1f, HorizontalAlign.Center);
                    texture.Draw(portrait.Left + portrait.Width * 0.26f, portrait.Top + portrait.Height * 0.17f, 20f, 20f, 1f);
                }


                if (!player.IsMe)
                {
                    if (Nemo == null || !Nemo.Active)
                    {
                    }
                    else
                    {
                        if (ParagonPercentageOnTheRight)
                        {
                            NemesisDecorator.Paint(portrait.Left + portrait.Width * 0.71f, portrait.Top + portrait.Height * 0.79f, portrait.Width * 0.28f, portrait.Height * 0.14f, HorizontalAlign.Center);
                        }
                        else
                        {
                            NemesisDecorator.Paint(portrait.Left + portrait.Width * -0.18f, portrait.Top + portrait.Height * 0.79f, portrait.Width * 0.28f, portrait.Height * 0.14f, HorizontalAlign.Center);
                        };
                    };
                }
                ;



                if (MyUnit == null || !MyUnit.Active)
                {
                }
                else
                {
                    if (!player.IsMe)
                    {
                        if (Unit == null || !Unit.Active)
                        {
                        }
                        else
                        {
                            if (Nemo == null || !Nemo.Active)
                            {
                                if (ParagonPercentageOnTheRight)
                                {
                                    UnityDecorator.Paint(portrait.Left + portrait.Width * 0.71f, portrait.Top + portrait.Height * 0.79f, portrait.Width * 0.28f, portrait.Height * 0.14f, HorizontalAlign.Center);
                                }
                                else
                                {
                                    UnityDecorator.Paint(portrait.Left + portrait.Width * -0.18f, portrait.Top + portrait.Height * 0.79f, portrait.Width * 0.28f, portrait.Height * 0.14f, HorizontalAlign.Center);
                                };
                            }
                            else
                            {
                                if (ParagonPercentageOnTheRight)
                                {
                                    UnityDecorator.Paint(portrait.Left + portrait.Width * 0.71f, portrait.Top + portrait.Height * 0.93f, portrait.Width * 0.28f, portrait.Height * 0.14f, HorizontalAlign.Center);
                                }
                                else
                                {
                                    UnityDecorator.Paint(portrait.Left + portrait.Width * -0.18f, portrait.Top + portrait.Height * 0.93f, portrait.Width * 0.28f, portrait.Height * 0.14f, HorizontalAlign.Center);
                                };
                            }
                        }
                    }
                }

                if (IsZDPS(player))
                {
                    ZDPSDecorator.Paint(portrait.Left + portrait.Width * 0.26f, portrait.Top + portrait.Height * 0.4f, portrait.Width * 0.5f, portrait.Height * 0.1f, HorizontalAlign.Center);
                }


                if (player.AnimationState == AcdAnimationState.Idle && player.CoordinateKnown)
                {
                    if (player.PortraitIndex == 0)
                    {
                        if (player.FloorCoordinate != Player0pos)
                        {
                            _watch0.Restart();
                        }
                        int AFK0 = (int)(_watch0.ElapsedMilliseconds / 60000);
                        if (AFK0 > 3)
                        {
                            AFKDecorator.Paint(portrait.Left + portrait.Width * 0.26f, portrait.Top + portrait.Height * 0.4f, portrait.Width * 0.5f, portrait.Height * 0.1f, HorizontalAlign.Center);
                        }
                    }
                    if (player.PortraitIndex == 1)
                    {
                        if (player.FloorCoordinate != Player1pos)
                        {
                            _watch1.Restart();
                        }
                        int AFK1 = (int)(_watch1.ElapsedMilliseconds / 60000);
                        if (AFK1 > 3)
                        {
                            AFKDecorator.Paint(portrait.Left + portrait.Width * 0.26f, portrait.Top + portrait.Height * 0.4f, portrait.Width * 0.5f, portrait.Height * 0.1f, HorizontalAlign.Center);
                        }
                    }
                    if (player.PortraitIndex == 2)
                    {
                        if (player.FloorCoordinate != Player2pos)
                        {
                            _watch2.Restart();
                        }
                        int AFK2 = (int)(_watch2.ElapsedMilliseconds / 60000);
                        if (AFK2 > 3)
                        {
                            AFKDecorator.Paint(portrait.Left + portrait.Width * 0.26f, portrait.Top + portrait.Height * 0.4f, portrait.Width * 0.5f, portrait.Height * 0.1f, HorizontalAlign.Center);
                        }
                    }
                    if (player.PortraitIndex == 3)
                    {
                        if (player.FloorCoordinate != Player3pos)
                        {
                            _watch3.Restart();
                        }
                        int AFK3 = (int)(_watch3.ElapsedMilliseconds / 60000);
                        if (AFK3 > 3)
                        {
                            AFKDecorator.Paint(portrait.Left + portrait.Width * 0.26f, portrait.Top + portrait.Height * 0.4f, portrait.Width * 0.5f, portrait.Height * 0.1f, HorizontalAlign.Center);
                        }
                    }
                }
                else
                {
                    if (player.PortraitIndex == 0)
                    {
                        _watch0.Restart();
                    }
                    if (player.PortraitIndex == 1)
                    {
                        _watch1.Restart();
                    }
                    if (player.PortraitIndex == 2)
                    {
                        _watch2.Restart();
                    }
                    if (player.PortraitIndex == 3)
                    {
                        _watch3.Restart();
                    }
                }

                if (player.PortraitIndex == 0)
                {
                    Player0pos = player.FloorCoordinate;
                }
                if (player.PortraitIndex == 1)
                {
                    Player1pos = player.FloorCoordinate;
                }
                if (player.PortraitIndex == 2)
                {
                    Player2pos = player.FloorCoordinate;
                }
                if (player.PortraitIndex == 3)
                {
                    Player3pos = player.FloorCoordinate;
                }
            }
        }
コード例 #7
0
        public override void Load(IController hud)
        {
            base.Load(hud);
            _watch0    = Hud.Time.CreateWatch();
            _watch1    = Hud.Time.CreateWatch();
            _watch2    = Hud.Time.CreateWatch();
            _watch3    = Hud.Time.CreateWatch();
            _NPCwatch0 = Hud.Time.CreateWatch();
            _NPCwatch1 = Hud.Time.CreateWatch();
            _NPCwatch2 = Hud.Time.CreateWatch();
            _NPCwatch3 = Hud.Time.CreateWatch();
            _NPCwatch0.Restart();
            _NPCwatch1.Restart();
            _NPCwatch2.Restart();
            _NPCwatch3.Restart();

            ShowGreaterRiftMaxLevel     = true;
            ParagonPercentageOnTheRight = true;
            ParagonPercentage           = "0";
            DisplayParagonPercentage    = true;
            TimeToNextParagon           = string.Empty;
            LastChatLine = string.Empty;


            ParagonPercentageDecorator = new TopLabelDecorator(Hud)
            {
                BackgroundTexture1        = Hud.Texture.Button2TextureBrown,
                BackgroundTextureOpacity1 = 0.8f,
                TextFont = Hud.Render.CreateFont("Segoe UI Light", 7, 250, 255, 255, 255, false, false, true),

                TextFunc = () => ParagonPercentage,
                HintFunc = () => "Paragon level " + (Hud.Game.Me.CurrentLevelParagon + 1) + " in " + TimeToNextParagon + Environment.NewLine + "EXP/h : " + ValueToString(Hud.Game.CurrentHeroToday.GainedExperiencePerHourPlay, ValueFormat.ShortNumber),
            };



            GRlevel  = -1;
            SheetDPS = -1;
            EHP      = -1;
            Class    = "-1";
            Nemesis  = "-1";
            Unity    = "-1";



            HighestSoloRiftLevelDecorator = new TopLabelDecorator(Hud)
            {
                BackgroundTexture1        = Hud.Texture.Button2TextureBrown,
                BackgroundTextureOpacity1 = 0.9f,
                TextFont = Hud.Render.CreateFont("Segoe UI Light", 7, 250, 255, 255, 255, false, false, true),

                TextFunc = () => "      " + GRlevel,

                HintFunc = () => Class + Nemesis + Unity + Environment.NewLine + "Sheet DPS : " + ValueToString((long)SheetDPS, ValueFormat.LongNumber) + Environment.NewLine + "EHP : " + ValueToString((long)EHP, ValueFormat.LongNumber),
            };

            ZDPSDecorator = new TopLabelDecorator(Hud)
            {
                BackgroundBrush = Hud.Render.CreateBrush(0, 0, 0, 0, 0),
                BorderBrush     = Hud.Render.CreateBrush(0, 182, 26, 255, 1),
                TextFont        = Hud.Render.CreateFont("Segoe UI Light", 30, 120, 0, 191, 255, true, false, false),

                TextFunc = () => "Z",
                HintFunc = () => "",
            };

            AFKDecorator = new TopLabelDecorator(Hud)
            {
                BackgroundBrush = Hud.Render.CreateBrush(0, 0, 0, 0, 0),
                BorderBrush     = Hud.Render.CreateBrush(0, 182, 26, 255, 1),
                TextFont        = Hud.Render.CreateFont("Segoe UI Light", 30, 255, 255, 0, 0, true, false, 255, 255, 255, 255, true),

                TextFunc = () => "AFK",
                HintFunc = () => "",
            };

            NPCDecorator = new TopLabelDecorator(Hud)
            {
                BackgroundBrush = Hud.Render.CreateBrush(0, 0, 0, 0, 0),
                BorderBrush     = Hud.Render.CreateBrush(0, 182, 26, 255, 1),
                TextFont        = Hud.Render.CreateFont("Segoe UI Light", 30, 40, 0, 255, 0, true, false, 40, 255, 255, 255, true),

                TextFunc = () => "NPC",
                HintFunc = () => "",
            };

            NemesisDecorator = new TopLabelDecorator(Hud)
            {
                BackgroundTexture1        = Hud.Texture.Button2TextureBrown,
                BackgroundTextureOpacity1 = 0.8f,
                TextFont = Hud.Render.CreateFont("Segoe UI Light", 7, 250, 212, 144, 0, false, false, true),

                TextFunc = () => "[N]",
                HintFunc = () => "Nemesis equipped",
            };

            UnityDecorator = new TopLabelDecorator(Hud)
            {
                BackgroundTexture1        = Hud.Texture.Button2TextureBrown,
                BackgroundTextureOpacity1 = 0.8f,
                TextFont = Hud.Render.CreateFont("Segoe UI Light", 7, 250, 212, 144, 0, false, false, true),

                TextFunc = () => "[U]",
                HintFunc = () => "Unity equipped",
            };
        }
コード例 #8
0
        public void PaintTopInGame(ClipState clipState)
        {
            if (Hud.Render.UiHidden)
            {
                return;
            }
            if (clipState != ClipState.BeforeClip)
            {
                return;
            }
            if (Hud.Game.Me.PortraitUiElement.Rectangle == null)
            {
                return;
            }
            var uiRect = Hud.Game.Me.PortraitUiElement.Rectangle;

            int index = Hud.Game.Me.Hero.BattleTag.IndexOf("#");

            if (index > 0)
            {
                MyAccountName = Hud.Game.Me.Hero.BattleTag.Substring(0, index);
            }


            if (Hud.Game.Me.CurrentLevelNormal == 70)
            {
                ParagonPercentage = string.Format(CultureInfo.InvariantCulture, "{0:0.##}%", (Hud.Game.Me.CurrentLevelParagonDouble - Hud.Game.Me.CurrentLevelParagon) * 100);
            }
            else if (Hud.Game.Me.CurrentLevelNormal < 70)
            {
                ParagonPercentage = string.Format(CultureInfo.InvariantCulture, "{0:0.##}%", Convert.ToSingle(Hud.Game.Me.CurrentLevelNormal) / 70 * 100);
            }



            if (ParagonPercentageOnTheRight & DisplayParagonPercentage)
            {
                ParagonPercentageDecorator.Paint(uiRect.Left + uiRect.Width * 0.71f, uiRect.Top + uiRect.Height * 0.79f, uiRect.Width * 0.48f, uiRect.Height * 0.14f, HorizontalAlign.Center);
            }
            else if (DisplayParagonPercentage)
            {
                ParagonPercentageDecorator.Paint(uiRect.Left + uiRect.Width * -0.18f, uiRect.Top + uiRect.Height * 0.79f, uiRect.Width * 0.48f, uiRect.Height * 0.14f, HorizontalAlign.Center);
            }
            ;


            foreach (var player in Hud.Game.Players.OrderBy(p => p.PortraitIndex))
            {
                if (player == null || player.PortraitUiElement == null || player.PortraitUiElement.Rectangle == null || player.BattleTagAbovePortrait == null)
                {
                    continue;
                }
                var portrait = player.PortraitUiElement.Rectangle;

                GRlevel  = player.HighestHeroSoloRiftLevel;
                SheetDPS = player.Offense.SheetDps;
                EHP      = player.Defense.EhpCur;
                Class    = IsZDPS(player) ? "Z " + player.HeroClassDefinition.HeroClass  : player.HeroClassDefinition.HeroClass.ToString();
                var Nemo = player.Powers.GetBuff(318820);
                if (Nemo == null || !Nemo.Active)
                {
                    Nemesis = "";
                }
                else
                {
                    Nemesis = " [Nemesis]";
                }
                var Unit = player.Powers.GetBuff(318769);
                if (Unit == null || !Unit.Active)
                {
                    Unity = "";
                }
                else
                {
                    Unity = " [Unity]";
                }
                var MyUnit = Hud.Game.Me.Powers.GetBuff(318769);


                if (player.CurrentLevelNormal == 70 && ShowGreaterRiftMaxLevel)
                {
                    uint TextNumber = 795145286;

                    if (GRlevel > 0 && GRlevel < 10)
                    {
                        TextNumber = (uint)(795145286 + GRlevel);
                    }
                    else if (GRlevel > 9 && GRlevel < 20)
                    {
                        TextNumber = (uint)(795145309 + GRlevel);
                    }
                    else if (GRlevel > 19 && GRlevel < 30)
                    {
                        TextNumber = (uint)(795145332 + GRlevel);
                    }
                    else if (GRlevel > 29 && GRlevel < 40)
                    {
                        TextNumber = (uint)(795145355 + GRlevel);
                    }
                    else if (GRlevel > 39 && GRlevel < 50)
                    {
                        TextNumber = (uint)(795145378 + GRlevel);
                    }
                    else if (GRlevel > 49 && GRlevel < 60)
                    {
                        TextNumber = (uint)(795145401 + GRlevel);
                    }
                    else if (GRlevel > 59 && GRlevel < 70)
                    {
                        TextNumber = (uint)(795145424 + GRlevel);
                    }
                    else if (GRlevel > 69 && GRlevel < 80)
                    {
                        TextNumber = (uint)(795145447 + GRlevel);
                    }
                    else if (GRlevel > 79 && GRlevel < 90)
                    {
                        TextNumber = (uint)(795145470 + GRlevel);
                    }
                    else if (GRlevel > 89 && GRlevel < 100)
                    {
                        TextNumber = (uint)(795145493 + GRlevel);
                    }
                    else if (GRlevel > 99 && GRlevel < 110)
                    {
                        TextNumber = (uint)(469991699 + GRlevel);
                    }
                    else if (GRlevel > 109 && GRlevel < 120)
                    {
                        TextNumber = (uint)(469991722 + GRlevel);
                    }
                    else if (GRlevel > 119 && GRlevel < 130)
                    {
                        TextNumber = (uint)(469991745 + GRlevel);
                    }
                    else if (GRlevel > 129 && GRlevel < 140)
                    {
                        TextNumber = (uint)(469991768 + GRlevel);
                    }
                    else if (GRlevel > 139 && GRlevel < 150)
                    {
                        TextNumber = (uint)(469991791 + GRlevel);
                    }
                    else if (GRlevel == 150)
                    {
                        TextNumber = 469991964;
                    }

                    if (GRlevel != 0)
                    {
                        var texture = Hud.Texture.GetTexture(TextNumber);
                        if (texture == null)
                        {
                            texture = Hud.Texture.GetTexture(795145286);
                        }
                        var glow = Hud.Texture.GetTexture(1738962956);

                        HighestSoloRiftLevelDecorator.Paint(portrait.Left + portrait.Width * 0.26f, portrait.Top + portrait.Height * 0.2f, portrait.Width * 0.5f, portrait.Height * 0.1f, HorizontalAlign.Center);
                        glow.Draw(portrait.Left + portrait.Width * 0.17f, portrait.Top + portrait.Height * 0.08f, 60f, 60f, 0.5f);
                        texture.Draw(portrait.Left + portrait.Width * 0.30f, portrait.Top + portrait.Height * 0.14f, 37f, 37f, 1f);
                    }
                }


                if (!player.IsMe)
                {
                    if (Nemo == null || !Nemo.Active)
                    {
                    }
                    else
                    {
                        if (ParagonPercentageOnTheRight)
                        {
                            NemesisDecorator.Paint(portrait.Left + portrait.Width * 0.71f, portrait.Top + portrait.Height * 0.79f, portrait.Width * 0.28f, portrait.Height * 0.14f, HorizontalAlign.Center);
                        }
                        else
                        {
                            NemesisDecorator.Paint(portrait.Left + portrait.Width * -0.18f, portrait.Top + portrait.Height * 0.79f, portrait.Width * 0.28f, portrait.Height * 0.14f, HorizontalAlign.Center);
                        };
                    };
                }
                ;



                if (MyUnit == null || !MyUnit.Active)
                {
                }
                else
                {
                    if (!player.IsMe)
                    {
                        if (Unit == null || !Unit.Active)
                        {
                        }
                        else
                        {
                            if (Nemo == null || !Nemo.Active)
                            {
                                if (ParagonPercentageOnTheRight)
                                {
                                    UnityDecorator.Paint(portrait.Left + portrait.Width * 0.71f, portrait.Top + portrait.Height * 0.79f, portrait.Width * 0.28f, portrait.Height * 0.14f, HorizontalAlign.Center);
                                }
                                else
                                {
                                    UnityDecorator.Paint(portrait.Left + portrait.Width * -0.18f, portrait.Top + portrait.Height * 0.79f, portrait.Width * 0.28f, portrait.Height * 0.14f, HorizontalAlign.Center);
                                };
                            }
                            else
                            {
                                if (ParagonPercentageOnTheRight)
                                {
                                    UnityDecorator.Paint(portrait.Left + portrait.Width * 0.71f, portrait.Top + portrait.Height * 0.93f, portrait.Width * 0.28f, portrait.Height * 0.14f, HorizontalAlign.Center);
                                }
                                else
                                {
                                    UnityDecorator.Paint(portrait.Left + portrait.Width * -0.18f, portrait.Top + portrait.Height * 0.93f, portrait.Width * 0.28f, portrait.Height * 0.14f, HorizontalAlign.Center);
                                };
                            }
                        }
                    }
                }

                if (IsZDPS(player))
                {
                    ZDPSDecorator.Paint(portrait.Left + portrait.Width * 0.26f, portrait.Top + portrait.Height * 0.4f, portrait.Width * 0.5f, portrait.Height * 0.1f, HorizontalAlign.Center);
                }


                if (player.AnimationState == AcdAnimationState.Idle && player.CoordinateKnown)
                {
                    if (player.PortraitIndex == 0)
                    {
                        if (player.FloorCoordinate != Player0pos)
                        {
                            _watch0.Restart();
                        }
                        int AFK0 = (int)(_watch0.ElapsedMilliseconds / 60000);
                        if (AFK0 > 3)
                        {
                            AFKDecorator.Paint(portrait.Left + portrait.Width * 0.26f, portrait.Top + portrait.Height * 0.6f, portrait.Width * 0.5f, portrait.Height * 0.1f, HorizontalAlign.Center);
                            isAFK0 = true;
                        }
                        else
                        {
                            isAFK0 = false;
                        }
                    }
                    if (player.PortraitIndex == 1)
                    {
                        if (player.FloorCoordinate != Player1pos)
                        {
                            _watch1.Restart();
                        }
                        int AFK1 = (int)(_watch1.ElapsedMilliseconds / 60000);
                        if (AFK1 > 3)
                        {
                            AFKDecorator.Paint(portrait.Left + portrait.Width * 0.26f, portrait.Top + portrait.Height * 0.6f, portrait.Width * 0.5f, portrait.Height * 0.1f, HorizontalAlign.Center);
                            isAFK1 = true;
                        }
                        else
                        {
                            isAFK1 = false;
                        }
                    }
                    if (player.PortraitIndex == 2)
                    {
                        if (player.FloorCoordinate != Player2pos)
                        {
                            _watch2.Restart();
                        }
                        int AFK2 = (int)(_watch2.ElapsedMilliseconds / 60000);
                        if (AFK2 > 3)
                        {
                            AFKDecorator.Paint(portrait.Left + portrait.Width * 0.26f, portrait.Top + portrait.Height * 0.6f, portrait.Width * 0.5f, portrait.Height * 0.1f, HorizontalAlign.Center);
                            isAFK2 = true;
                        }
                        else
                        {
                            isAFK2 = false;
                        }
                    }
                    if (player.PortraitIndex == 3)
                    {
                        if (player.FloorCoordinate != Player3pos)
                        {
                            _watch3.Restart();
                        }
                        int AFK3 = (int)(_watch3.ElapsedMilliseconds / 60000);
                        if (AFK3 > 3)
                        {
                            AFKDecorator.Paint(portrait.Left + portrait.Width * 0.26f, portrait.Top + portrait.Height * 0.6f, portrait.Width * 0.5f, portrait.Height * 0.1f, HorizontalAlign.Center);
                            isAFK3 = true;
                        }
                        else
                        {
                            isAFK3 = false;
                        }
                    }
                }
                else
                {
                    if (player.PortraitIndex == 0)
                    {
                        _watch0.Restart();
                    }
                    if (player.PortraitIndex == 1)
                    {
                        _watch1.Restart();
                    }
                    if (player.PortraitIndex == 2)
                    {
                        _watch2.Restart();
                    }
                    if (player.PortraitIndex == 3)
                    {
                        _watch3.Restart();
                    }
                }

                if (player.PortraitIndex == 0 && LastChatLine.Contains(MyAccountName))
                {
                    if (!LastChatLine.Contains("AFK"))
                    {
                        _watch0.Restart();
                    }
                    if (LastChatLine.Contains("teleported") || LastChatLine.Contains("returning") || LastChatLine.Contains("slain") || LastChatLine.Contains("AFK"))
                    {
                    }
                    else
                    {
                        _NPCwatch0.Restart();
                    }
                }
                else if (player.PortraitIndex == 1 && LastChatLine.Contains(player.BattleTagAbovePortrait))
                {
                    if (!LastChatLine.Contains("AFK"))
                    {
                        _watch1.Restart();
                    }
                    if (LastChatLine.Contains("teleported") || LastChatLine.Contains("returning") || LastChatLine.Contains("slain") || LastChatLine.Contains("AFK"))
                    {
                    }
                    else
                    {
                        _NPCwatch1.Restart();
                    }
                }
                else if (player.PortraitIndex == 2 && LastChatLine.Contains(player.BattleTagAbovePortrait))
                {
                    if (!LastChatLine.Contains("AFK"))
                    {
                        _watch2.Restart();
                    }
                    if (LastChatLine.Contains("teleported") || LastChatLine.Contains("returning") || LastChatLine.Contains("slain") || LastChatLine.Contains("AFK"))
                    {
                    }
                    else
                    {
                        _NPCwatch2.Restart();
                    }
                }
                else if (player.PortraitIndex == 3 && LastChatLine.Contains(player.BattleTagAbovePortrait))
                {
                    if (!LastChatLine.Contains("AFK"))
                    {
                        _watch3.Restart();
                    }
                    if (LastChatLine.Contains("teleported") || LastChatLine.Contains("returning") || LastChatLine.Contains("slain") || LastChatLine.Contains("AFK"))
                    {
                    }
                    else
                    {
                        _NPCwatch3.Restart();
                    }
                }

                if (player.PortraitIndex == 0)
                {
                    if (!string.IsNullOrEmpty(player.BattleTagAbovePortrait) && player.BattleTagAbovePortrait != NamePlayer0)
                    {
                        _NPCwatch0.Restart();
                        _watch0.Restart();
                    }
                    Player0pos = player.FloorCoordinate;
                    int NPC0 = (int)(_NPCwatch0.ElapsedMilliseconds / 60000);
                    if (NPC0 > 3 && !isAFK0 && NPCDeco)
                    {
                        NPCDecorator.Paint(portrait.Left + portrait.Width * 0.26f, portrait.Top + portrait.Height * 0.6f, portrait.Width * 0.5f, portrait.Height * 0.1f, HorizontalAlign.Center);
                    }
                    NamePlayer0 = player.BattleTagAbovePortrait;
                }
                else if (player.PortraitIndex == 1)
                {
                    if (!string.IsNullOrEmpty(player.BattleTagAbovePortrait) && player.BattleTagAbovePortrait != NamePlayer1)
                    {
                        _NPCwatch1.Restart();
                        _watch1.Restart();
                    }
                    Player1pos = player.FloorCoordinate;
                    int NPC1 = (int)(_NPCwatch1.ElapsedMilliseconds / 60000);
                    if (NPC1 > 3 && !isAFK1 && NPCDeco)
                    {
                        NPCDecorator.Paint(portrait.Left + portrait.Width * 0.26f, portrait.Top + portrait.Height * 0.6f, portrait.Width * 0.5f, portrait.Height * 0.1f, HorizontalAlign.Center);
                    }
                    NamePlayer1 = player.BattleTagAbovePortrait;
                }
                else if (player.PortraitIndex == 2)
                {
                    if (!string.IsNullOrEmpty(player.BattleTagAbovePortrait) && player.BattleTagAbovePortrait != NamePlayer2)
                    {
                        _NPCwatch2.Restart();
                        _watch2.Restart();
                    }
                    Player2pos = player.FloorCoordinate;
                    int NPC2 = (int)(_NPCwatch2.ElapsedMilliseconds / 60000);
                    if (NPC2 > 3 && !isAFK2 && NPCDeco)
                    {
                        NPCDecorator.Paint(portrait.Left + portrait.Width * 0.26f, portrait.Top + portrait.Height * 0.6f, portrait.Width * 0.5f, portrait.Height * 0.1f, HorizontalAlign.Center);
                    }
                    NamePlayer2 = player.BattleTagAbovePortrait;
                }
                else if (player.PortraitIndex == 3)
                {
                    if (!string.IsNullOrEmpty(player.BattleTagAbovePortrait) && player.BattleTagAbovePortrait != NamePlayer3)
                    {
                        _NPCwatch3.Restart();
                        _watch3.Restart();
                    }
                    Player3pos = player.FloorCoordinate;
                    int NPC3 = (int)(_NPCwatch3.ElapsedMilliseconds / 60000);
                    if (NPC3 > 3 && !isAFK3 && NPCDeco)
                    {
                        NPCDecorator.Paint(portrait.Left + portrait.Width * 0.26f, portrait.Top + portrait.Height * 0.6f, portrait.Width * 0.5f, portrait.Height * 0.1f, HorizontalAlign.Center);
                    }
                    NamePlayer3 = player.BattleTagAbovePortrait;
                }
            }
            TimeToNextParagon = TimeToParagonLevel(Hud.Game.Me.CurrentLevelParagon + 1, false);
        }
コード例 #9
0
        public void PaintTopInGame(ClipState clipState)
        {
            if (Hud.Render.UiHidden)
            {
                return;
            }
            if (clipState != ClipState.BeforeClip)
            {
                return;
            }
            var uiInv = Hud.Inventory.InventoryMainUiElement;

            if (uiInv.Visible)
            {
                return;
            }

            int RextY  = (int)((Hud.Window.Size.Height / 3) * 2);
            int RextX  = (int)((Hud.Window.Size.Width / 8) * 7);
            int Height = (int)(Hud.Window.Size.Height / 3);
            int Width  = (int)(Hud.Window.Size.Width / 8);

            if (Hud.Window.CursorInsideRect(RextX, RextY, Width, Height))
            {
                return;
            }


            string TotalTime         = ToReadableTime(Hud.Tracker.CurrentAccountTotal.ElapsedMilliseconds);
            string TodayTime         = ToReadableTime(Hud.Tracker.CurrentAccountToday.ElapsedMilliseconds);
            string SessionTime       = ToReadableTime(Hud.Tracker.Session.ElapsedMilliseconds);
            string TotalTimePlayed   = ToReadableTime(Hud.Tracker.CurrentAccountTotal.PlayElapsedMilliseconds);
            string TodayTimePlayed   = ToReadableTime(Hud.Tracker.CurrentAccountToday.PlayElapsedMilliseconds);
            string SessionTimePlayed = ToReadableTime(Hud.Tracker.Session.PlayElapsedMilliseconds);
            string TotalTimeTown     = ToReadableTime(Hud.Tracker.CurrentAccountTotal.TownElapsedMilliseconds);
            string TodayTimeTown     = ToReadableTime(Hud.Tracker.CurrentAccountToday.TownElapsedMilliseconds);
            string SessionTimeTown   = ToReadableTime(Hud.Tracker.Session.TownElapsedMilliseconds);


            double TotalGainedExperience          = Hud.Tracker.CurrentAccountTotal.GainedExperience;
            double TotalGainedExperiencePerHour   = Hud.Tracker.CurrentAccountTotal.GainedExperiencePerHourPlay;
            double TodayGainedExperience          = Hud.Tracker.CurrentAccountToday.GainedExperience;
            double TodayGainedExperiencePerHour   = Hud.Tracker.CurrentAccountToday.GainedExperiencePerHourPlay;
            double SessionGainedExperience        = Hud.Tracker.Session.GainedExperience;
            double SessionGainedExperiencePerHour = Hud.Tracker.Session.GainedExperiencePerHourPlay;

            long   TotalMonsterKill          = Hud.Tracker.CurrentAccountTotal.MonsterKill;
            double TotalMonsterKillPerHour   = Hud.Tracker.CurrentAccountTotal.MonsterKillPerHour;
            long   TodayMonsterKill          = Hud.Tracker.CurrentAccountToday.MonsterKill;
            double TodayMonsterKillPerHour   = Hud.Tracker.CurrentAccountToday.MonsterKillPerHour;
            long   SessionMonsterKill        = Hud.Tracker.Session.MonsterKill;
            double SessionMonsterKillPerHour = Hud.Tracker.Session.MonsterKillPerHour;

            long   TotalEliteKill          = Hud.Tracker.CurrentAccountTotal.EliteKill;
            double TotalEliteKillPerHour   = Hud.Tracker.CurrentAccountTotal.EliteKillPerHour;
            long   TodayEliteKill          = Hud.Tracker.CurrentAccountToday.EliteKill;
            double TodayEliteKillPerHour   = Hud.Tracker.CurrentAccountToday.EliteKillPerHour;
            long   SessionEliteKill        = Hud.Tracker.Session.EliteKill;
            double SessionEliteKillPerHour = Hud.Tracker.Session.EliteKillPerHour;

            long   TotalDropAll          = Hud.Tracker.CurrentAccountTotal.DropAll;
            double TotalDropAllPerHour   = Hud.Tracker.CurrentAccountTotal.DropAllPerHour;
            long   TodayDropAll          = Hud.Tracker.CurrentAccountToday.DropAll;
            double TodayDropAllPerHour   = Hud.Tracker.CurrentAccountToday.DropAllPerHour;
            long   SessionDropAll        = Hud.Tracker.Session.DropAll;
            double SessionDropAllPerHour = Hud.Tracker.Session.DropAllPerHour;

            long   TotalWhite          = Hud.Tracker.CurrentAccountTotal.DropWhite;
            double TotalWhitePerHour   = Hud.Tracker.CurrentAccountTotal.DropWhitePerHour;
            long   TodayWhite          = Hud.Tracker.CurrentAccountToday.DropWhite;
            double TodayWhitePerHour   = Hud.Tracker.CurrentAccountToday.DropWhitePerHour;
            long   SessionWhite        = Hud.Tracker.Session.DropWhite;
            double SessionWhitePerHour = Hud.Tracker.Session.DropWhitePerHour;

            long   TotalMagic          = Hud.Tracker.CurrentAccountTotal.DropMagic;
            double TotalMagicPerHour   = Hud.Tracker.CurrentAccountTotal.DropMagicPerHour;
            long   TodayMagic          = Hud.Tracker.CurrentAccountToday.DropMagic;
            double TodayMagicPerHour   = Hud.Tracker.CurrentAccountToday.DropMagicPerHour;
            long   SessionMagic        = Hud.Tracker.Session.DropMagic;
            double SessionMagicPerHour = Hud.Tracker.Session.DropMagicPerHour;

            long   TotalRare          = Hud.Tracker.CurrentAccountTotal.DropRare;
            double TotalRarePerHour   = Hud.Tracker.CurrentAccountTotal.DropRarePerHour;
            long   TodayRare          = Hud.Tracker.CurrentAccountToday.DropRare;
            double TodayRarePerHour   = Hud.Tracker.CurrentAccountToday.DropRarePerHour;
            long   SessionRare        = Hud.Tracker.Session.DropRare;
            double SessionRarePerHour = Hud.Tracker.Session.DropRarePerHour;

            long   TotalLegendary          = Hud.Tracker.CurrentAccountTotal.DropLegendary;
            double TotalLegendaryPerHour   = Hud.Tracker.CurrentAccountTotal.DropLegendaryPerHour;
            long   TodayLegendary          = Hud.Tracker.CurrentAccountToday.DropLegendary;
            double TodayLegendaryPerHour   = Hud.Tracker.CurrentAccountToday.DropLegendaryPerHour;
            long   SessionLegendary        = Hud.Tracker.Session.DropLegendary;
            double SessionLegendaryPerHour = Hud.Tracker.Session.DropLegendaryPerHour;

            long   TotalAncient          = Hud.Tracker.CurrentAccountTotal.DropAncient;
            double TotalAncientPerHour   = Hud.Tracker.CurrentAccountTotal.DropAncientPerHour;
            long   TodayAncient          = Hud.Tracker.CurrentAccountToday.DropAncient;
            double TodayAncientPerHour   = Hud.Tracker.CurrentAccountToday.DropAncientPerHour;
            long   SessionAncient        = Hud.Tracker.Session.DropAncient;
            double SessionAncientPerHour = Hud.Tracker.Session.DropAncientPerHour;

            long   TotalPrimal          = Hud.Tracker.CurrentAccountTotal.DropPrimalAncient;
            double TotalPrimalPerHour   = Hud.Tracker.CurrentAccountTotal.DropPrimalAncientPerHour;
            long   TodayPrimal          = Hud.Tracker.CurrentAccountToday.DropPrimalAncient;
            double TodayPrimalPerHour   = Hud.Tracker.CurrentAccountToday.DropPrimalAncientPerHour;
            long   SessionPrimal        = Hud.Tracker.Session.DropPrimalAncient;
            double SessionPrimalPerHour = Hud.Tracker.Session.DropPrimalAncientPerHour;

            long   TotalDropGold            = Hud.Tracker.CurrentAccountTotal.DropGold; //always 0
            long   TotalGainedGold          = Hud.Tracker.CurrentAccountTotal.GainedGold;
            double TotalGainedGoldPerHour   = Hud.Tracker.CurrentAccountTotal.GainedGoldPerHour;
            long   TodayDropGold            = Hud.Tracker.CurrentAccountToday.DropGold; //always 0
            long   TodayGainedGold          = Hud.Tracker.CurrentAccountToday.GainedGold;
            double TodayGainedGoldPerHour   = Hud.Tracker.CurrentAccountToday.GainedGoldPerHour;
            long   SessionDropGold          = Hud.Tracker.Session.DropGold; //always 0
            long   SessionGainedGold        = Hud.Tracker.Session.GainedGold;
            double SessionGainedGoldPerHour = Hud.Tracker.Session.GainedGoldPerHour;

            long   TotalDeath          = Hud.Tracker.CurrentAccountTotal.Death;
            double TotalDeathPerHour   = Hud.Tracker.CurrentAccountTotal.DeathPerHour;
            long   TodayDeath          = Hud.Tracker.CurrentAccountToday.Death;
            double TodayDeathPerHour   = Hud.Tracker.CurrentAccountToday.DeathPerHour;
            long   SessionDeath        = Hud.Tracker.Session.Death;
            double SessionDeathPerHour = Hud.Tracker.Session.DeathPerHour;

            long   TotalDropBloodShard          = Hud.Tracker.CurrentAccountTotal.DropBloodShard;
            double TotalDropBloodShardPerHour   = Hud.Tracker.CurrentAccountTotal.DropBloodShardPerHour;
            long   TodayDropBloodShard          = Hud.Tracker.CurrentAccountToday.DropBloodShard;
            double TodayDropBloodShardPerHour   = Hud.Tracker.CurrentAccountToday.DropBloodShardPerHour;
            long   SessionDropBloodShard        = Hud.Tracker.Session.DropBloodShard;
            double SessionDropBloodShardPerHour = Hud.Tracker.Session.DropBloodShardPerHour;


            if (_Timer.ElapsedMilliseconds > 6000)
            {
                ++WhichStat;
                _Timer.Restart();
            }

            if (WhichStat > 15)
            {
                WhichStat = 1;
            }


            switch (WhichStat)
            {
            case 1:
                if (ExperienceStats)
                {
                    CurrentStats = "━━━━━ Experience Gained ━━━━━" + Environment.NewLine +
                                   "Run: " + ValueToString(SessionGainedExperience, ValueFormat.ShortNumber) + " (" + ValueToString(SessionGainedExperiencePerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Today: " + ValueToString(TodayGainedExperience, ValueFormat.ShortNumber) + " (" + ValueToString(TodayGainedExperiencePerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Total: " + ValueToString(TotalGainedExperience, ValueFormat.ShortNumber) + " (" + ValueToString(TotalGainedExperiencePerHour, ValueFormat.ShortNumber) + "/h)";
                    break;
                }
                else
                {
                    ++WhichStat;
                    break;
                }

            case 2:
                if (MonsterKillStats)
                {
                    CurrentStats = "━━━━━ Monster Killed ━━━━━" + Environment.NewLine +
                                   "Run: " + ValueToString(SessionMonsterKill, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(SessionMonsterKillPerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Today: " + ValueToString(TodayMonsterKill, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(TodayMonsterKillPerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Total: " + ValueToString(TotalMonsterKill, ValueFormat.ShortNumber) + " (" + ValueToString(TotalMonsterKillPerHour, ValueFormat.ShortNumber) + "/h)";
                    break;
                }
                else
                {
                    ++WhichStat;
                    break;
                }

            case 3:
                if (EliteKillStats)
                {
                    CurrentStats = "━━━━━ Elite Killed ━━━━━" + Environment.NewLine +
                                   "Run: " + ValueToString(SessionEliteKill, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(SessionEliteKillPerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Today: " + ValueToString(TodayEliteKill, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(TodayEliteKillPerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Total: " + ValueToString(TotalEliteKill, ValueFormat.ShortNumber) + " (" + ValueToString(TotalEliteKillPerHour, ValueFormat.ShortNumber) + "/h)";
                    break;
                }
                else
                {
                    ++WhichStat;
                    break;
                }

            case 4:
                if (ItemDropStats)
                {
                    CurrentStats = "━━━━━ Item Drop ━━━━━" + Environment.NewLine +
                                   "Run: " + ValueToString(SessionDropAll, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(SessionDropAllPerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Today: " + ValueToString(TodayDropAll, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(TodayDropAllPerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Total: " + ValueToString(TotalDropAll, ValueFormat.ShortNumber) + " (" + ValueToString(TotalDropAllPerHour, ValueFormat.ShortNumber) + "/h)";
                    break;
                }
                else
                {
                    ++WhichStat;
                    break;
                }

            case 5:
                if (WhiteDropStats)
                {
                    CurrentStats = "━━━━━ White Drop ━━━━━" + Environment.NewLine +
                                   "Run: " + ValueToString(SessionWhite, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(SessionWhitePerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Today: " + ValueToString(TodayWhite, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(TodayWhitePerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Total: " + ValueToString(TotalWhite, ValueFormat.ShortNumber) + " (" + ValueToString(TotalWhitePerHour, ValueFormat.ShortNumber) + "/h)";
                    break;
                }
                else
                {
                    ++WhichStat;
                    break;
                }

            case 6:
                if (MagicDropStats)
                {
                    CurrentStats = "━━━━━ Magic Drop ━━━━━" + Environment.NewLine +
                                   "Run: " + ValueToString(SessionMagic, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(SessionMagicPerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Today: " + ValueToString(TodayMagic, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(TodayMagicPerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Total: " + ValueToString(TotalMagic, ValueFormat.ShortNumber) + " (" + ValueToString(TotalMagicPerHour, ValueFormat.ShortNumber) + "/h)";
                    break;
                }
                else
                {
                    ++WhichStat;
                    break;
                }

            case 7:
                if (RareDropStats)
                {
                    CurrentStats = "━━━━━ Rare Drop ━━━━━" + Environment.NewLine +
                                   "Run: " + ValueToString(SessionRare, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(SessionRarePerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Today: " + ValueToString(TodayRare, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(TodayRarePerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Total: " + ValueToString(TotalRare, ValueFormat.ShortNumber) + " (" + ValueToString(TotalRarePerHour, ValueFormat.ShortNumber) + "/h)";
                    break;
                }
                else
                {
                    ++WhichStat;
                    break;
                }

            case 8:
                if (LegendaryDropStats)
                {
                    CurrentStats = "━━━━━ Legendary Drop ━━━━━" + Environment.NewLine +
                                   "Run: " + ValueToString(SessionLegendary, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(SessionLegendaryPerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Today: " + ValueToString(TodayLegendary, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(TodayLegendaryPerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Total: " + ValueToString(TotalLegendary, ValueFormat.ShortNumber) + " (" + ValueToString(TotalLegendaryPerHour, ValueFormat.ShortNumber) + "/h)";
                    break;
                }
                else
                {
                    ++WhichStat;
                    break;
                }

            case 9:
                if (AncientDropStats)
                {
                    CurrentStats = "━━━━━ Ancient Drop ━━━━━" + Environment.NewLine +
                                   "Run: " + ValueToString(SessionAncient, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(SessionAncientPerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Today: " + ValueToString(TodayAncient, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(TodayAncientPerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Total: " + ValueToString(TotalAncient, ValueFormat.ShortNumber) + " (" + ValueToString(TotalAncientPerHour, ValueFormat.ShortNumber) + "/h)";
                    break;
                }
                else
                {
                    ++WhichStat;
                    break;
                }

            case 10:
                if (PrimalDropStats)
                {
                    CurrentStats = "━━━━━ Primal Ancient Drop ━━━━━" + Environment.NewLine +
                                   "Run: " + ValueToString(SessionPrimal, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(SessionPrimalPerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Today: " + ValueToString(TodayPrimal, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(TodayPrimalPerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Total: " + ValueToString(TotalPrimal, ValueFormat.ShortNumber) + " (" + ValueToString(TotalPrimalPerHour, ValueFormat.ShortNumber) + "/h)";
                    break;
                }
                else
                {
                    ++WhichStat;
                    break;
                }

            case 11:
            case 12:
                if (GameTimeStats)
                {
                    CurrentStats = "━━━━━ Time in Game ━━━━━" + Environment.NewLine +
                                   "Run: " + SessionTime + Environment.NewLine +
                                   "         (" + SessionTimePlayed + " played)" + Environment.NewLine +
                                   "Today: " + TodayTime + Environment.NewLine +
                                   "           (" + TodayTimePlayed + " played)" + Environment.NewLine +
                                   "Total: " + TotalTime + Environment.NewLine +
                                   "          (" + TotalTimePlayed + " played)";
                    break;
                }
                else
                {
                    WhichStat += 2;
                    break;
                }

            case 13:
                if (GoldStats)
                {
                    CurrentStats = "━━━━━ Gold ━━━━━" + Environment.NewLine +
                                   "Run: " + ValueToString(SessionGainedGold, ValueFormat.ShortNumber) + " (" + ValueToString(SessionGainedGoldPerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Today: " + ValueToString(TodayGainedGold, ValueFormat.ShortNumber) + " (" + ValueToString(TodayGainedGoldPerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Total: " + ValueToString(TotalGainedGold, ValueFormat.ShortNumber) + " (" + ValueToString(TotalGainedGoldPerHour, ValueFormat.ShortNumber) + "/h)";
                    break;
                }
                else
                {
                    ++WhichStat;
                    break;
                }

            case 14:
                if (DeathStats)
                {
                    CurrentStats = "━━━━━ Death ━━━━━" + Environment.NewLine +
                                   "Run: " + ValueToString(SessionDeath, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(SessionDeathPerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Today: " + ValueToString(TodayDeath, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(TodayDeathPerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Total: " + ValueToString(TotalDeath, ValueFormat.ShortNumber) + " (" + ValueToString(TotalDeathPerHour, ValueFormat.ShortNumber) + "/h)";
                    break;
                }
                else
                {
                    ++WhichStat;
                    break;
                }

            case 15:
                if (BloodShardStats)
                {
                    CurrentStats = "━━━━━ BloodShard Drop ━━━━━" + Environment.NewLine +
                                   "Run: " + ValueToString(SessionDropBloodShard, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(SessionDropBloodShardPerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Today: " + ValueToString(TodayDropBloodShard, ValueFormat.NormalNumberNoDecimal) + " (" + ValueToString(TodayDropBloodShardPerHour, ValueFormat.ShortNumber) + "/h)" + Environment.NewLine +
                                   "Total: " + ValueToString(TotalDropBloodShard, ValueFormat.ShortNumber) + " (" + ValueToString(TotalDropBloodShardPerHour, ValueFormat.ShortNumber) + "/h)";
                    break;
                }
                else
                {
                    WhichStat = 1;
                    break;
                }
            }



            CurrentStatDecorator.Paint(RextX, RextY, Width, Height, HorizontalAlign.Left);



            /*
             *
             * HorizontalTopLabelList, VerticalTopLabelList ?
             *
             * CurrentAccountLastMonth
             * CurrentAccountLastWeek
             * CurrentAccountYesterday
             *
             * long DamageDealtAll { get; }
             * long DamageDealtCrit { get; }
             * long DamageTaken { get; }
             * long Healing { get; }
             * double WalkYards { get; }
             *
             * double GainedExperiencePerHourFull { get; }
             *
             *
             * double DamageDealtAllPerSecond { get; }
             * double DamageDealtCritPerSecond { get; }
             * double DamageTakenPerSecond { get; }
             * double HealingPerSecond { get; }
             *
             * double MonsterKillPerLegendary { get; }
             * double EliteKillPerLegendary { get; }
             */
        }