LevelProgressLabel.cs rev 1372

// LevelProgressLabel.cs "$Revision: 1372 $" "$Date: 2019-03-13 18:11:31 +0200 (ke, 13 maalis 2019) $"
using SharpDX;
using System;
using System.Text;
using Turbo.Plugins;
using Turbo.Plugins.Default;

namespace Turbo.plugins.JarJar.DefaultUI
{
    class LevelProgressLabel : BasePlugin, IInGameTopPainter
    {
        public IFont textFont { get; set; }
        public float offsetX { get; set; } = 1.00f;             // Relative to player portrait Width from Top.
        public float offsetY { get; set; } = 0.70f;             // Relative to portrait Height from Left.

        public Func<IController, System.Drawing.PointF> LabelPosFunc { get; set; }  // Override label positioning logic if needed.

        public bool logRiftCompletion { get; set; } = false;    // Logs kill xp and RG bonus xp (rift completed or arrive to town).
        public bool logDebugData { get; set; } = false;         // Debug logging.

        string previousBuilder = "";
        StringBuilder logBuilder = new StringBuilder();
        StringBuilder labelBuilder = new StringBuilder();

        public LevelProgressLabel() { Enabled = true; Order = 51; }     // Just after RiftTimeLogger

        public override void Load(IController hud)
        {
            base.Load(hud);

            var textColor = Color.DodgerBlue;
            textFont = hud.Render.CreateFont("consolas", 9f, textColor.A, textColor.R, textColor.G, textColor.B, true, false, 220, 32, 32, 32, true);

            LabelPosFunc = (thud) => {
                var portraitRect = thud.Game.Me.PortraitUiElement.Rectangle;
                float posX = portraitRect.Left + portraitRect.Width * offsetX;
                float posY = portraitRect.Top + portraitRect.Height * offsetY;
                return new System.Drawing.PointF(posX, posY);
            };
        }

        SpecialArea currentArea = SpecialArea.PvP;
        bool isInTown = false;
        bool riftRunning = false;
        bool riftCompleted = true;
        bool logRunStats = false;
        double prevRiftPercentage = 0;
        uint savedLevelParagon;
        long savedParagonTotalExp;
        long savedMobKillsExp;
        long finalRGKillsExp;
        // If we got paragon levels, save prev values.
        long prevLevelParagonTotalExp;
        uint firstOfPreviousParagons;
        uint LastOfPreviousParagons;

        void resetStats()
        {
            var game = Hud.Game;
            var player = game.Me;
            prevRiftPercentage = game.RiftPercentage;
            savedParagonTotalExp = player.ParagonTotalExp;
            savedMobKillsExp = 0;
            finalRGKillsExp = 0;
            prevLevelParagonTotalExp = 0;
            firstOfPreviousParagons = 0;
            LastOfPreviousParagons = 0;
        }

