diff --git a/HealthBar.cs b/HealthBar.cs new file mode 100644 index 0000000..f8872f1 --- /dev/null +++ b/HealthBar.cs @@ -0,0 +1,207 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using ExileCore.PoEMemory.Components; +using ExileCore.PoEMemory.MemoryObjects; +using ExileCore.Shared.Cache; +using ExileCore.Shared.Enums; +using SharpDX; + +namespace HealthBars +{ + public class DebuffPanelConfig + { + public Dictionary Bleeding { get; set; } + public Dictionary Corruption { get; set; } + public Dictionary Poisoned { get; set; } + public Dictionary Frozen { get; set; } + public Dictionary Chilled { get; set; } + public Dictionary Burning { get; set; } + public Dictionary Shocked { get; set; } + public Dictionary WeakenedSlowed { get; set; } + } + + public class HealthBar + { + private const int DPS_CHECK_TIME = 1000; + private const int DPS_FAST_CHECK_TIME = 200; + private const int DPS_POP_TIME = 2000; + private static readonly List IgnoreEntitiesList = new List {"MonsterFireTrap2", "MonsterBlastRainTrap"}; + private readonly Stopwatch dpsStopwatch = Stopwatch.StartNew(); + private readonly TimeCache _distance; + private bool _init; + private int _lastHp; + public RectangleF BackGround; + public bool CanNotDie; + public double DiedFrames = 0; + public Func IsHidden; + private bool isHostile; + private readonly Action OnHostileChange; + public bool Skip = false; + + public HealthBar(Entity entity, HealthBarsSettings settings) + { + Entity = entity; + _distance = new TimeCache(() => entity.DistancePlayer, 200); + + IsHidden = () => entity.IsHidden; + + // If ignored entity found, skip + foreach (var _entity in IgnoreEntitiesList) + { + if (entity.Path.Contains(_entity)) + return; + } + + Update(entity, settings); + + //CanNotDie = entity.GetComponent().StatDictionary.ContainsKey(GameStat.CannotDie); + CanNotDie = entity.Path.StartsWith("Metadata/Monsters/Totems/Labyrinth"); + + if (entity.HasComponent() && entity.GetComponent().Mods.Contains("MonsterConvertsOnDeath_")) + { + OnHostileChange = () => + { + if (_init) Update(Entity, settings); + }; + } + } + + public bool IsHostile + { + get + { + var entityIsHostile = Entity.IsHostile; + + if (isHostile != entityIsHostile) + { + isHostile = entityIsHostile; + OnHostileChange?.Invoke(); + } + + return entityIsHostile; + } + } + + public int MaxHp { get; private set; } + public float HpPercent { get; set; } + public float Distance => _distance.Value; + public Life Life => Entity.GetComponent(); + public Entity Entity { get; } + public UnitSettings Settings { get; private set; } + public CreatureType Type { get; private set; } + public LinkedList DpsQueue { get; } = new LinkedList(); + + public Color Color + { + get + { + if (IsHidden()) + return Color.LightGray; + + if (HpPercent <= 0.1f) + return Settings.Under10Percent; + + return Settings.Color; + } + } + + public float HpWidth { get; set; } + public float EsWidth { get; set; } + + public void Update(Entity entity, HealthBarsSettings settings) + { + if (entity.HasComponent()) + { + Type = CreatureType.Player; + Settings = settings.Players; + } + else if (entity.HasComponent()) + { + if (entity.IsHostile) + { + switch (entity.GetComponent().Rarity) + { + case MonsterRarity.White: + Type = CreatureType.Normal; + Settings = settings.NormalEnemy; + break; + + case MonsterRarity.Magic: + Type = CreatureType.Magic; + Settings = settings.MagicEnemy; + break; + + case MonsterRarity.Rare: + Settings = settings.RareEnemy; + Type = CreatureType.Rare; + break; + + case MonsterRarity.Unique: + Settings = settings.UniqueEnemy; + Type = CreatureType.Unique; + break; + default: + Settings = settings.Minions; + Type = CreatureType.Minion; + break; + } + } + else + { + Type = CreatureType.Minion; + Settings = settings.Minions; + } + } + + _lastHp = GetFullHp(); + MaxHp = Life.MaxHP; + _init = true; + } + + public bool IsShow(bool showEnemy) + { + if (Settings == null) + return false; + + return !IsHostile ? Settings.Enable.Value : Settings.Enable.Value && showEnemy && IsHostile; + } + + public void DpsRefresh() + { + var chechTime = DpsQueue.Count > 0 ? DPS_CHECK_TIME : DPS_FAST_CHECK_TIME; + + if (dpsStopwatch.ElapsedMilliseconds >= chechTime) + { + var hp = GetFullHp(); + + if (hp > -1000000 && hp < 10000000 && _lastHp != hp) + { + DpsQueue.AddFirst(-(_lastHp - hp)); + + if (DpsQueue.Count > Settings.FloatingCombatStackSize) + { + DpsQueue.RemoveLast(); + dpsStopwatch.Restart(); + } + + _lastHp = hp; + } + } + } + + public void DpsDequeue() + { + if (dpsStopwatch.ElapsedMilliseconds >= DPS_POP_TIME) + { + if (DpsQueue.Count > 0) DpsQueue.RemoveLast(); + dpsStopwatch.Restart(); + } + } + + private int GetFullHp() + { + return Life.CurHP + Life.CurES; + } + } +} diff --git a/HealthBars.cs b/HealthBars.cs new file mode 100644 index 0000000..88b325c --- /dev/null +++ b/HealthBars.cs @@ -0,0 +1,323 @@ +using System; +using System.Collections.Generic; +using System.Globalization; +using System.Linq; +using ExileCore; +using ExileCore.PoEMemory; +using ExileCore.PoEMemory.Components; +using ExileCore.PoEMemory.MemoryObjects; +using ExileCore.Shared.Cache; +using ExileCore.Shared.Enums; +using SharpDX; + +namespace HealthBars +{ + public class HealthBars : BaseSettingsPlugin + { + private Camera camera; + private bool CanTick = true; + private readonly List ElementForSkip = new List(); + + private readonly List Ignored = new List + { + "Metadata/Monsters/Daemon/SilverPoolChillDaemon", + "Metadata/Monsters/Daemon", + "Metadata/Monsters/Frog/FrogGod/SilverOrb", + "Metadata/Monsters/Frog/FrogGod/SilverPool", + "Metadata/Monsters/Labyrinth/GoddessOfJusticeMapBoss@7", + "Metadata/Monsters/Labyrinth/GoddessOfJustice@", + "Metadata/Monsters/LeagueBetrayal/MasterNinjaCop", + //Delirium Ignores + "Metadata/Monsters/LeagueAffliction/DoodadDaemons/DoodadDaemonEyes1", + "Metadata/Monsters/LeagueAffliction/DoodadDaemons/DoodadDaemonEyes2", + "Metadata/Monsters/LeagueAffliction/DoodadDaemons/DoodadDaemonEyes3", + "Metadata/Monsters/LeagueAffliction/DoodadDaemons/DoodadDaemonSpikes", + "Metadata/Monsters/LeagueAffliction/DoodadDaemons/DoodadDaemonSpikes2", + "Metadata/Monsters/LeagueAffliction/DoodadDaemons/DoodadDaemonSpikes3", + "Metadata/Monsters/LeagueAffliction/DoodadDaemons/DoodadDaemonPimple1", + "Metadata/Monsters/LeagueAffliction/DoodadDaemons/DoodadDaemonPimple2", + "Metadata/Monsters/LeagueAffliction/DoodadDaemons/DoodadDaemonPimple3", + "Metadata/Monsters/LeagueAffliction/DoodadDaemons/DoodadDaemonGoatFillet1Vanish", + "Metadata/Monsters/LeagueAffliction/DoodadDaemons/DoodadDaemonGoatFillet2Vanish" + }; + + private IngameUIElements ingameUI; + private CachedValue ingameUICheckVisible; + private Vector2 oldplayerCord; + private Entity Player; + private HealthBar PlayerBar; + private double time; + private RectangleF windowRectangle; + private Size2F windowSize; + + public override void OnLoad() + { + CanUseMultiThreading = true; + Graphics.InitImage("healthbar.png"); + } + + public override bool Initialise() + { + Player = GameController.Player; + ingameUI = GameController.IngameState.IngameUi; + PlayerBar = new HealthBar(Player, Settings); + + GameController.EntityListWrapper.PlayerUpdate += (sender, args) => + { + Player = GameController.Player; + + PlayerBar = new HealthBar(Player, Settings); + }; + + ingameUICheckVisible = new TimeCache(() => + { + windowRectangle = GameController.Window.GetWindowRectangleReal(); + windowSize = new Size2F(windowRectangle.Width / 2560, windowRectangle.Height / 1600); + camera = GameController.Game.IngameState.Camera; + + return ingameUI.BetrayalWindow.IsVisibleLocal || ingameUI.SellWindow.IsVisibleLocal || + ingameUI.DelveWindow.IsVisibleLocal || ingameUI.IncursionWindow.IsVisibleLocal || + ingameUI.UnveilWindow.IsVisibleLocal || ingameUI.TreePanel.IsVisibleLocal || ingameUI.AtlasPanel.IsVisibleLocal || + ingameUI.CraftBench.IsVisibleLocal; + }, 250); + + return true; + } + + public override void AreaChange(AreaInstance area) + { + ingameUI = GameController.IngameState.IngameUi; + } + + public void HpBarWork(HealthBar healthBar) + { + if (!healthBar.Settings.Enable) + { + healthBar.Skip = true; + return; + } + + if (!healthBar.Entity.IsAlive) + { + healthBar.Skip = true; + return; + } + + var healthBarDistance = healthBar.Distance; + + if (healthBarDistance > Settings.LimitDrawDistance) + { + healthBar.Skip = true; + return; + } + + healthBar.HpPercent = healthBar.Life.HPPercentage; + + if (healthBar.HpPercent < 0.001f) + { + healthBar.Skip = true; + return; + } + + if (healthBar.Type == CreatureType.Minion && healthBar.HpPercent * 100 > Settings.ShowMinionOnlyBelowHp) + { + healthBar.Skip = true; + return; + } + + if (healthBar.Entity.League == LeagueType.Legion && healthBar.Entity.IsHidden && healthBar.Entity.Rarity != MonsterRarity.Unique) + { + healthBar.Skip = true; + return; + } + + var _ = healthBar.IsHostile; + var worldCoords = healthBar.Entity.Pos; + worldCoords.Z += Settings.GlobalZ; + var mobScreenCoords = camera.WorldToScreen(worldCoords); + if (mobScreenCoords == Vector2.Zero) return; + var scaledWidth = healthBar.Settings.Width * windowSize.Width; + var scaledHeight = healthBar.Settings.Height * windowSize.Height; + + healthBar.BackGround = new RectangleF(mobScreenCoords.X - scaledWidth / 2f, mobScreenCoords.Y - scaledHeight / 2f, scaledWidth, + scaledHeight); + + if (healthBarDistance > 80 && !windowRectangle.Intersects(healthBar.BackGround)) + { + healthBar.Skip = true; + return; + } + + foreach (var forSkipBar in ElementForSkip) + { + if (forSkipBar.IsVisibleLocal && forSkipBar.GetClientRectCache.Intersects(healthBar.BackGround)) + { + healthBar.Skip = true; + } + } + + healthBar.HpWidth = healthBar.HpPercent * scaledWidth; + healthBar.EsWidth = healthBar.Life.ESPercentage * scaledWidth; + } + + public override Job Tick() + { + if (Settings.MultiThreading && GameController.EntityListWrapper.ValidEntitiesByType[EntityType.Monster].Count >= + Settings.MultiThreadingCountEntities) + { + return new Job(nameof(HealthBars), TickLogic); + + // return GameController.MultiThreadManager.AddJob(TickLogic, nameof(HealthBars)); + } + + TickLogic(); + return null; + } + + private void TickLogic() + { + CanTick = true; + + if (ingameUICheckVisible.Value) + { + CanTick = false; + return; + } + + if (camera == null) + { + CanTick = false; + return; + } + + if (GameController.Area.CurrentArea.IsTown && !Settings.ShowInTown) + { + CanTick = false; + return; + } + + foreach (var validEntity in GameController.EntityListWrapper.ValidEntitiesByType[EntityType.Monster]) + { + var healthBar = validEntity.GetHudComponent(); + + if (healthBar != null) + HpBarWork(healthBar); + } + + foreach (var validEntity in GameController.EntityListWrapper.ValidEntitiesByType[EntityType.Player]) + { + var healthBar = validEntity.GetHudComponent(); + + if (healthBar != null) + HpBarWork(healthBar); + } + } + + public override void Render() + { + if (!CanTick) + return; + + foreach (var entity in GameController.EntityListWrapper.ValidEntitiesByType[EntityType.Monster]) + { + var healthBar = entity.GetHudComponent(); + if (healthBar == null) continue; + + if (healthBar.Skip) + { + healthBar.Skip = false; + continue; + } + + DrawBar(healthBar); + } + + foreach (var entity in GameController.EntityListWrapper.ValidEntitiesByType[EntityType.Player]) + { + var healthBar = entity.GetHudComponent(); + if (healthBar == null) continue; + + if (healthBar.Skip) + { + healthBar.Skip = false; + continue; + } + + DrawBar(healthBar); + } + + if (Settings.SelfHealthBarShow) + { + var worldCoords = PlayerBar.Entity.Pos; + worldCoords.Z += Settings.PlayerZ; + var result = camera.WorldToScreen(worldCoords); + + if (Math.Abs(oldplayerCord.X - result.X) < 40 || Math.Abs(oldplayerCord.X - result.Y) < 40) + result = oldplayerCord; + else + oldplayerCord = result; + + var scaledWidth = PlayerBar.Settings.Width * windowSize.Width; + var scaledHeight = PlayerBar.Settings.Height * windowSize.Height; + + PlayerBar.BackGround = new RectangleF(result.X - scaledWidth / 2f, result.Y - scaledHeight / 2f, scaledWidth, + scaledHeight); + + PlayerBar.HpPercent = PlayerBar.Life.HPPercentage; + PlayerBar.HpWidth = PlayerBar.HpPercent * scaledWidth; + PlayerBar.EsWidth = PlayerBar.Life.ESPercentage * scaledWidth; + DrawBar(PlayerBar); + } + } + + public void DrawBar(HealthBar bar) + { + if (Settings.ImGuiRender) + { + Graphics.DrawBox(bar.BackGround, bar.Settings.BackGround); + Graphics.DrawBox(new RectangleF(bar.BackGround.X, bar.BackGround.Y, bar.HpWidth, bar.BackGround.Height), bar.Color); + } + else + { + Graphics.DrawImage("healthbar.png", bar.BackGround, bar.Settings.BackGround); + + Graphics.DrawImage("healthbar.png", new RectangleF(bar.BackGround.X, bar.BackGround.Y, bar.HpWidth, bar.BackGround.Height), + bar.Color); + } + + Graphics.DrawBox(new RectangleF(bar.BackGround.X, bar.BackGround.Y, bar.EsWidth, bar.BackGround.Height * 0.33f), Color.Aqua); + bar.BackGround.Inflate(1, 1); + Graphics.DrawFrame(bar.BackGround, bar.Settings.Outline, 1); + + if (bar.Settings.ShowPercents) + { + Graphics.DrawText($"{Math.Floor(bar.HpPercent * 100).ToString(CultureInfo.InvariantCulture)}", + new Vector2(bar.BackGround.Right, bar.BackGround.Center.Y - Graphics.Font.Size / 2f), + bar.Settings.PercentTextColor); + } + + if (bar.Settings.ShowHealthText) + { + var formattableString = $"{bar.Life.CurHP}/{bar.MaxHp}"; + + Graphics.DrawText(formattableString, + new Vector2(bar.BackGround.Center.X, bar.BackGround.Center.Y - Graphics.Font.Size / 2f), + bar.Settings.HealthTextColor, FontAlign.Center); + } + } + + public override void EntityAdded(Entity Entity) + { + if (Entity.Type != EntityType.Monster && Entity.Type != EntityType.Player || Entity.Address == GameController.Player.Address || + Entity.Type == EntityType.Daemon) return; + + if (Entity.GetComponent() != null && !Entity.IsAlive) return; + if (Ignored.Any(x => Entity.Path.StartsWith(x))) return; + Entity.SetHudComponent(new HealthBar(Entity, Settings)); + } + + public override void EntityRemoved(Entity Entity) + { + } + } +} diff --git a/HealthBars.csproj b/HealthBars.csproj new file mode 100644 index 0000000..8cc92d2 --- /dev/null +++ b/HealthBars.csproj @@ -0,0 +1,83 @@ + + + + + Debug + AnyCPU + {4DEE86D7-5666-4B10-93C2-0CCEEF3799E5} + Library + Properties + HealthBars + HealthBars + v4.8 + 512 + true + + + true + full + false + ..\..\..\..\PoeHelper\Plugins\Compiled\HealthBars\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + ..\0Compiles\HealthBars\ + TRACE + prompt + 4 + + + true + ..\..\..\..\PoeHelper\Plugins\Compiled\DevTree\ + DEBUG;TRACE + full + x64 + prompt + MinimumRecommendedRules.ruleset + + + bin\x64\Release\ + TRACE + true + pdbonly + x64 + prompt + MinimumRecommendedRules.ruleset + + + + ..\..\PoEHelper\ExileCore.dll + + + ..\..\ExileApi\packages\SharpDX.4.2.0\lib\net45\SharpDX.dll + False + + + ..\..\ExileApi\packages\SharpDX.Mathematics.4.2.0\lib\net45\SharpDX.Mathematics.dll + False + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/HealthBars.sln b/HealthBars.sln new file mode 100644 index 0000000..e83d0ce --- /dev/null +++ b/HealthBars.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.29905.134 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HealthBars", "HealthBars.csproj", "{4DEE86D7-5666-4B10-93C2-0CCEEF3799E5}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|x64 = Debug|x64 + Release|Any CPU = Release|Any CPU + Release|x64 = Release|x64 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {4DEE86D7-5666-4B10-93C2-0CCEEF3799E5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {4DEE86D7-5666-4B10-93C2-0CCEEF3799E5}.Debug|Any CPU.Build.0 = Debug|Any CPU + {4DEE86D7-5666-4B10-93C2-0CCEEF3799E5}.Debug|x64.ActiveCfg = Debug|x64 + {4DEE86D7-5666-4B10-93C2-0CCEEF3799E5}.Debug|x64.Build.0 = Debug|x64 + {4DEE86D7-5666-4B10-93C2-0CCEEF3799E5}.Release|Any CPU.ActiveCfg = Release|Any CPU + {4DEE86D7-5666-4B10-93C2-0CCEEF3799E5}.Release|Any CPU.Build.0 = Release|Any CPU + {4DEE86D7-5666-4B10-93C2-0CCEEF3799E5}.Release|x64.ActiveCfg = Release|x64 + {4DEE86D7-5666-4B10-93C2-0CCEEF3799E5}.Release|x64.Build.0 = Release|x64 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {9BF0A8B7-5BFC-4327-B754-34C21ACA4251} + EndGlobalSection +EndGlobal diff --git a/HealthBarsSettings.cs b/HealthBarsSettings.cs new file mode 100644 index 0000000..cd5e029 --- /dev/null +++ b/HealthBarsSettings.cs @@ -0,0 +1,128 @@ +using ExileCore.Shared.Attributes; +using ExileCore.Shared.Interfaces; +using ExileCore.Shared.Nodes; + +namespace HealthBars +{ + public class HealthBarsSettings : ISettings + { + public HealthBarsSettings() + { + Enable = new ToggleNode(false); + ShowInTown = new ToggleNode(false); + ShowES = new ToggleNode(true); + ShowEnemies = new ToggleNode(true); + Players = new UnitSettings(0x008000ff, 0); + Minions = new UnitSettings(0x90ee90ff, 0); + NormalEnemy = new UnitSettings(0xff0000ff, 0, 0x66ff66ff, false); + MagicEnemy = new UnitSettings(0xff0000ff, 0x8888ffff, 0x66ff99ff, false); + RareEnemy = new UnitSettings(0xff0000ff, 0xffff77ff, 0x66ff99ff, false); + UniqueEnemy = new UnitSettings(0xff0000ff, 0xffa500ff, 0x66ff99ff, false); + ShowDebuffPanel = new ToggleNode(false); + DebuffPanelIconSize = new RangeNode(20, 15, 40); + GlobalZ = new RangeNode(-100, -300, 300); + PlayerZ = new RangeNode(-100, -300, 300); + OffsetBars = new RangeNode(0, -300, 300); + } + + [Menu("Show In Town")] + public ToggleNode ShowInTown { get; set; } + [Menu("Show ES")] + public ToggleNode ShowES { get; set; } + [Menu("Show Enemies", 0, 3)] + public ToggleNode ShowEnemies { get; set; } + [Menu("Players", 1)] + public UnitSettings Players { get; set; } + [Menu("Minions", 2)] + public UnitSettings Minions { get; set; } + [Menu("Normal enemy", 3)] + public UnitSettings NormalEnemy { get; set; } + [Menu("Magic enemy", 4)] + public UnitSettings MagicEnemy { get; set; } + [Menu("Rare enemy", 5)] + public UnitSettings RareEnemy { get; set; } + [Menu("Unique enemy", 6)] + public UnitSettings UniqueEnemy { get; set; } + [Menu("Show Debuff Panel")] + public ToggleNode ShowDebuffPanel { get; set; } + [Menu("Size debuff icon")] + public RangeNode DebuffPanelIconSize { get; set; } + [Menu("Z")] + public RangeNode GlobalZ { get; set; } + [Menu("Player Z")] + public RangeNode PlayerZ { get; set; } + [Menu("PlayerBar Y Offset")] + public RangeNode OffsetBars { get; set; } + [Menu("Hide Over UI")] + public ToggleNode HideOverUi { get; set; } = new ToggleNode(true); + [Menu("Using ImGui for render")] + public ToggleNode ImGuiRender { get; set; } = new ToggleNode(false); + public RangeNode LimitDrawDistance { get; set; } = new RangeNode(133, 0, 1000); + [Menu("Rounding")] + + public RangeNode Rounding { get; set; } = new RangeNode(0, 0, 64); + public ToggleNode MultiThreading { get; set; } = new ToggleNode(false); + public RangeNode MultiThreadingCountEntities { get; set; } = new RangeNode(10, 1, 200); + public RangeNode ShowMinionOnlyBelowHp { get; set; } = new RangeNode(50, 1, 100); + public ToggleNode SelfHealthBarShow { get; set; } = new ToggleNode(true); + public ToggleNode Enable { get; set; } + + } + + public class UnitSettings : ISettings + { + public UnitSettings(uint color, uint outline) + { + Enable = new ToggleNode(true); + Width = new RangeNode(100, 20, 250); + Height = new RangeNode(20, 5, 150); + Color = color; + Outline = outline; + Under10Percent = 0xffffffff; + PercentTextColor = 0xffffffff; + HealthTextColor = 0xffffffff; + HealthTextColorUnder10Percent = 0xffff00ff; + ShowPercents = new ToggleNode(false); + ShowHealthText = new ToggleNode(false); + ShowFloatingCombatDamage = new ToggleNode(false); + FloatingCombatTextSize = new RangeNode(15, 10, 30); + FloatingCombatDamageColor = SharpDX.Color.Yellow; + FloatingCombatHealColor = SharpDX.Color.Lime; + BackGround = SharpDX.Color.Black; + TextSize = new RangeNode(15, 10, 50); + FloatingCombatStackSize = new RangeNode(1, 1, 10); + } + + public UnitSettings(uint color, uint outline, uint percentTextColor, bool showText) : this(color, outline) + { + PercentTextColor = percentTextColor; + ShowPercents.Value = showText; + ShowHealthText.Value = showText; + } + + public RangeNode Width { get; set; } + public RangeNode Height { get; set; } + public ColorNode Color { get; set; } + public ColorNode Outline { get; set; } + public ColorNode BackGround { get; set; } + public ColorNode Under10Percent { get; set; } + public ColorNode PercentTextColor { get; set; } + public ColorNode HealthTextColor { get; set; } + public ColorNode HealthTextColorUnder10Percent { get; set; } + public ToggleNode ShowPercents { get; set; } + public ToggleNode ShowHealthText { get; set; } + public RangeNode TextSize { get; set; } + [Menu("Floating Combat Text")] + public ToggleNode ShowFloatingCombatDamage { get; set; } + [Menu("Damage Color")] + public ColorNode FloatingCombatDamageColor { get; set; } + [Menu("Heal Color")] + public ColorNode FloatingCombatHealColor { get; set; } + [Menu("Text Size")] + public RangeNode FloatingCombatTextSize { get; set; } + [Menu("Number of Lines")] + public RangeNode FloatingCombatStackSize { get; set; } + [Menu("Enable")] + public ToggleNode Enable { get; set; } + } +} diff --git a/Properties/AssemblyInfo.cs b/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..d466c87 --- /dev/null +++ b/Properties/AssemblyInfo.cs @@ -0,0 +1,35 @@ +using System.Reflection; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("HealthBars")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("HealthBars")] +[assembly: AssemblyCopyright("Copyright © 2019")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("4dee86d7-5666-4b10-93c2-0cceef3799e5")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/README.md b/README.md new file mode 100644 index 0000000..dc26a1e --- /dev/null +++ b/README.md @@ -0,0 +1 @@ +HealthBars diff --git a/packages.config b/packages.config new file mode 100644 index 0000000..7eaa735 --- /dev/null +++ b/packages.config @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file