├── .gitignore
└── Tracker
    ├── .editorconfig
    ├── GroundEffectLogic.cs
    ├── GroundEffectSettings.cs
    ├── Libs
        ├── GameHelper.dll
        └── GameOffsets.dll
    ├── MonsterLineLogic.cs
    ├── StatusEffectLogic.cs
    ├── StatusEffectSettings.cs
    ├── Tracker.cs
    ├── Tracker.csproj
    ├── Tracker.sln
    └── TrackerSettings.cs


/.gitignore:
--------------------------------------------------------------------------------
 1 | ################################################################################
 2 | # This .gitignore file was automatically created by Microsoft(R) Visual Studio.
 3 | ################################################################################
 4 | 
 5 | /Tracker/.vs
 6 | /Tracker/bin
 7 | /Tracker/obj
 8 | /GameHelper/bin
 9 | /GameHelper/obj
10 | 


--------------------------------------------------------------------------------
/Tracker/.editorconfig:
--------------------------------------------------------------------------------
1 | [*.cs]
2 | 
3 | # S1104: Fields should not have public accessibility
4 | dotnet_diagnostic.S1104.severity = none
5 | 


--------------------------------------------------------------------------------
/Tracker/GroundEffectLogic.cs:
--------------------------------------------------------------------------------
 1 | using GameHelper;
 2 | using GameHelper.RemoteObjects.Components;
 3 | using GameHelper.RemoteObjects.States.InGameStateObjects;
 4 | using GameHelper.Utils;
 5 | using ImGuiNET;
 6 | using System.Linq;
 7 | 
 8 | namespace Tracker
 9 | {
10 |     public class EntityWithSettings
11 |     {
12 |         public Entity Entity { get; set; }
13 |         public GroundEffectSettings GroundEffect { get; set; }
14 |     }
15 | 
16 |     public class GroundEffectLogic(TrackerSettings settings)
17 |     {
18 |         private TrackerSettings Settings { get; } = settings;
19 | 
20 |         public void Draw()
21 |         {
22 |             var areaInstance = Core.States.InGameStateObject.CurrentAreaInstance;
23 |             var matchingEntities = areaInstance.AwakeEntities
24 |                 .Select(entity => new
25 |                 {
26 |                     Entity = entity.Value,
27 |                     GroundEffect = Settings.GroundEffects.Find(effect => entity.Value.Path.StartsWith(effect.Path) && effect.IsEnabled)
28 |                 })
29 |                 .Where(entity => entity.GroundEffect is not null)
30 |                 .Select(entity => new EntityWithSettings
31 |                 {
32 |                     Entity = entity.Entity,
33 |                     GroundEffect = entity.GroundEffect
34 |                 });
35 | 
36 |             foreach (var item in matchingEntities)
37 |             {
38 |                 var entity = item.Entity;
39 |                 var groundEffect = item.GroundEffect;
40 | 
41 |                 if (!entity.TryGetComponent<Render>(out var entityRender)) continue;
42 |                 if (!entity.TryGetComponent<Positioned>(out var entityPositioned) || entityPositioned.IsFriendly) continue;
43 | 
44 |                 var drawList = ImGui.GetBackgroundDrawList();
45 |                 var entityLocation = Core.States.InGameStateObject.CurrentWorldInstance.WorldToScreen(entityRender.WorldPosition);
46 |                 var color = ImGuiHelper.Color(groundEffect.Color);
47 | 
48 |                 if (groundEffect.Filled) drawList.AddCircleFilled(entityLocation, groundEffect.Radius, color);
49 |                 else drawList.AddCircle(entityLocation, groundEffect.Radius, color, 0, groundEffect.LineWeight);
50 |             }
51 |         }
52 |     }
53 | }
54 | 