        public void PaintTopInGame(ClipState clipState)
        {
            if (clipState != ClipState.BeforeClip) return;
            if (Hud.Render.UiHidden) return;
            if ((Hud.Game.MapMode == MapMode.WaypointMap) || (Hud.Game.MapMode == MapMode.ActMap) || (Hud.Game.MapMode == MapMode.Map)) return;
            var game = Hud.Game;
            var player = game.Me;
            // Sanity checks as changing level causes sometimes these to be temporarily zero.
            if (player.ParagonTotalExp == 0 || player.CurrentLevelParagon == 0) return;

            if (currentArea != game.SpecialArea || isInTown != game.IsInTown)
            {
                if (logDebugData) logNewArea();
                if ((currentArea == SpecialArea.None || currentArea == SpecialArea.PvP) &&
                    (game.SpecialArea == SpecialArea.Rift || game.SpecialArea == SpecialArea.GreaterRift || game.SpecialArea == SpecialArea.ChallengeRift))
                {
                    // Start rift.
                    if (!riftRunning)
                    {
                        riftRunning = true;
                        if (riftCompleted)
                        {
                            resetStats();
                            riftCompleted = false;
                        }
                        if (logDebugData) logRiftStart();
                    }
                }
                if (game.SpecialArea == SpecialArea.None &&
                    (currentArea == SpecialArea.Rift || currentArea == SpecialArea.GreaterRift || currentArea == SpecialArea.ChallengeRift))
                {
                    // Return from rift.
                    riftRunning = false;
                    savedMobKillsExp = player.ParagonTotalExp - savedParagonTotalExp;
                    if (logDebugData) logRiftEnd();
                }
                if (game.IsInTown)
                {
                    if (!isInTown)
                    {
                        // Enter town
                        if (savedParagonTotalExp == 0)
                        {
                            // First time in town after new game.
                            savedParagonTotalExp = player.ParagonTotalExp;
                            savedLevelParagon = player.CurrentLevelParagon;
                        }
                        else if (game.RiftPercentage == 0)
                        {
                            // We return from other gameplay level (than rift).
                            if (logRiftCompletion) logRunStats = true;
                        }
                        if (logDebugData) logEnterTown();
                    }
                }
                else
                {
                    if (isInTown)
                    {
                        // Leave town
                        if (logDebugData) logExitTown();
                        if (!riftRunning)
                        {
                            // When we leave, reset stats for next run.
                            resetStats();
                        }
                    }
                }
                currentArea = game.SpecialArea;
            }
            if (isInTown != game.IsInTown)
            {
                isInTown = game.IsInTown;   // Current town state.
            }
            if (savedLevelParagon != player.CurrentLevelParagon)
            {
                // Save current progress for pervious level and start stats for new paragon level.
                // - if we get new paragon level during rift, it is "impossible" to calculate xp distribution between paragon levels :-(
                prevLevelParagonTotalExp += player.ParagonTotalExp - savedParagonTotalExp;
                if (firstOfPreviousParagons == 0)
                {
                    firstOfPreviousParagons = savedLevelParagon;
                    LastOfPreviousParagons = savedLevelParagon;
                }
                else
                {
                    LastOfPreviousParagons = savedLevelParagon;
                }
                // Restart paragon exp stats!
                savedParagonTotalExp = player.ParagonTotalExp;
                savedMobKillsExp = 0;
                if (logDebugData) logParagonChanged();
                savedLevelParagon = player.CurrentLevelParagon;
            }
            if (!isInTown)
            {
                // Calculate mob kill exp "realtime".
                if (player.ParagonTotalExp > (savedParagonTotalExp + savedMobKillsExp))
                {
                    savedMobKillsExp = player.ParagonTotalExp - savedParagonTotalExp;
                }
            }
            if (prevRiftPercentage != game.RiftPercentage)
            {
                if (game.RiftPercentage == 0 && prevRiftPercentage > 0)
                {
                    // Rift guardian kill experience bonus has been awarded to us now.
                    riftCompleted = true;
                    if (logRiftCompletion) logRunStats = true;
                    finalRGKillsExp = player.ParagonTotalExp - savedParagonTotalExp - savedMobKillsExp;
                    if (logDebugData) logBonusXpReward();
                }
                prevRiftPercentage = game.RiftPercentage;
            }
            if (logBuilder.Length > 0)
            {
                logData();
                logBuilder.Clear();
            }
            // Progression label.
            // - flash 100% rift progression until it is collected!
            string percentLabel =
                game.RiftPercentage <= 0 ? "":
                game.RiftPercentage < 100 ? string.Format(" : {0:0}%", game.RiftPercentage)
                : ((Hud.Game.CurrentGameTick / 60) % 2 == 0 ? "" : " : 100% Bonus");
            labelBuilder
                .AppendFormat("{0,-17} {1}", player.SnoArea.NameEnglish, percentLabel)
                .AppendLine()
                .AppendFormat("Level done  {0,10}  needs {1}",
                    percent(player.ParagonExpInThisLevel, player.ParagonExpToNextLevel),
                    ValueToString(player.ParagonExpToNextLevel - player.ParagonExpInThisLevel, ValueFormat.LongNumber))
                .AppendLine();
            bool splitXp = prevLevelParagonTotalExp > 0;    // Impossible to allocate XP between two levels properly :-(
            if (splitXp)
                labelBuilder
                .AppendFormat("Prev  XP {0,7} (P {1})", ValueToString(prevLevelParagonTotalExp, ValueFormat.LongNumber),
                    firstOfPreviousParagons == LastOfPreviousParagons ? firstOfPreviousParagons.ToString() : string.Format("{0}-{1}", firstOfPreviousParagons, LastOfPreviousParagons))
                .AppendLine();
            if (savedMobKillsExp > 0)
                labelBuilder
                .AppendFormat("Kill  XP {0,7}{1}", ValueToString(savedMobKillsExp, ValueFormat.LongNumber), splitXp ? "" : percent(savedMobKillsExp, player.ParagonExpToNextLevel))
                .AppendLine();
            if (finalRGKillsExp > 0)
            {
                long totalExp = savedMobKillsExp + finalRGKillsExp;
                labelBuilder
                .AppendFormat("Bonus XP {0,7}{1}", ValueToString(finalRGKillsExp, ValueFormat.LongNumber), splitXp ? "" : percent(finalRGKillsExp, player.ParagonExpToNextLevel))
                .AppendLine()
                .AppendFormat("Total XP {0,7}{1}", ValueToString(totalExp, ValueFormat.LongNumber), splitXp ? "" : percent(totalExp, player.ParagonExpToNextLevel))
                .AppendLine();
            }
            var layout = textFont.GetTextLayout(labelBuilder.ToString());
            var pos = LabelPosFunc(Hud);
            textFont.DrawText(layout, pos.X,  pos.Y);
            labelBuilder.Clear();
            if (logRunStats)
            {
                long kills = prevLevelParagonTotalExp + savedMobKillsExp;
                if (kills > 0) Hud.Debug(string.Format("Kill: {0,7} XP", ValueToString(kills, ValueFormat.LongNumber)));
                if (finalRGKillsExp > 0) Hud.Debug(string.Format("RG:   {0,7} XP", ValueToString(finalRGKillsExp, ValueFormat.LongNumber)));
                logRunStats = false;
            }
        }

