public void Paint(IActor actor, IWorldCoordinate coord, string text)
{
if (!Enabled)
{
return;
}
if (Brush == null)
{
return;
}
if (Radius <= 0)
{
return;
}
var sc = coord.ToScreenCoordinate(true, true);
var screenBorderPadding = Hud.Window.Size.Height * 0.01f;
var radius = RadiusTransformator != null?RadiusTransformator.TransformRadius(Radius) : Radius;
switch (Shape)
{
case GroundShape.X:
if (Brush.StrokeStyle.DashStyle == SharpDX.Direct2D1.DashStyle.Solid)
{
_shadowBrush.StrokeWidth = Brush.StrokeWidth >= 0 ? Brush.StrokeWidth + 1 : Brush.StrokeWidth - 1;
_shadowBrush.DrawWorldPlus(radius, coord.X, coord.Y, coord.Z);
}
Brush.DrawWorldPlus(radius, coord.X, coord.Y, coord.Z);
break;
}
}
public void Paint(IActor actor, IWorldCoordinate coord, string text)
{
if (!Enabled)
{
return;
}
if (Brush == null)
{
return;
}
if (Radius <= 0)
{
return;
}
if (ShapePainter == null)
{
return;
}
float x, y, radius;
CalculateCoordinateAndRadius(coord, out x, out y, out radius);
ShapePainter.Paint(x, y, radius, Brush, ShadowBrush);
}
public void Paint(IActor actor, IWorldCoordinate coord, string text)
{
if (!Enabled)
{
return;
}
var painter = Hud.GetPlugin <GroundLabelDecoratorPainterPlugin>();
if (painter == null)
{
return;
}
if ((CountDownFrom != null) && (actor != null))
{
var remaining = CountDownFrom.Value - ((Hud.Game.CurrentGameTick - actor.CreatedAtInGameTick) / 60.0f);
if (remaining < 0)
{
remaining = 0;
}
var vf = (remaining > 1.0f) ? "F0" : "F1";
text = remaining.ToString(vf, CultureInfo.InvariantCulture);
}
painter.EnqueLabelForPaint(this, coord, text);
}
/// <summary>
/// Paints the decorator.
/// </summary>
/// <param name="coord">The coordinate of the texture.</param>
/// <param name="text">Unused.</param>
public void Paint(IActor actor, IWorldCoordinate coord, string text)
{
if (!Enabled)
{
return;
}
if (SnoItem != null)
{
Texture = Hud.Texture.GetItemTexture(SnoItem);
}
if (Texture == null)
{
return;
}
if (Radius <= 0)
{
return;
}
CalculateCoordinateAndRadius(coord, out float mapX, out float mapY, out float radius);
var width = Texture.Width * radius;
var height = Texture.Height * radius;
Texture.Draw(mapX - width / 2, mapY - height / 2, width, height);
}
public void Paint(IActor actor, IWorldCoordinate coord, string text)
{
if (!Enabled)
{
return;
}
if (LabelFont == null)
{
return;
}
if (string.IsNullOrEmpty(text))
{
return;
}
float mapx, mapy;
Hud.Render.GetMinimapCoordinates(coord.X, coord.Y, out mapx, out mapy);
var layout = LabelFont.GetTextLayout(text);
if (!Up)
{
LabelFont.DrawText(layout, mapx - layout.Metrics.Width / 2, mapy + RadiusOffset);
}
else
{
LabelFont.DrawText(layout, mapx - layout.Metrics.Width / 2, mapy - RadiusOffset - layout.Metrics.Height);
}
}
public void Paint(IActor actor, IWorldCoordinate coord, string text)
{
if (!Enabled)
{
return;
}
if (Brush == null)
{
return;
}
if (Radius <= 0)
{
return;
}
if (ShapePainter == null)
{
return;
}
var radius = RadiusTransformator != null?RadiusTransformator.TransformRadius(Radius) : Radius;
var rotation = RotationTransformator != null?RotationTransformator.TransformRotation(Rotation) : Rotation;
ShapePainter.Paint(coord.X, coord.Y, coord.Z, radius, rotation, Brush, ShadowBrush);
}
public void Paint(IActor actor, IWorldCoordinate coord, string text)
{
if (!Enabled)
{
return;
}
if (!IsEnabledFunc.Invoke())
{
return;
}
if (Brush == null)
{
return;
}
if (Radius <= 0)
{
return;
}
var missingPercent = FilledPercentFunc == null
? 0f
: (100f - FilledPercentFunc.Invoke()) / 100f;
coord = actor == null
? coord
: actor.FloorCoordinate;
var sectionsCounts = SectionsCountFunc.Invoke(this);
Draw(coord, StartAngle, EndAngle, sectionsCounts, missingPercent, BackgroundBrush, Brush);
}
public void Paint(IActor actor, IWorldCoordinate coord, string text)
{
if (!Enabled)
{
return;
}
if (actor == null)
{
return;
}
var rad = Radius / 1200.0f * Hud.Window.Size.Height;
var max = CountDownFrom;
var elapsed = (Hud.Game.CurrentGameTick - actor.CreatedAtInGameTick) / 60.0f;
if (elapsed > max)
{
elapsed = max;
}
var screenCoord = coord.ToScreenCoordinate();
var startAngle = Convert.ToInt32(360 / max * elapsed) - 90;
var endAngle = 360 - 90;
using (var pg = Hud.Render.CreateGeometry())
{
using (var gs = pg.Open())
{
gs.BeginFigure(new Vector2(screenCoord.X, screenCoord.Y), FigureBegin.Filled);
for (int angle = startAngle; angle <= endAngle; angle++)
{
var mx = rad * (float)Math.Cos(angle * Math.PI / 180.0f);
var my = rad * (float)Math.Sin(angle * Math.PI / 180.0f);
var vector = new Vector2(screenCoord.X + mx, screenCoord.Y + my);
gs.AddLine(vector);
}
gs.EndFigure(FigureEnd.Closed);
gs.Close();
}
BackgroundBrushFill.DrawGeometry(pg);
}
using (var pg = Hud.Render.CreateGeometry())
{
using (var gs = pg.Open())
{
gs.BeginFigure(new Vector2(screenCoord.X, screenCoord.Y), FigureBegin.Filled);
for (int angle = endAngle; angle <= startAngle + 360; angle++)
{
var mx = rad * (float)Math.Cos(angle * Math.PI / 180.0f);
var my = rad * (float)Math.Sin(angle * Math.PI / 180.0f);
var vector = new Vector2(screenCoord.X + mx, screenCoord.Y + my);
gs.AddLine(vector);
}
gs.EndFigure(FigureEnd.Closed);
gs.Close();
}
BackgroundBrushEmpty.DrawGeometry(pg);
}
}
public int monsterDensityAroundCursor(float distance)
{
if (!Hud.Game.Me.IsInTown)
{
IScreenCoordinate coord = Hud.Game.Me.FloorCoordinate.ToScreenCoordinate(); //Hud.Render.GetCursorPos();
coord.X = Hud.Window.CursorX;
coord.Y = Hud.Window.CursorY;
IWorldCoordinate cursor = coord.ToWorldCoordinate();
int count = 0;
foreach (IMonster monster in Hud.Game.AliveMonsters)
{
if (monster.FloorCoordinate.XYDistanceTo(cursor) < distance)
{
count++;
}
}
if (drawCursorCircle)
{
cursorBrush.DrawWorldEllipse(distance, -1, cursor);
}
if (drawCursorLabel)
{
cursorDecorator.Paint(Hud.Window.CursorX - 10, Hud.Window.CursorY + 30, 50, 20, count.ToString(), null, "");
}
return(count);
}
return(0);
}
public DAV_WayPointSno(int act, uint areaSno, uint worldId, IWorldCoordinate mapCoord)
{
Act = act;
AreaSno = areaSno;
WorldId = worldId;
FloorCoordinate = mapCoord;
}
/// <summary>
/// Paints the decorator.
/// </summary>
/// <param name="coord">The coordinate of the texture.</param>
/// <param name="text">Unused.</param>
public void Paint(IActor actor, IWorldCoordinate coord, string text)
{
if (!Enabled || Radius <= 0)
{
return;
}
if (Texture == null)
{
if (SnoItem != null)
{
Texture = Hud.Texture.GetItemTexture(SnoItem);
}
if (Texture == null)
{
return;
}
}
CalculateCoordinateAndRadius(coord, out var mapX, out var mapY, out var radius);
var width = Texture.Width * radius;
var height = Texture.Height * radius;
Texture.Draw(mapX - (width / 2), mapY - (height / 2), width, height, OpacityMultiplier);
}
private static List <Vector2> ArcVectors(float radius, IWorldCoordinate coord, float start, float end, int sectionsCount)
{
var angleStep = (end - start) / sectionsCount;
var vectors = new List <Vector2>();
for (var angle = start; angle <= end; angle += angleStep)
{
if (angle + angleStep > end) //if it's the last step, round the end
{
angle = end;
}
//convert to radiant for ease of use, and set top == 0f, counter clockwise up to 360.
var radians = (angle - 135f) * Math.PI / 180.0f;
var cos = (float)Math.Cos(radians);
var sin = (float)Math.Sin(radians);
var mx = radius * cos;
var my = radius * sin;
var vector = coord.ToVector2(mx, my, 0);
vectors.Add(vector);
}
return(vectors);
}
private IWorldCoordinate PointOnLine(IWorldCoordinate s, IWorldCoordinate t, float yards)
{
float distance = (float)Math.Sqrt(Math.Pow((t.X - s.X), 2) + Math.Pow((t.Y - s.Y), 2));
float ratio = yards / distance;
float x3 = ratio * t.X + (1 - ratio) * s.X;
float y3 = ratio * t.Y + (1 - ratio) * s.Y;
return(Hud.Window.CreateWorldCoordinate(x3, y3, Hud.Game.Me.FloorCoordinate.Z));
}
public void CalculateCoordinateAndRadius(IWorldCoordinate coord, out float mapX, out float mapY, out float radius)
{
Hud.Render.GetMinimapCoordinates(coord.X, coord.Y, out mapX, out mapY);
radius = Radius * Hud.Render.MinimapScale;
if (RadiusTransformator != null)
{
radius = RadiusTransformator.TransformRadius(radius);
}
}
public void Paint(IActor actor, IWorldCoordinate coord, string text)
{
if (!Enabled || Brush == null || Radius <= 0 || ShapePainter == null)
{
return;
}
CalculateCoordinateAndRadius(coord, out var x, out var y, out var radius);
ShapePainter.Paint(x, y, radius, Brush, ShadowBrush);
}
public static void DrawWorldCirclePartial(this IBrush brush,
float radius, int sectionsCount, float stroke,
IWorldCoordinate coord,
float startAngle, float endAngle,
CapStyle endCapStyle = CapStyle.Flat, CapStyle startCapStyle = CapStyle.Flat,
float missingPercent = 0, IBrush bgBrush = null)
{
var fullAngleRange = endAngle - startAngle;
var halfRange = fullAngleRange / 2f;
var halfStroke = stroke / 2f;
var start = Math.Max(startAngle, startAngle + halfRange * missingPercent);
var end = Math.Min(endAngle, endAngle - halfRange * missingPercent);
if (start > end || start < 0 || end < 0 || start > 360)
{
return;
}
using (var pg = Hud.Render.CreateGeometry())
{
using (var gs = pg.Open())
{
var outerVectors = ArcVectors(radius + halfStroke, coord, start, end, sectionsCount);
var innerVectors = ArcVectors(radius - halfStroke, coord, start, end, sectionsCount);
gs.BeginFigure(outerVectors.First(), FigureBegin.Filled);
foreach (var v in outerVectors.Skip(1))
{
gs.AddLine(v);
}
//TODO: if rounded cap, add half circle
innerVectors.Reverse();
foreach (var v in innerVectors)
{
gs.AddLine(v);
}
//TODO: if rounded cap, add half circle
gs.EndFigure(FigureEnd.Closed);
gs.Close();
if (bgBrush != null)
{
bgBrush.DrawGeometry(pg);
}
brush.DrawGeometry(pg);
}
}
}
public void Paint(IActor actor, IWorldCoordinate coord, string text)
{
if (!Enabled)
{
return;
}
if (actor == null)
{
return;
}
SoundAlertManagerPlugin.Register <T>(actor, SoundAlert);
}
public void Paint(WorldLayer layer, IActor actor, IWorldCoordinate coord, string text)
{
if (!Enabled)
{
return;
}
foreach (var decorator in Decorators)
{
if (decorator.Enabled && (decorator.Layer == layer))
{
decorator.Paint(actor, coord, text);
}
}
}
public void PaintWorld(WorldLayer layer)
{
if (!Hud.Game.Me.IsInTown)
{
IScreenCoordinate coord = Hud.Window.CreateScreenCoordinate(Hud.Window.CursorX, Hud.Window.CursorY);
IWorldCoordinate cursor = coord.ToWorldCoordinate();
int count = 0;
foreach (IMonster monster in Hud.Game.AliveMonsters)
{
if (monster.FloorCoordinate.XYDistanceTo(cursor) < Distance)
{
count++;
}
}
if (DrawCursorCircle)
{
CursorCircleBrush.DrawWorldEllipse(Distance, -1, cursor);
}
if (DrawCursorLabel)
{
float width = Hud.Window.Size.Height * CursorLabelWRatio;
float height = Hud.Window.Size.Height * CursorLabelHRatio;
CursorLabelDecorator.Paint(coord.X + CursorLabelXOffset, coord.Y + CursorLabelYOffset, width, height, count.ToString(), null, "");
}
if (DrawTopLabel)
{
float x = Hud.Window.Size.Width * TopLabelXRatio;
float y = Hud.Window.Size.Height * TopLabelYRatio;
float width = Hud.Window.Size.Height * TopLabelWRatio;
float height = Hud.Window.Size.Height * TopLabelHRatio;
TopLabelDecorator.Paint(x - width / 2, y, width, height, count.ToString(), null, "");
}
if (DrawCursorLine)
{
var player = Hud.Game.Me.ScreenCoordinate;
LineBrush.DrawLine(player.X, player.Y, coord.X, coord.Y);
}
if (DrawDistanceLabel)
{
var distance = Hud.Game.Me.FloorCoordinate.XYDistanceTo(cursor);
float x = Hud.Window.Size.Width * DistanceLabelXRatio;
float y = Hud.Window.Size.Height * DistanceLabelYRatio;
float width = Hud.Window.Size.Height * DistanceLabelWRatio;
float height = Hud.Window.Size.Height * DistanceLabelHRatio;
TopLabelDecorator.Paint(x - width / 2, y, width, height, distance.ToString("F1", CultureInfo.InvariantCulture));
}
}
}
public int monsterDensityAroundPlayer(float distance)
{
if (!Hud.Game.Me.IsInTown)
{
IWorldCoordinate me = Hud.Game.Me.FloorCoordinate;
int count = 0;
foreach (IMonster monster in Hud.Game.AliveMonsters)
{
if (monster.FloorCoordinate.XYDistanceTo(me) < distance)
{
count++;
}
}
return(count);
}
return(0);
}
private void DrawTargetLine(IWorldCoordinate awc, IWorldCoordinate twc, IMonster m, IMonster target)
{
IBrush cBrush = GreyBrush;
if (m != null && target != null)
{
if (m.AnnId == target.AnnId)
{
cBrush = GreenBrush;
}
else
{
cBrush = RedBrush;
RedHitBoxDecorator.Paint(_layer, m, m.FloorCoordinate, string.Empty);
}
}
cBrush.DrawLineWorld(awc, PointOnLine(awc, twc, HitYards), 4f);
}
private IWorldCoordinate[] PointOnOrthogonal(IWorldCoordinate swc, IWorldCoordinate twc, float offset)
{
float m = (twc.Y - swc.Y) / (twc.X - swc.X);
float orthm = -1 * (1 / m);
float yoff = twc.Y - orthm * twc.X;
float x3 = (float)((twc.X * Math.Pow(orthm, 2) + twc.X - Math.Sqrt(Math.Pow(offset, 2) * Math.Pow(orthm, 2) + Math.Pow(offset, 2))) / (Math.Pow(orthm, 2) + 1));
float x4 = (float)((twc.X * Math.Pow(orthm, 2) + twc.X + Math.Sqrt(Math.Pow(offset, 2) * Math.Pow(orthm, 2) + Math.Pow(offset, 2))) / (Math.Pow(orthm, 2) + 1));
float y3 = orthm * x3 + yoff;
float y4 = orthm * x4 + yoff;
IWorldCoordinate[] x =
{
Hud.Window.CreateWorldCoordinate(x3, y3, Hud.Game.Me.FloorCoordinate.Z),
Hud.Window.CreateWorldCoordinate(x4, y4, Hud.Game.Me.FloorCoordinate.Z)
};
return(x);
}
public void DrawSplit(IWorldCoordinate pwc, IWorldCoordinate mwc, IWorldCoordinate awc, IMonster target, List <IMonster> obstacles)
{
//get middle impale
IWorldCoordinate middlewc = PointOnLine(awc, mwc, AdjacentYards);
//get left and right impales
IWorldCoordinate[] lr = PointOnOrthogonal(awc, middlewc, OppositeYards);
//sort obstacles by distance
if (target != null)
{
obstacles.Add(target);
}
if (obstacles.Any())
{
obstacles.Sort((x, y) => x.NormalizedXyDistanceToMe.CompareTo(y.NormalizedXyDistanceToMe));
}
//get first target for each impale projectile
float distance = (target != null) ? (float)target.NormalizedXyDistanceToMe + 2 * target.RadiusBottom : 0;
IMonster tm = FirstTarget(pwc, middlewc, obstacles, distance);
IMonster tlr0 = FirstTarget(pwc, lr[0], obstacles, distance);
IMonster tlr1 = FirstTarget(pwc, lr[1], obstacles, distance);
//draw targetline for each impale and for maintarge
if (target != null)
{
BlueBrush.DrawLineWorld(awc, target.FloorCoordinate, 4f);
}
DrawTargetLine(awc, middlewc, tm, target);
DrawTargetLine(awc, lr[0], tlr0, target);
DrawTargetLine(awc, lr[1], tlr1, target);
//draw target hitbox
if (target != null && tm != null && tlr0 != null && tlr1 != null && target.AnnId == tm.AnnId && target.AnnId == tlr0.AnnId && target.AnnId == tlr1.AnnId)
{
GreenHitBoxDecorator.Paint(_layer, target, target.FloorCoordinate, string.Empty);
}
else if (target != null)
{
BlueHitBoxDecorator.Paint(_layer, target, target.FloorCoordinate, string.Empty);
}
}
public void Paint(IActor actor, IWorldCoordinate coord, string text)
{
if (!Enabled)
{
return;
}
if (ActiveBrush == null || InactiveBrush == null)
{
return;
}
var distance = actor.NormalizedXyDistanceToMe;
if (distance <= HideRange)
{
return;
}
var monsterCoord = coord.ToScreenCoordinate();
var myCoords = Hud.Game.Me.ScreenCoordinate;
//Draw line to actor
var start = PointOnLine(myCoords.X, myCoords.Y, monsterCoord.X, monsterCoord.Y, OnLineStartOffset);
var end = PointOnLine(monsterCoord.X, monsterCoord.Y, myCoords.X, myCoords.Y, OnLineEndOffset);
if (distance < ActiveRange)
{
ActiveBrush.DrawLine(start.X, start.Y, end.X, end.Y, ActiveStrokeWidth);
}
else
{
InactiveBrush.DrawLine(start.X, start.Y, end.X, end.Y, InactiveStrokeWidth);
}
if (ShowText) //Draw text
{
var layout = TextFont.GetTextLayout(string.Format("{0:N0}", distance));
var p = PointOnLine(myCoords.X, myCoords.Y, monsterCoord.X, monsterCoord.Y, TextOffset);
TextFont.DrawText(layout, p.X, p.Y);
//textDistanceAway += 30; // avoid text overlap
}
}
internal void EnqueLabelForPaint(GroundLabelDecorator decorator, IWorldCoordinate coord, string text)
{
if (string.IsNullOrEmpty(text))
{
return;
}
if (!_registeredLabels.TryGetValue(coord, out var list))
{
list = new List <RegisteredLabel>();
_registeredLabels.Add(coord, list);
}
list.Add(new RegisteredLabel()
{
Decorator = decorator,
Coord = coord,
Text = text
});
}
public void Paint(IActor actor, IWorldCoordinate coord, string text)
{
if (!Enabled)
{
return;
}
if (Brush == null)
{
return;
}
var radius = Radius;
if (radius == -1)
{
if (actor != null)
{
radius = Math.Min(actor.RadiusBottom, 20);
}
else
{
return;
}
}
if (RadiusTransformator != null)
{
radius = RadiusTransformator.TransformRadius(radius);
}
if (HasShadow)
{
if (Brush.StrokeStyle.DashStyle == SharpDX.Direct2D1.DashStyle.Solid)
{
_shadowBrush.StrokeWidth = Brush.StrokeWidth >= 0 ? Brush.StrokeWidth + 1 : Brush.StrokeWidth - 1;
_shadowBrush.DrawWorldEllipse(radius, -1, coord);
}
}
Brush.DrawWorldEllipse(radius, -1, coord);
}
private IMonster FirstTarget(IWorldCoordinate s, IWorldCoordinate t, List <IMonster> obstacles, float distance)
{
IMonster r = null;
IWorldCoordinate c = null;
foreach (IMonster m in obstacles)
{
float d = 0f;
while (d <= distance)
{
c = PointOnLine(s, t, d);
if (m.FloorCoordinate.XYDistanceTo(c) <= m.RadiusBottom)
{
r = m;
break;
}
d += 0.1f;
}
}
return(r);
}
public void PaintWorld(WorldLayer layer)
{
//if (!IsNephalemRift || !IsGreaterRift || Hud.Game.Me.HeroClassDefinition.HeroClass != HeroClass.DemonHunter) return;
if (Hud.Game.Me.HeroClassDefinition.HeroClass != HeroClass.DemonHunter)
{
return;
}
_layer = layer;
//get player, mouse, animation-start coordinates
IWorldCoordinate player = Hud.Game.Me.ScreenCoordinate.ToWorldCoordinate();
IWorldCoordinate mouse = Hud.Window.CreateScreenCoordinate(Hud.Window.CursorX, Hud.Window.CursorY).ToWorldCoordinate();
IWorldCoordinate anim = PointOnLine(player, mouse, AnimationYards);
//get closest elite/boss target
var elites = Hud.Game.AliveMonsters.Where(x => (x.Rarity == ActorRarity.Boss || x.Rarity == ActorRarity.Champion || x.Rarity == ActorRarity.Rare) &&
x.IsOnScreen &&
x.NormalizedXyDistanceToMe <= HitYards
).ToList();
elites.Sort((x, y) => x.NormalizedXyDistanceToMe.CompareTo(y.NormalizedXyDistanceToMe));
var target = elites.FirstOrDefault();
//no targets in area
if (target == null || !target.FloorCoordinate.IsValid)
{
return;
}
//get all possible intercepting obstacles
var trash = Hud.Game.AliveMonsters.Where(x => x.FloorCoordinate.IsValid &&
x.IsOnScreen &&
!(x.Rarity == ActorRarity.Boss || x.Rarity == ActorRarity.Champion || x.Rarity == ActorRarity.Rare) &&
x.NormalizedXyDistanceToMe <= target.NormalizedXyDistanceToMe &&
target.FloorCoordinate.XYDistanceTo(x.FloorCoordinate) <= target.NormalizedXyDistanceToMe
);
//draw split
DrawSplit(player, mouse, anim, target, trash.ToList());
}
public static Vector2 ToVector2(this IWorldCoordinate coords, float offsetWorldX = 0, float offsetWorldY = 0, float offsetWorldZ = 0, float translateX = 0, float translateY = 0)
{
offsetWorldX += coords.X;
offsetWorldY += coords.Y;
offsetWorldZ += coords.Z;
var referer = Hud.Game.Me.FloorCoordinate;
var xd = offsetWorldX - referer.X;
var yd = offsetWorldY - referer.Y;
var zd = offsetWorldZ - referer.Z;
var w = -0.515 * xd + -0.514 * yd + -0.686 * zd + 97.985;
var X = (-1.682 * xd + 1.683 * yd + 0 * zd + 7.045e-3) / w;
var Y = (-1.54 * xd + -1.539 * yd + 2.307 * zd + 6.161) / w;
var aspectChange = coords.Window.Size.Width / (double)coords.Window.Size.Height / (4.0f / 3.0f); // 4:3 = default aspect ratio
X /= aspectChange;
var rX = (float)((X + 1) / 2 * coords.Window.Size.Width);
var rY = (float)((1 - Y) / 2 * coords.Window.Size.Height);
return(new Vector2(rX + translateX, rY + translateY));
}
public void PaintWorld(WorldLayer layer)
{
if (Hud.Game.IsInTown)
{
return;
}
IWorldCoordinate WizPosition = Hud.Game.Players.First().FloorCoordinate;
int WizardsIngame = 0;
foreach (var player in Hud.Game.Players)
{
if (player.HeroClassDefinition.HeroClass == HeroClass.Wizard)
{
WizPosition = player.FloorCoordinate;
WizardsIngame++;
}
}
float mindist = float.MaxValue;
var actors = Hud.Game.Actors.Where(x => x.SnoActor.Sno == ActorSnoEnum._generic_proxy && x.GetAttributeValueAsInt(Hud.Sno.Attributes.Power_Buff_1_Visual_Effect_None, Hud.Sno.SnoPowers.OculusRing.Sno) == 1);
if (actors.Count() > 0)
{
var closest = actors.First();
foreach (var actor in actors)
{
float dist = actor.FloorCoordinate.XYDistanceTo(WizPosition);
if (dist < mindist)
{
closest = actor;
mindist = dist;
}
}
foreach (var actor in actors)
{
if (WizardsIngame == 1)
{
if (actor == closest)
{
if (mindist < 13.3f)
{
DecoratorInside.Paint(layer, actor, actor.FloorCoordinate, null);
}
else
{
DecoratorClosest.Paint(layer, actor, actor.FloorCoordinate, null);
}
}
else
{
DecoratorBase.Paint(layer, actor, actor.FloorCoordinate, null);
}
}
else
{
DecoratorBase.Paint(layer, actor, actor.FloorCoordinate, null);
}
}
}
}