--------------------------------------------------------------------------------
/Tracker/GroundEffectSettings.cs:
--------------------------------------------------------------------------------
 1 | using System.Numerics;
 2 | 
 3 | namespace Tracker
 4 | {
 5 |     public class GroundEffectSettings(bool isEnabled, string path, Vector4 color, int radius, int lineWeight, bool filled)
 6 |     {
 7 |         public string Path = path;
 8 |         public Vector4 Color = color;
 9 |         public bool IsEnabled = isEnabled;
10 |         public int LineWeight = lineWeight;
11 |         public bool Filled = filled;
12 |         public int Radius = radius;
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/Tracker/Libs/GameHelper.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DevChronos/Tracker/175ef0de32ab72bc360f61d663a9a721ac7f5e20/Tracker/Libs/GameHelper.dll


--------------------------------------------------------------------------------
/Tracker/Libs/GameOffsets.dll:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/DevChronos/Tracker/175ef0de32ab72bc360f61d663a9a721ac7f5e20/Tracker/Libs/GameOffsets.dll


--------------------------------------------------------------------------------
/Tracker/MonsterLineLogic.cs:
--------------------------------------------------------------------------------
 1 | using GameHelper;
 2 | using GameHelper.RemoteEnums;
 3 | using GameHelper.RemoteEnums.Entity;
 4 | using GameHelper.RemoteObjects.Components;
 5 | using GameHelper.RemoteObjects.States.InGameStateObjects;
 6 | using GameHelper.Utils;
 7 | using GameOffsets.Objects.States.InGameState;
 8 | using ImGuiNET;
 9 | using System.Collections.Generic;
10 | using System.Linq;
11 | using System.Numerics;
12 | 
13 | namespace Tracker
14 | {
15 |     public class MonsterLineLogic(TrackerSettings settings)
16 |     {
17 |         private TrackerSettings Settings { get; } = settings;
18 | 
19 |         public void Draw()
20 |         {
21 |             var player = Core.States.InGameStateObject.CurrentAreaInstance.Player;
22 | 
23 |             if (!player.TryGetComponent<Render>(out var playerRender)) return;
24 |             var playerlocation = Core.States.InGameStateObject.CurrentWorldInstance.WorldToScreen(playerRender.WorldPosition);
25 | 
26 |             if (Settings.UniqueLine)
27 |             {
28 |                 foreach (var entity in GetMonsters(Rarity.Unique))
29 |                     _drawMonsterLine(entity, Settings.UniqueLineColor);
30 |             }
31 | 
32 |             if (Settings.RareLine)
33 |             {
34 |                 foreach (var entity in GetMonsters(Rarity.Rare))
35 |                     _drawMonsterLine(entity, Settings.RareLineColor);
36 |             }
37 | 
38 |             if (Settings.MagicLine)
39 |             {
40 |                 foreach (var entity in GetMonsters(Rarity.Magic))
41 |                     _drawMonsterLine(entity, Settings.MagicLineColor);
42 |             }
43 | 
44 |             void _drawMonsterLine(Entity entity, Vector4 color)
45 |             {
46 |                 if (!entity.TryGetComponent<Render>(out var entityRender)) return;
47 | 
48 |                 var drawList = ImGui.GetBackgroundDrawList();
49 |                 var entitylocation = Core.States.InGameStateObject.CurrentWorldInstance.WorldToScreen(entityRender.WorldPosition);
50 | 
51 |                 drawList.AddLine(playerlocation, entitylocation, ImGuiHelper.Color(color), 1.0f);
52 |             }
53 |         }
54 | 
55 |         private IEnumerable<Entity> GetMonsters()
56 |         {
57 |             var areaInstance = Core.States.InGameStateObject.CurrentAreaInstance;
58 |             return areaInstance.AwakeEntities.Where(IsValidMonster).Select(entity => entity.Value);
59 |         }
60 | 
61 |         private IEnumerable<Entity> GetMonsters(Rarity rarity)
62 |         {
63 |             return GetMonsters().Where(entity => entity.TryGetComponent<ObjectMagicProperties>(out var comp) && comp.Rarity == rarity);
64 |         }
65 | 
66 |         private bool IsValidMonster(KeyValuePair<EntityNodeKey, Entity> entity)
67 |         {
68 |             return
69 |                 entity.Value.IsValid &&
70 |                 entity.Value.EntityState == EntityStates.None &&
71 |                 entity.Value.EntityType == EntityTypes.Monster;
72 |         }
73 |     }
74 | }
75 | 


--------------------------------------------------------------------------------
/Tracker/StatusEffectLogic.cs:
--------------------------------------------------------------------------------
 1 | using GameHelper;
 2 | using GameHelper.RemoteEnums;
 3 | using GameHelper.RemoteEnums.Entity;
 4 | using GameHelper.RemoteObjects.Components;
 5 | using GameHelper.RemoteObjects.States.InGameStateObjects;
 6 | using GameHelper.Utils;
 7 | using GameOffsets.Objects.States.InGameState;
 8 | using ImGuiNET;
 9 | using System;
10 | using System.Collections.Generic;
11 | using System.Linq;
12 | using System.Numerics;
13 | 
14 | namespace Tracker
15 | {
16 |     public class StatusEffectLogic(TrackerSettings settings)
17 |     {
18 |         private TrackerSettings Settings { get; } = settings;
19 | 
20 |         public void Draw()
21 |         {
22 |             foreach (var entity in GetMonsters())
23 |             {
24 |                 if (!entity.TryGetComponent<Render>(out var entityRender)) continue;
25 |                 if (!entity.TryGetComponent<Buffs>(out var entityBuffs)) continue;
26 | 
27 |                 var effects = Settings.StatusEffects.Where(mse => entityBuffs.StatusEffects.ContainsKey(mse.Name) && mse.IsEnabled);
28 |                 if (!effects.Any()) continue;
29 | 
30 |                 var drawList = ImGui.GetBackgroundDrawList();
31 |                 var entitylocation = Core.States.InGameStateObject.CurrentWorldInstance.WorldToScreen(entityRender.WorldPosition);
32 | 
33 |                 var shadowOffset = new Vector2(1, 1);
34 |                 var shadowColor = ImGuiHelper.Color(new Vector4(0, 0, 0, 1.0f));
35 | 
36 |                 for (var i = 0; i < effects.Count(); i++)
37 |                 {
38 |                     var barWidthMultiplier = 1.0f;
39 | 
40 |                     var effect = effects.ElementAt(i);
41 |                     var statusEffect = entityBuffs.StatusEffects[effect.Name];
42 |                     var displayText = effect.DisplayName;
43 | 
44 |                     if (statusEffect.TimeLeft > 0 && statusEffect.TimeLeft < 99)
45 |                     {
46 |                         displayText += $"  {statusEffect.TimeLeft:F1}s";
47 | 
48 |                         if (statusEffect.TotalTime < 99)
49 |                             barWidthMultiplier = statusEffect.TimeLeft / statusEffect.TotalTime;
50 |                     }
51 | 
52 |                     var textSize = ImGui.CalcTextSize(displayText);
53 |                     var padding = new Vector2(5, 2);
54 |                     var bgPos = new Vector2(entitylocation.X - padding.X, entitylocation.Y - padding.Y);
55 |                     var bgSize = new Vector2(Math.Max(textSize.X + padding.X * 2, Settings.StatusBarMinWidth), textSize.Y + padding.Y * 2);
56 | 
57 |                     drawList.AddRectFilled(bgPos, bgPos + bgSize, ImGuiHelper.Color(Settings.StatusBarBackgroundColor));
58 | 
59 |                     var barInset = 1.0f;
60 |                     var barPos = new Vector2(bgPos.X + barInset, bgPos.Y + barInset);
61 |                     var barSize = new Vector2(bgSize.X - barInset * 2, bgSize.Y - barInset * 2);
62 |                     var barWidth = barSize.X * barWidthMultiplier;
63 |                     drawList.AddRectFilled(barPos, new Vector2(barPos.X + barWidth, barPos.Y + barSize.Y), ImGuiHelper.Color(effect.BarColor));
64 | 
65 |                     drawList.AddText(entitylocation + shadowOffset, shadowColor, displayText);
66 |                     drawList.AddText(entitylocation, ImGuiHelper.Color(effect.TextColor), displayText);
67 | 
68 |                     entitylocation.Y += textSize.Y + padding.Y * 2 - 1;
69 |                 }
70 |             }
71 |         }
72 | 
73 |         private IEnumerable<Entity> GetMonsters()
74 |         {
75 |             var areaInstance = Core.States.InGameStateObject.CurrentAreaInstance;
76 |             var monsters = areaInstance.AwakeEntities.Where(IsValidMonster).Select(entity => entity.Value);
77 |             return monsters.Where(entity => entity.TryGetComponent<ObjectMagicProperties>(out var comp) && comp.Rarity != Rarity.Normal);
78 |         }
79 | 
80 |         private bool IsValidMonster(KeyValuePair<EntityNodeKey, Entity> entity)
81 |         {
82 |             return
83 |                 entity.Value.IsValid &&
84 |                 entity.Value.EntityState == EntityStates.None &&
85 |                 entity.Value.EntityType == EntityTypes.Monster;
86 |         }
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/Tracker/StatusEffectSettings.cs:
--------------------------------------------------------------------------------
 1 | using System.Numerics;
 2 | 
 3 | namespace Tracker
 4 | {
 5 |     public class StatusEffectSettings(bool isEnabled, string name, string displayName, Vector4 textcolor, Vector4 barColor)
 6 |     {
 7 |         public string Name = name;
 8 |         public string DisplayName = displayName;
 9 |         public Vector4 TextColor = textcolor;
10 |         public Vector4 BarColor = barColor;
11 |         public bool IsEnabled = isEnabled;
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/Tracker/Tracker.cs:
--------------------------------------------------------------------------------
  1 | namespace Tracker
  2 | {
  3 |     using GameHelper.Plugin;
  4 |     using ImGuiNET;
  5 |     using Newtonsoft.Json;
  6 |     using System;
  7 |     using System.IO;
  8 |     using System.Numerics;
  9 | 
 10 |     public sealed class Tracker : PCore<TrackerSettings>
 11 |     {
 12 |         private string SettingPathname => Path.Join(this.DllDirectory, "config", "settings.txt");
 13 |         private MonsterLineLogic MonsterLine { get; set; }
 14 |         private GroundEffectLogic GroundEffect { get; set; }
 15 |         private StatusEffectLogic StatusEffect { get; set; }
 16 | 
 17 |         public override void OnDisable()
 18 |         {
 19 |         }
 20 | 
 21 |         public override void OnEnable(bool isGameOpened)
 22 |         {
 23 |             if (File.Exists(this.SettingPathname))
 24 |             {
 25 |                 var content = File.ReadAllText(this.SettingPathname);
 26 |                 var serializerSettings = new JsonSerializerSettings() { ObjectCreationHandling = ObjectCreationHandling.Replace };
 27 |                 this.Settings = JsonConvert.DeserializeObject<TrackerSettings>(content, serializerSettings);
 28 |             }
 29 | 
 30 |             MonsterLine = new MonsterLineLogic(this.Settings);
 31 |             GroundEffect = new GroundEffectLogic(this.Settings);
 32 |             StatusEffect = new StatusEffectLogic(this.Settings);
 33 |         }
 34 | 
 35 |         public override void SaveSettings()
 36 |         {
 37 |             Directory.CreateDirectory(Path.GetDirectoryName(this.SettingPathname));
 38 |             var settingsData = JsonConvert.SerializeObject(this.Settings, Formatting.Indented);
 39 |             File.WriteAllText(this.SettingPathname, settingsData);
 40 |         }
 41 | 
 42 |         public override void DrawSettings()
 43 |         {
 44 |             DrawMonsterLineSettigns();
 45 |             DrawGroundEffectSettings();
 46 |             DrawStatusEffectSettings();
 47 |         }
 48 | 
 49 |         public override void DrawUI()
 50 |         {
 51 |             this.MonsterLine.Draw();
 52 |             this.GroundEffect.Draw();
 53 |             this.StatusEffect.Draw();
 54 |         }
 55 | 
 56 |         private void DrawMonsterLineSettigns()
 57 |         {
 58 |             ImGui.Checkbox("##UniqueLine", ref Settings.UniqueLine);
 59 |             ImGui.SameLine();
 60 |             ColorSwatch("Unique monster line color", ref Settings.UniqueLineColor);
 61 | 
 62 |             ImGui.Checkbox("##RareLine", ref Settings.RareLine);
 63 |             ImGui.SameLine();
 64 |             ColorSwatch("Rare monster line color", ref Settings.RareLineColor);
 65 | 
 66 |             ImGui.Checkbox("##MagicLine", ref Settings.MagicLine);
 67 |             ImGui.SameLine();
 68 |             ColorSwatch("Magic monster line color", ref Settings.MagicLineColor);
 69 |         }
 70 | 
 71 |         private void DrawGroundEffectSettings()
 72 |         {
 73 |             if (ImGui.CollapsingHeader("Ground Effects"))
 74 |             {
 75 |                 ImGui.Indent();
 76 | 
 77 |                 for (int i = 0; i < Settings.GroundEffects.Count; i++)
 78 |                 {
 79 |                     var groundEffect = Settings.GroundEffects[i];
 80 | 
 81 |                     ImGui.Checkbox($"##GroundEffectEnabled{i}", ref groundEffect.IsEnabled);
 82 | 
 83 |                     ImGui.SameLine();
 84 |                     ColorSwatch($"##GroundEffectColor{i}", ref groundEffect.Color);
 85 | 
 86 |                     ImGui.SameLine();
 87 |                     ImGui.Text($"Fill");
 88 |                     ImGui.SameLine();
 89 |                     ImGui.Checkbox($"##Fill{i}", ref groundEffect.Filled);
 90 | 
 91 |                     ImGui.SameLine();
 92 |                     ImGui.Text($"Weight");
 93 |                     ImGui.SameLine();
 94 |                     ImGui.SetNextItemWidth(50);
 95 |                     ImGui.SliderInt($"##Weight{i}", ref groundEffect.LineWeight, 1, 5);
 96 | 
 97 |                     ImGui.SameLine();
 98 |                     ImGui.Text("Radius");
 99 |                     ImGui.SameLine();
100 |                     ImGui.SetNextItemWidth(50);
101 |                     ImGui.SliderInt($"##Radius{i}", ref groundEffect.Radius, 50, 300);
102 | 
103 |                     ImGui.SameLine();
104 |                     ImGui.SetNextItemWidth(GetInputWidth());
105 |                     ImGui.InputText($"##GroundEffectPath{i}", ref groundEffect.Path, 256);
106 | 
107 |                     ImGui.SameLine();
108 |                     if (ImGui.Button($"Delete##GroundEffectDelete{i}"))
109 |                     {
110 |                         Settings.GroundEffects.RemoveAt(i);
111 |                         break;
112 |                     }
113 |                 }
114 | 
115 |                 if (ImGui.Button("Add Ground Effect"))
116 |                     Settings.GroundEffects.Add(new GroundEffectSettings(true, "", new Vector4(1.0f, 0.0f, 0.0f, 0.6f), 100, 1, false));
117 | 
118 |                 ImGui.Unindent();
119 |             }
120 |         }
121 | 
122 |         private void DrawStatusEffectSettings()
123 |         {
124 |             if (ImGui.CollapsingHeader("Monster Status Effects"))
125 |             {
126 |                 ImGui.Indent();
127 | 
128 |                 ImGui.Text($"StatusBar Background");
129 |                 ImGui.SameLine();
130 |                 ColorSwatch($"##StatusBarBG", ref Settings.StatusBarBackgroundColor);
131 |                 Tooltip("Status Effect text color.");
132 | 
133 |                 ImGui.SameLine();
134 |                 ImGui.Text($"StatusBar Min Width");
135 |                 ImGui.SameLine();
136 |                 ImGui.SetNextItemWidth(ImGui.GetContentRegionAvail().X);
137 |                 ImGui.SliderInt($"##StatusBar Min Width", ref Settings.StatusBarMinWidth, 50, 300);
138 | 
139 |                 for (int i = 0; i < Settings.StatusEffects.Count; i++)
140 |                 {
141 |                     var statusEffect = Settings.StatusEffects[i];
142 | 
143 |                     ImGui.Checkbox($"##StatusEffectEnabled{i}", ref statusEffect.IsEnabled);
144 |                     Tooltip("Enable status Effect.");
145 | 
146 |                     ImGui.SameLine();
147 |                     ColorSwatch($"##StatusEffectTextColor{i}", ref statusEffect.TextColor);
148 |                     Tooltip("Status Effect text color.");
149 | 
150 |                     ImGui.SameLine();
151 |                     ColorSwatch($"##StatusEffectBarColor{i}", ref statusEffect.BarColor);
152 |                     Tooltip("Status Effect bar color.");
153 | 
154 |                     ImGui.SameLine();
155 |                     ImGui.Text($"Display Name");
156 | 
157 |                     ImGui.SameLine();
158 |                     ImGui.SetNextItemWidth(120);
159 |                     ImGui.InputText($"##DisplayName{i}", ref statusEffect.DisplayName, 256);
160 | 
161 |                     ImGui.SameLine();
162 |                     ImGui.Text($"Name");
163 | 
164 |                     ImGui.SameLine();
165 |                     ImGui.SetNextItemWidth(GetInputWidth());
166 |                     ImGui.InputText($"##Name{i}", ref statusEffect.Name, 256);
167 | 
168 |                     ImGui.SameLine();
169 |                     if (ImGui.Button($"Delete##StatusEffectDelete{i}"))
170 |                     {
171 |                         Settings.StatusEffects.RemoveAt(i);
172 |                         break;
173 |                     }
174 |                 }
175 | 
176 |                 if (ImGui.Button("Add Status Effect"))
177 |                     Settings.StatusEffects.Add(new StatusEffectSettings(true, "xxx", "XXX", new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.4549f, 0.0314f, 0.0314f, 1.0f)));
178 | 
179 |                 ImGui.Unindent();
180 |             }
181 |         }
182 | 
183 |         private static void ColorSwatch(string label, ref System.Numerics.Vector4 color)
184 |         {
185 | 
186 |             if (ImGui.ColorButton(label, color))
187 |                 ImGui.OpenPopup(label);
188 | 
189 |             if (ImGui.BeginPopup(label))
190 |             {
191 |                 ImGui.ColorPicker4(label, ref color);
192 |                 ImGui.EndPopup();
193 |             }
194 | 
195 |             if (!label.StartsWith("##"))
196 |             {
197 |                 ImGui.SameLine();
198 |                 ImGui.Text(label);
199 |             }
200 |         }
201 | 
202 |         private static void Tooltip(string label)
203 |         {
204 |             if (ImGui.IsItemHovered())
205 |             {
206 |                 ImGui.BeginTooltip();
207 |                 ImGui.Text(label);
208 |                 ImGui.EndTooltip();
209 |             }
210 |         }
211 | 
212 |         private static float GetInputWidth()
213 |         {
214 |             var availableWidth = ImGui.GetContentRegionAvail().X;
215 |             var minWidth = 50.0f;
216 |             var buttonSize = ImGui.CalcTextSize($"Delete");
217 |             buttonSize.X += ImGui.GetStyle().FramePadding.X * 2;
218 |             return Math.Max(availableWidth - buttonSize.X - 10, minWidth);
219 |         }
220 |     }
221 | }
222 | 


--------------------------------------------------------------------------------
/Tracker/Tracker.csproj:
--------------------------------------------------------------------------------
 1 | <Project Sdk="Microsoft.NET.Sdk">
 2 | 
 3 |   <PropertyGroup>
 4 |     <TargetFramework>net8.0</TargetFramework>
 5 |     <OutputType>Library</OutputType>
 6 |     <GenerateDocumentationFile>False</GenerateDocumentationFile>
 7 |   </PropertyGroup>
 8 | 
 9 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
10 |     <PlatformTarget>x64</PlatformTarget>
11 |   </PropertyGroup>
12 | 
13 |   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
14 |     <PlatformTarget>x64</PlatformTarget>
15 |   </PropertyGroup>
16 | 
17 |   <ItemGroup>
18 |     <PackageReference Include="ImGui.NET" Version="1.90.9.1" />
19 |     <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
20 |   </ItemGroup>
21 | 
22 |   <ItemGroup>
23 |     <Reference Include="GameHelper">
24 |       <HintPath>Libs\GameHelper.dll</HintPath>
25 |     </Reference>
26 |     <Reference Include="GameOffsets">
27 |       <HintPath>Libs\GameOffsets.dll</HintPath>
28 |     </Reference>
29 |   </ItemGroup>
30 | 
31 |   <Target Name="CopyFiles" AfterTargets="Build">
32 |     <Copy SourceFiles="$(OutDir)$(TargetName)$(TargetExt); $(OutDir)$(TargetName).pdb;" DestinationFolder="..\GameHelper\$(OutDir)Plugins\$(ProjectName)" SkipUnchangedFiles="true" />
33 |   </Target>
34 | 
35 | </Project>
36 | 


--------------------------------------------------------------------------------
/Tracker/Tracker.sln:
--------------------------------------------------------------------------------
 1 | 
 2 | Microsoft Visual Studio Solution File, Format Version 12.00
 3 | # Visual Studio Version 17
 4 | VisualStudioVersion = 17.11.35222.181
 5 | MinimumVisualStudioVersion = 10.0.40219.1
 6 | Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Tracker", "Tracker.csproj", "{D008BA19-5EDD-47E3-A77D-0F1B5D06C0DA}"
 7 | EndProject
 8 | Global
 9 | 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
10 | 		Debug|Any CPU = Debug|Any CPU
11 | 		Release|Any CPU = Release|Any CPU
12 | 	EndGlobalSection
13 | 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
14 | 		{D008BA19-5EDD-47E3-A77D-0F1B5D06C0DA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
15 | 		{D008BA19-5EDD-47E3-A77D-0F1B5D06C0DA}.Debug|Any CPU.Build.0 = Debug|Any CPU
16 | 		{D008BA19-5EDD-47E3-A77D-0F1B5D06C0DA}.Release|Any CPU.ActiveCfg = Release|Any CPU
17 | 		{D008BA19-5EDD-47E3-A77D-0F1B5D06C0DA}.Release|Any CPU.Build.0 = Release|Any CPU
18 | 	EndGlobalSection
19 | 	GlobalSection(SolutionProperties) = preSolution
20 | 		HideSolutionNode = FALSE
21 | 	EndGlobalSection
22 | 	GlobalSection(ExtensibilityGlobals) = postSolution
23 | 		SolutionGuid = {6D3FB613-1644-4F50-99A8-DCCDD5C1409E}
24 | 	EndGlobalSection
25 | EndGlobal
26 | 


--------------------------------------------------------------------------------
/Tracker/TrackerSettings.cs:
--------------------------------------------------------------------------------
 1 | namespace Tracker
 2 | {
 3 |     using GameHelper.Plugin;
 4 |     using System.Collections.Generic;
 5 |     using System.Numerics;
 6 | 
 7 |     public sealed class TrackerSettings : IPSettings
 8 |     {
 9 |         public bool UniqueLine = true;
10 |         public bool RareLine = true;
11 |         public bool MagicLine = false;
12 | 
13 |         public Vector4 UniqueLineColor = new(1.0f, 0.580f, 0.0f, 0.564f);
14 |         public Vector4 RareLineColor = new(1.0f, 0.988f, 0.0f, 0.490f);
15 |         public Vector4 MagicLineColor = new(0.0f, 0.117f, 1.0f, 0.294f);
16 | 
17 |         public List<GroundEffectSettings> GroundEffects;
18 |         public List<StatusEffectSettings> StatusEffects;
19 | 
20 |         public Vector4 StatusBarBackgroundColor = new(0, 0, 0, 0.750f);
21 |         public int StatusBarMinWidth = 120;
22 | 
23 |         public TrackerSettings()
24 |         {
25 |             GroundEffects = [
26 |                 new GroundEffectSettings(true, "Metadata/Effects/Spells/ground_effects/VisibleServerGroundEffect", new Vector4(1.0f, 0.0f, 0.0f, 0.6f), 100, 1, false),
27 |                 new GroundEffectSettings(true, "Metadata/Monsters/MonsterMods/GroundOnDeath/BurningGroundDaemon", new Vector4(1.0f, 0.0f, 0.0f, 0.6f), 100, 1, false),
28 |                 new GroundEffectSettings(true, "Metadata/Monsters/MonsterMods/GroundOnDeath/ColdSnapGroundDaemon", new Vector4(1.0f, 0.0f, 0.0f, 0.6f), 100, 1, false),
29 |                 new GroundEffectSettings(true, "Metadata/Monsters/MonsterMods/OnDeathLightningExplosion", new Vector4(1.0f, 0.0f, 0.0f, 0.6f), 100, 1, false),
30 |                 new GroundEffectSettings(true, "Metadata/Monsters/MonsterMods/OnDeathFireExplosion", new Vector4(1.0f, 0.0f, 0.0f, 0.6f), 100, 1, false)
31 |             ];
32 | 
33 |             StatusEffects = [
34 |                 new StatusEffectSettings(true, "shocked", "Shocked", new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.6549f, 0.6039f, 0.0431f, 1.0f) ),
35 |                 new StatusEffectSettings(true, "proximal_intangibility", "Intangible", new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.4549f, 0.0314f, 0.0314f, 1.0f) ),
36 |                 new StatusEffectSettings(true, "frozen", "Frozen", new Vector4(1.0f, 1.0f, 1.0f, 1.0f), new Vector4(0.0f,    0.6314f, 0.8118f, 1.0f) )
37 |             ];
38 |         }
39 |     }
40 | }
41 | 


--------------------------------------------------------------------------------