        string percent(double value, double total)
        {
            if (total > 0)
            {
                double result = value / total * 100d;
                if (result < 0.1) return string.Format(" {0:0.00}%", result);
                return string.Format(" {0,4:0.0}%", result);
            }
            return "";
        }

        void logData()
        {
            var game = Hud.Game;
            var player = game.Me;
            string area = string.Format("{0}: {1}\r\n",
                player.InGreaterRift ? player.InGreaterRiftRank.ToString() : game.GameDifficulty.ToString().ToUpper(),
                player.SnoArea.NameEnglish
                );
            string temp = logBuilder
                .Insert(0, area)
                .ToString();
            if (temp != previousBuilder)
            {
                previousBuilder = temp;
                Hud.Debug("\r\n" + temp);
            }
        }

        void logNewArea()
        {
            var game = Hud.Game;
            var player = game.Me;
            logBuilder
            .AppendFormat("CHANGE area {0} -> {1} : {2}", currentArea, game.SpecialArea, player.SnoArea.NameEnglish)
            .AppendLine();
        }

        void logRiftStart()
        {
            var game = Hud.Game;
            var player = game.Me;
            logBuilder
            .AppendFormat("rift  {0,20}", "START")
            .AppendLine()
            .AppendFormat("exp   {0,20}", ValueToString(player.ParagonTotalExp, ValueFormat.NormalNumber))
            .AppendLine()
            .AppendFormat("this  {0,20}{1}", ValueToString(player.ParagonExpInThisLevel, ValueFormat.NormalNumber), percent(player.ParagonExpInThisLevel, player.ParagonExpToNextLevel))
            .AppendLine()
            .AppendFormat("next  {0,20}", ValueToString(player.ParagonExpToNextLevel, ValueFormat.NormalNumber))
            .AppendLine();
        }

        void logRiftEnd()
        {
            var game = Hud.Game;
            var player = game.Me;
            logBuilder
                .AppendFormat("rift  {0,20}", "END")
                .AppendLine()
                .AppendFormat("exp   {0,20}", ValueToString(player.ParagonTotalExp, ValueFormat.NormalNumber))
                .AppendLine()
                .AppendFormat("this  {0,20}{1}", ValueToString(player.ParagonExpInThisLevel, ValueFormat.NormalNumber), percent(player.ParagonExpInThisLevel, player.ParagonExpToNextLevel))
                .AppendLine()
                .AppendFormat("next  {0,20}", ValueToString(player.ParagonExpToNextLevel, ValueFormat.NormalNumber))
                .AppendLine()
                .AppendFormat("saved {0,20}", ValueToString(savedParagonTotalExp, ValueFormat.NormalNumber))
                .AppendLine()
                .AppendFormat("kills {0,20}", ValueToString(savedMobKillsExp, ValueFormat.NormalNumber))
                .AppendLine();
            if (logDebugData && prevLevelParagonTotalExp > 0)
                logBuilder
                .AppendFormat("p-lvl {0,20} {1}-{2}", ValueToString(prevLevelParagonTotalExp, ValueFormat.NormalNumber), firstOfPreviousParagons, LastOfPreviousParagons)
                .AppendLine();
        }

        void logEnterTown()
        {
            var game = Hud.Game;
            var player = game.Me;
            logBuilder
            .AppendFormat("town  {0,20} {1}", "ENTER", riftRunning ? "riftRunning" : "")
            .AppendLine()
            .AppendFormat("exp   {0,20}", ValueToString(player.ParagonTotalExp, ValueFormat.NormalNumber))
            .AppendLine()
            .AppendFormat("this  {0,20}{1}", ValueToString(player.ParagonExpInThisLevel, ValueFormat.NormalNumber), percent(player.ParagonExpInThisLevel, player.ParagonExpToNextLevel))
            .AppendLine()
            .AppendFormat("next  {0,20}", ValueToString(player.ParagonExpToNextLevel, ValueFormat.NormalNumber))
            .AppendLine()
            .AppendFormat("saved {0,20}", ValueToString(savedParagonTotalExp, ValueFormat.NormalNumber))
            .AppendLine()
            .AppendFormat("kills {0,20}", ValueToString(savedMobKillsExp, ValueFormat.NormalNumber))
            .AppendLine();
            if (logDebugData && prevLevelParagonTotalExp > 0)
                logBuilder
                .AppendFormat("p-lvl {0,20} {1}-{2}", ValueToString(prevLevelParagonTotalExp, ValueFormat.NormalNumber), firstOfPreviousParagons, LastOfPreviousParagons)
                .AppendLine();
        }

        void logExitTown()
        {
            var game = Hud.Game;
            var player = game.Me;
            logBuilder
            .AppendFormat("town  {0,20} {1}", "EXIT", riftRunning ? "riftRunning" : "")
            .AppendLine()
            .AppendFormat("exp   {0,20}", ValueToString(player.ParagonTotalExp, ValueFormat.NormalNumber))
            .AppendLine()
            .AppendFormat("this  {0,20}{1}", ValueToString(player.ParagonExpInThisLevel, ValueFormat.NormalNumber), percent(player.ParagonExpInThisLevel, player.ParagonExpToNextLevel))
            .AppendLine()
            .AppendFormat("next  {0,20}", ValueToString(player.ParagonExpToNextLevel, ValueFormat.NormalNumber))
            .AppendLine()
            .AppendFormat("saved {0,20}", ValueToString(savedParagonTotalExp, ValueFormat.NormalNumber))
            .AppendLine()
            .AppendFormat("kills {0,20}", ValueToString(savedMobKillsExp, ValueFormat.NormalNumber))
            .AppendLine();
            if (logDebugData && prevLevelParagonTotalExp > 0)
                logBuilder
                .AppendFormat("p-lvl {0,20} {1}-{2}", ValueToString(prevLevelParagonTotalExp, ValueFormat.NormalNumber), firstOfPreviousParagons, LastOfPreviousParagons)
                .AppendLine();
        }

        void logParagonChanged()
        {
            var game = Hud.Game;
            var player = game.Me;
            logBuilder
            .AppendFormat("new   {0,20} {1} -> {2}", "PARAGON", savedLevelParagon, player.CurrentLevelParagon)
            .AppendLine()
            .AppendFormat("exp   {0,20}", ValueToString(player.ParagonTotalExp, ValueFormat.NormalNumber))
            .AppendLine()
            .AppendFormat("this  {0,20}{1}", ValueToString(player.ParagonExpInThisLevel, ValueFormat.NormalNumber), percent(player.ParagonExpInThisLevel, player.ParagonExpToNextLevel))
            .AppendLine()
            .AppendFormat("next  {0,20}", ValueToString(player.ParagonExpToNextLevel, ValueFormat.NormalNumber))
            .AppendLine()
            .AppendFormat("p-lvl {0,20} {1}-{2}", ValueToString(prevLevelParagonTotalExp, ValueFormat.NormalNumber), firstOfPreviousParagons, LastOfPreviousParagons)
            .AppendLine();
        }

        void logBonusXpReward()
        {
            var game = Hud.Game;
            var player = game.Me;
            long deltaTotXp = player.ParagonTotalExp - savedParagonTotalExp;
            long totalExp = savedMobKillsExp + finalRGKillsExp;
            logBuilder
                .Append("CHANGE EXP REWARD")
                .AppendLine()
                .AppendFormat("exp   {0,20}", ValueToString(player.ParagonTotalExp, ValueFormat.NormalNumber))
                .AppendLine()
                .AppendFormat("this  {0,20}{1}", ValueToString(player.ParagonExpInThisLevel, ValueFormat.NormalNumber), percent(player.ParagonExpInThisLevel, player.ParagonExpToNextLevel))
                .AppendLine()
                .AppendFormat("next  {0,20}", ValueToString(player.ParagonExpToNextLevel, ValueFormat.NormalNumber))
                .AppendLine()
                .AppendFormat("saved {0,20}", ValueToString(savedParagonTotalExp, ValueFormat.NormalNumber))
                .AppendLine()
                .AppendFormat("delta {0,20}{1}", ValueToString(deltaTotXp, ValueFormat.NormalNumber), percent(deltaTotXp, player.ParagonExpToNextLevel))
                .AppendLine()
                .AppendFormat("kills {0,20}{1}", ValueToString(savedMobKillsExp, ValueFormat.NormalNumber), percent(savedMobKillsExp, player.ParagonExpToNextLevel))
                .AppendLine()
                .AppendFormat("boss  {0,20}{1}", ValueToString(finalRGKillsExp, ValueFormat.NormalNumber), percent(finalRGKillsExp, player.ParagonExpToNextLevel))
                .AppendLine()
                .AppendFormat("total {0,20}{1}", ValueToString(totalExp, ValueFormat.NormalNumber), percent(totalExp, player.ParagonExpToNextLevel))
                .AppendLine();
            if (prevLevelParagonTotalExp > 0)
                logBuilder
                .AppendFormat("p-lvl {0,20} {1}-{2}", ValueToString(prevLevelParagonTotalExp, ValueFormat.NormalNumber), firstOfPreviousParagons, LastOfPreviousParagons)
                .AppendLine();
        }
    }
}