private void OnDraw()
{
try
{
var startPosition = GameManager.MouseScreenPosition + this.textPosition;
foreach (var ability in this.timings.Where(x => x.Display))
{
var textureSize = new Vector2(this.textSize * Hud.Info.ScreenRatio * 1.75f);
var outlineSize = textureSize * 1.17f;
var outlinePosition = startPosition - new Vector2(
(outlineSize.X - textureSize.X) / 2f,
(outlineSize.Y - textureSize.Y) / 2f);
RendererManager.DrawTexture("o9k.outline", new RectangleF(outlinePosition.X, outlinePosition.Y, outlineSize.X, outlineSize.Y));
RendererManager.DrawTexture(ability.Name, new RectangleF(startPosition.X, startPosition.Y, textureSize.X, textureSize.Y), TextureType.RoundAbility);
RendererManager.DrawText(
ability.Time,
startPosition + new Vector2(textureSize.X * 1.2f, 0),
ability.Color,
this.textSize * Hud.Info.ScreenRatio);
startPosition += new Vector2(0, textureSize.Y * 1.2f);
}
}
catch (InvalidOperationException)
{
// ignore
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void OnDraw()
{
try
{
if (this.BallLightning == null || this.ballLightning.Level <= 0 || !this.ballLightning.Owner.IsAlive)
{
return;
}
var mousePosition = GameManager.MousePosition;
var mp = this.menu.ShowRemainingMp
? this.BallLightning.GetRemainingMana(mousePosition).ToString()
: this.BallLightning.GetRequiredMana(mousePosition).ToString();
RendererManager.DrawText(
mp,
GameManager.MouseScreenPosition + (new Vector2(30, 30) * Hud.Info.ScreenRatio),
Color.White,
16 * Hud.Info.ScreenRatio);
}
catch (Exception exception)
{
Logger.Error(exception);
}
}
public virtual void Draw()
{
var backgroundColor = new Color(50, 50, 50, 200);
RendererManager.DrawFilledRectangle(new RectangleF(this.position.X, this.position.Y, this.buttonSize.X, this.buttonSize.Y), this.IsMouseUnderButton() ? backgroundColor.SetAlpha(255) : backgroundColor);
RendererManager.DrawText(this.name, this.textPosition, Color.DeepSkyBlue, "Arial", this.textSize);
}
public void Draw(Rectangle9 position, float textSize)
{
try
{
RendererManager.DrawTexture(this.texture, position);
RendererManager.DrawRectangle(position - 1, Color.Black);
if (this.level == 0)
{
RendererManager.DrawTexture("o9k.ability_0lvl_bg", position);
return;
}
if (this.cooldown <= 0)
{
return;
}
RendererManager.DrawTexture("o9k.ability_cd_bg", position);
RendererManager.DrawText(
Math.Ceiling(this.RemainingCooldown).ToString("N0"),
position,
Color.White,
FontFlags.Center | FontFlags.VerticalCenter,
textSize);
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void DrawIntersections()
{
try
{
foreach (var unit in EntityManager9.Units.Where(x => x.IsHero && x.IsAlive && x.IsAlly(this.owner.Team)).ToList())
{
var obstacles = this.pathfinder.GetIntersectingObstacles(unit).ToList();
if (obstacles.Count == 0)
{
continue;
}
var position = RendererManager.WorldToScreen(unit.Position);
if (position.IsZero)
{
continue;
}
foreach (var obstacle in obstacles)
{
RendererManager.DrawText(
obstacle.EvadableAbility.Ability.DisplayName + " (" + obstacle.Id + ") " + obstacle.GetEvadeTime(unit, false).ToString("n2"),
(position += new Vector2(0, 20)) + new Vector2(-120, 0),
this.actionManager.IsObstacleIgnored(unit, obstacle) ? Color.Gray : Color.White,
"Arial",
TextSize);
}
}
}
catch
{
//ignored
}
}
public override void DrawOnMap(IMinimap minimap)
{
var position = minimap.WorldToScreen(this.Position, 30 * Hud.Info.ScreenRatio);
if (position.IsZero)
{
return;
}
var pct = (int)((GameManager.RawGameTime - this.AddedTime) / this.Duration * 100);
RendererManager.DrawTexture("o9k.outline_red", position * 1.2f);
RendererManager.DrawTexture("o9k.outline_black" + pct, position * 1.25f);
RendererManager.DrawTexture(this.AbilityTexture, position, TextureType.RoundAbility);
position.Y += 30 * Hud.Info.ScreenRatio;
position *= 2;
RendererManager.DrawText(
TimeSpan.FromSeconds(this.Duration - (GameManager.RawGameTime - this.AddedTime)).ToString(@"m\:ss"),
position,
Color.White,
FontFlags.Center | FontFlags.VerticalCenter,
18 * Hud.Info.ScreenRatio);
}
public void DrawOnMap(IMinimap minimap)
{
var position = minimap.WorldToScreen(this.teleportPosition, 45 * Hud.Info.ScreenRatio);
if (position.IsZero)
{
return;
}
RendererManager.DrawTexture("o9k.outline_red", position * 1.12f);
RendererManager.DrawTexture(this.mapTexture, position, TextureType.RoundUnit);
var abilityTexturePosition = position * 0.5f;
abilityTexturePosition.X += abilityTexturePosition.Width * 0.8f;
abilityTexturePosition.Y += abilityTexturePosition.Height * 0.6f;
RendererManager.DrawTexture("o9k.outline_green_pct100", abilityTexturePosition * 1.2f);
RendererManager.DrawTexture(AbilityTexture, abilityTexturePosition, TextureType.RoundAbility);
position.Y += 50 * Hud.Info.ScreenRatio;
RendererManager.DrawText(
this.RemainingDuration.ToString("N1"),
position,
Color.White,
FontFlags.Center,
18 * Hud.Info.ScreenRatio);
}
private void OnDraw()
{
if (!RoshanMenu.PanelItem)
{
return;
}
var textureSize = new Vector2(320, 72) * RendererManager.Scaling;
if (RoshanDead)
{
RendererManager.DrawTexture("Divine.BeAware.Resources.Textures.roshan_dead.png", new RectangleF(RoshanPanelPosition.X, RoshanPanelPosition.Y, textureSize.X, textureSize.Y));
RendererManager.DrawText(RoshanTextTimer, RoshanPanelPosition + (new Vector2(86, 12) * RendererManager.Scaling), Color.Red, 40 * RendererManager.Scaling);
if (AegisWasFound && RoshanMenu.AegisItem)
{
RendererManager.DrawText(AegisTextTimer, RoshanPanelPosition + (new Vector2(148, 44) * RendererManager.Scaling), Color.Aqua, 28 * RendererManager.Scaling);
}
}
else
{
RendererManager.DrawTexture("Divine.BeAware.Resources.Textures.roshan_alive.png", new RectangleF(RoshanPanelPosition.X, RoshanPanelPosition.Y, textureSize.X, textureSize.Y));
RendererManager.DrawText("Roshan Alive", RoshanPanelPosition + (new Vector2(86, 12) * RendererManager.Scaling), Color.Aqua, 40 * RendererManager.Scaling);
}
}
private static void OnDraw()
{
try
{
if (Messages.Count == 0)
{
RendererManager.Draw -= OnDraw;
}
var position = new Vector2(Info.ScreenSize.X * 0.13f, Info.ScreenSize.Y * 0.05f);
foreach (var message in Messages.ToList())
{
var text = message.Key;
var time = message.Value;
if (GameManager.RawGameTime > time)
{
Messages.Remove(text);
continue;
}
position += new Vector2(0, 35);
RendererManager.DrawText(text, position, Color.OrangeRed, 33 * Info.ScreenRatio);
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
protected override void Draw()
{
var keyPosition = new Vector2(
(this.Position.X + this.Size.X) - this.MenuStyle.RightIndent - this.keyTextSize.X,
this.Position.Y + ((this.Size.Y - this.MenuStyle.TextSize) / 3.3f));
//key background
if (this.IsActive)
{
RendererManager.DrawLine(
this.Position + new Vector2(this.Size.X - (this.keyTextSize.X + (this.MenuStyle.RightIndent * 2)), this.Size.Y / 2),
this.Position + new Vector2(this.Size.X, this.Size.Y / 2),
this.MenuStyle.BackgroundColor,
this.Size.Y);
}
base.Draw();
//key
RendererManager.DrawText(
this.changingKey ? "?" : this.keyText,
keyPosition,
Color.White,
this.MenuStyle.Font,
this.MenuStyle.TextSize);
}
private void OnDraw()
{
try
{
foreach (var stack in this.stacks)
{
if (stack.Value <= 1)
{
continue;
}
var size = 16 * Hud.Info.ScreenRatio;
var minimapPosition = this.minimap.WorldToMinimap(stack.Key, size);
RendererManager.DrawText(
stack.Value.ToString(),
minimapPosition + new Size2F(size, 0),
Color.Orange,
FontFlags.Left,
size);
}
}
catch (InvalidOperationException)
{
//ignore
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void OnDraw()
{
try
{
var rune = EntityManager.GetEntities <Rune>()
.Where(x => x.IsValid)
.OrderBy(x => x.Position.DistanceSquared(GameManager.MousePosition))
.FirstOrDefault();
if (rune == null || !Hud.IsPositionOnScreen(rune.Position))
{
return;
}
var allies = EntityManager9.Heroes.Where(x => !x.IsMyHero && !x.IsIllusion && x.IsAlly() && x.IsAlive);
var textureSize = 45 * Hud.Info.ScreenRatio;
var margin = 20 * Hud.Info.ScreenRatio;
var position = this.minimap.WorldToScreen(rune.Position, textureSize);
foreach (var hero in allies)
{
var bottle = hero.Abilities.FirstOrDefault(x => x.Id == AbilityId.item_bottle);
if (bottle == null)
{
continue;
}
position.Y += textureSize + margin;
RendererManager.DrawTexture(hero.Name, position, TextureType.RoundUnit);
var outlinePosition = position * 1.25f;
RendererManager.DrawTexture("o9k.outline_hp", outlinePosition);
RendererManager.DrawTexture("o9k.outline_black" + (int)(100 - (hero.HealthPercentage / 2f)), outlinePosition);
RendererManager.DrawTexture("o9k.outline_mp" + (int)(hero.ManaPercentage / 2f), outlinePosition);
var chargesText = bottle.Charges.ToString("N0");
var chargesPosition = position.SinkToBottomRight(position.Width * 0.4f, position.Height * 0.4f);
RendererManager.DrawTexture("o9k.charge_bg", chargesPosition);
RendererManager.DrawTexture("o9k.outline_green", chargesPosition * 1.07f);
RendererManager.DrawText(
chargesText,
chargesPosition,
Color.White,
FontFlags.Center | FontFlags.VerticalCenter,
position.Width * 0.3f);
}
}
catch (InvalidOperationException)
{
// ignored
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void DrawingOnDraw()
{
var pos = GameManager.MousePosition;
RendererManager.DrawText(
pos.ToCopyFormat(),
GameManager.MouseScreenPosition + new Vector2(35, 0),
Color.White,
"Arial",
20);
}
private void OnDraw(EventArgs args)
{
if (this.canToggle)
{
RendererManager.DrawText(
"Can toggle",
RendererManager.WorldToScreen(this.Owner.Position),
Color.White,
"Arial",
25);
}
}
public void DrawMinimalistic(Rectangle9 position, float cooldownSize)
{
try
{
RendererManager.DrawTexture("o9k.ability_minimal_bg", position);
var levelHeight = position.Height * 0.2f;
var cooldown = this.Ability.RemainingCooldown;
if (cooldown > 0)
{
position = position.MoveTopBorder(cooldownSize * 0.8f);
RendererManager.DrawTexture("o9k.ability_minimal_cd_bg", position);
RendererManager.DrawText(
Math.Ceiling(cooldown).ToString("N0"),
position.MoveTopBorder(cooldownSize * 0.2f),
Color.White,
FontFlags.Center | FontFlags.VerticalCenter,
cooldownSize);
}
else if (this.Ability.ManaCost > this.Ability.Owner.Mana)
{
position = position.MoveTopBorder(cooldownSize * 0.8f);
RendererManager.DrawTexture("o9k.ability_minimal_mana_bg", position);
RendererManager.DrawText(
Math.Ceiling((this.Ability.ManaCost - this.Ability.Owner.Mana) / this.Ability.Owner.ManaRegeneration)
.ToString("N0"),
position.MoveTopBorder(cooldownSize * 0.2f),
Color.White,
FontFlags.Center | FontFlags.VerticalCenter,
cooldownSize);
}
RendererManager.DrawRectangle(position - 1, this.Ability.IsCasting ? Color.LightGreen : Color.Black);
var rec = position - 5;
var levelWidth = rec.Width / this.maxLevel;
var space = levelWidth * 0.05f;
var posY = rec.Bottom - levelHeight;
var levelDrawWidth = levelWidth - (space * 2);
var lvl = this.Ability.Level;
for (var i = 0; i < lvl; i++)
{
var lvlPos = new Rectangle9(rec.X + space, posY, levelDrawWidth, levelHeight);
RendererManager.DrawTexture("o9k.ability_level_rec", lvlPos);
rec = rec.MoveLeftBorder(levelWidth);
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
protected override void HpBar(int health, int maximumHealth, float healthPerc, Vector2 hpBarPosition)
{
if (!HpBarMenu.HpBarValueItem)
{
return;
}
var hpText = $"{health}/{maximumHealth}";
var sizeText = 12.5f * HUDInfo.RatioPercentage;
var measureText = RendererManager.MeasureText(hpText, sizeText);
RendererManager.DrawText(hpText, HpBarUtils.HpBarValuePosition(hpBarPosition, measureText.X), Color.WhiteSmoke, sizeText);
}
private void OnDraw()
{
try
{
var heroPosition = this.position.Value;
foreach (var pair in this.units.OrderByDescending(x => x.Value))
{
var unit = pair.Key;
if (!unit.IsValid)
{
continue;
}
if (unit.Team == this.ownerTeam)
{
if (!this.allies)
{
continue;
}
RendererManager.DrawTexture("o9k.net_worth_bg_ally", new RectangleF(heroPosition.X, heroPosition.Y, this.lineSize.X, this.lineSize.Y));
}
else
{
if (!this.enemies)
{
continue;
}
RendererManager.DrawTexture("o9k.net_worth_bg_enemy", new RectangleF(heroPosition.X, heroPosition.Y, this.lineSize.X, this.lineSize.Y));
}
RendererManager.DrawTexture(unit.Name, new RectangleF(heroPosition.X, heroPosition.Y, this.heroSize.X, this.heroSize.Y), UnitTextureType.Default);
RendererManager.DrawText(
pair.Value.ToString("N0"),
heroPosition + new Vector2(this.heroSize.X + 5, (this.lineSize.Y - this.textSize) / 5),
Color.White,
this.textSize);
heroPosition += new Vector2(0, this.heroSize.Y + 1);
}
}
catch (InvalidOperationException)
{
//ignore
}
catch (Exception e)
{
Logger.Error(e);
}
}
public static void DrawTextWithBackground(string text, float size, Vector2 position)
{
var measureText = RendererManager.MeasureText(text, size);
position -= new Vector2(measureText.X / 2, 0);
var bgPosition = position + new Vector2(0, measureText.Y / 2);
RendererManager.DrawLine(
bgPosition - new Vector2(2, 0),
bgPosition + new Vector2(measureText.X + 2, 0),
new Color(5, 25, 25, 150),
measureText.Y);
RendererManager.DrawText(text, position, Color.White, size);
}
public void DrawMenu()
{
this.Size = new Vector2(this.ChildWidth, this.MenuStyle.Height * 0.75f);
RendererManager.DrawLine(
this.MenuPosition + new Vector2(0, this.Size.Y / 2),
this.MenuPosition + new Vector2(this.Size.X, this.Size.Y / 2),
this.MenuStyle.HeaderBackgroundColor,
this.Size.Y);
var textPosition = new Vector2(
(this.MenuPosition.X + this.ChildWidth) - this.DisplayNameSize.X - this.MenuStyle.RightIndent,
this.MenuPosition.Y + ((this.Size.Y - this.MenuStyle.TextSize) / 4));
var iconSize = new Vector2(8, 14) * Hud.Info.ScreenRatio;
var iconPosition = new Vector2(
textPosition.X - (6 * Hud.Info.ScreenRatio),
this.menuPosition.Y + ((this.Size.Y - iconSize.Y) / 2));
for (var i = 1; i <= this.MenuItems.Count; i++)
{
RendererManager.DrawTexture(this.MenuStyle.TextureIconKey, new RectangleF(iconPosition.X - iconSize.X * i, iconPosition.Y, iconSize.X, iconSize.Y));
}
RendererManager.DrawText(this.DisplayName, textPosition, Color.White, this.MenuStyle.Font, this.MenuStyle.TextSize);
var position = this.MenuPosition + new Vector2(0, this.Size.Y);
for (var i = 0; i < this.MenuItems.Count; i++)
{
var menuItem = this.MenuItems[i];
menuItem.OnDraw(position, this.ChildWidth);
// line
if (i < this.MenuItems.Count)
{
RendererManager.DrawLine(
position,
position + new Vector2(this.ChildWidth, 0),
this.MenuStyle.MenuSplitLineColor,
this.MenuStyle.MenuSplitLineSize);
}
position += new Vector2(0, this.MenuStyle.Height);
}
}
protected virtual void Draw()
{
//background
RendererManager.DrawLine(
this.Position + new Vector2(0, this.Size.Y / 2),
this.Position + new Vector2(this.Size.X, this.Size.Y / 2),
this.MenuStyle.BackgroundColor,
this.Size.Y);
var pct = Math.Min(GameManager.RawGameTime - this.hooverTime, 0.3f) / 0.3f;
int alpha;
const int MinAlpha = 170;
if (this.isHoovered || (this is Menu menu && !menu.IsCollapsed))
{
alpha = (int)((pct * (255 - MinAlpha)) + MinAlpha);
//tooltip
if (!string.IsNullOrEmpty(this.Tooltip))
{
var tooltipTextSize = RendererManager.MeasureText(this.Tooltip, this.MenuStyle.Font, this.MenuStyle.TooltipTextSize);
RendererManager.DrawFilledRectangle(
new RectangleF(
this.Position.X + this.Size.X + this.MenuStyle.LeftIndent,
this.Position.Y + (tooltipTextSize.Y / 4f),
tooltipTextSize.X + this.MenuStyle.LeftIndent + this.MenuStyle.RightIndent,
tooltipTextSize.Y),
new Color(5, 5, 5, 200),
new Color(50, 50, 50, 255),
1);
RendererManager.DrawText(
this.Tooltip,
new RectangleF(
this.Position.X + this.Size.X + (this.MenuStyle.LeftIndent * 2),
this.Position.Y + (tooltipTextSize.Y / 4f),
tooltipTextSize.X,
this.Size.Y),
Color.White,
FontFlags.Left,
this.MenuStyle.TooltipTextSize);
}
}
private void OnDraw()
{
try
{
foreach (var wave in this.creepWaves)
{
if (!wave.IsSpawned || wave.IsVisible)
{
continue;
}
var position = wave.PredictedPosition;
var count = wave.Creeps.Count.ToString();
if (this.showOnMinimap)
{
var size = 19 * Hud.Info.ScreenRatio;
var minimapPosition = this.minimap.WorldToMinimap(position, size);
RendererManager.DrawText(count, minimapPosition + new Size2F(size, 0), Color.OrangeRed, FontFlags.Left, size);
}
if (this.showOnMap)
{
var size = 32 * Hud.Info.ScreenRatio;
var mapPosition = this.minimap.WorldToScreen(position, size);
if (mapPosition.IsZero)
{
continue;
}
RendererManager.DrawText(count, mapPosition + new Size2F(size, 0), Color.OrangeRed, FontFlags.Left, size);
}
}
}
catch (InvalidOperationException)
{
// ignored
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void OnDraw()
{
try
{
var diff = this.teams[Team.Radiant] - this.teams[Team.Dire];
string text;
Team team;
if (diff > 0)
{
text = Math.Ceiling(diff / 1000f) + "k";
team = Team.Radiant;
}
else
{
text = Math.Ceiling(diff / -1000f) + "k";
team = Team.Dire;
}
var ratio = Hud.Info.ScreenRatio;
var position = this.topPanel.GetScorePosition(team);
position.Y += position.Height + 1;
position.Height = 22f * ratio;
var textSize = 15 * ratio;
var measureText = (position.Width - (RendererManager.MeasureText(text, textSize).X + (24 * ratio))) / 2f;
RendererManager.DrawTexture("o9k.net_worth_bg_top", position);
RendererManager.DrawTexture(
this.ownerTeam == team ? "o9k.net_worth_arrow_ally" : "o9k.net_worth_arrow_enemy",
new RectangleF(position.X + measureText, position.Y + (4 * ratio), 12 * ratio, 12 * ratio));
RendererManager.DrawText(text, new Vector2(position.X + measureText + (15 * ratio), position.Y), Color.White, textSize);
}
catch (InvalidOperationException)
{
//ignore
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void OnDraw()
{
try
{
var time = DateTime.Now.ToString(this.timeFormat);
var timeSize = RendererManager.MeasureText(time, this.textSize);
var bgWidth = timeSize.X * 2.5f;
var bgPosition = this.position - new Vector2(bgWidth, 0);
var textPosition = this.position - new Vector2(timeSize.X + (4 * Hud.Info.ScreenRatio), 0);
RendererManager.DrawTexture("o9k.time_bg", new RectangleF(bgPosition.X, bgPosition.Y, bgWidth, this.textSize * 1.25f));
RendererManager.DrawText(time, textPosition, Color.LightGray, this.textSize);
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void DrawEvadableAbilities()
{
try
{
foreach (var unit in this.abilityManager.EvadableAbilities.Select(x => x.Ability.Owner)
.Where(x => x.IsAlive && x.IsVisible)
.Distinct()
.ToList())
{
var position = RendererManager.WorldToScreen(unit.Position);
if (position.IsZero)
{
continue;
}
position -= new Vector2(-50, 110);
foreach (var ability in this.abilityManager.EvadableAbilities.Where(x => x.Owner.Equals(unit))
.OrderBy(x => x.Ability.BaseAbility.AbilitySlot)
.ToList())
{
var text = ability.Ability.DisplayName;
if (ability is IModifierCounter modifier)
{
text += " (Modifier " + (modifier.ModifierEnemyCounter ? "enemy" : "ally") + ")";
}
RendererManager.DrawText(
text,
(position += new Vector2(0, 20)) + new Vector2(20, 0),
ability.Ability.BaseAbility.IsInAbilityPhase ? Color.LawnGreen :
ability.Ability.CanBeCasted() ? Color.White : Color.Gray,
"Arial",
TextSize);
}
}
}
catch (Exception e)
{
Logger.Warn(e.ToString());
}
}
private void DrawTownPortalScroll(Hero hero, Vector2 position, Vector2 size, float mana)
{
var tp = hero.Inventory.TownPortalScroll;
if (tp != null)
{
RendererManager.DrawTexture(tp.Name, new RectangleF(position.X, position.Y, size.X, size.Y), TextureType.RoundAbility, true);
var manaCost = tp.ManaCost;
var enoughMana = mana >= manaCost;
var cooldown = Math.Ceiling(tp.Cooldown);
if (cooldown > 0 || !enoughMana)
{
RendererManager.DrawFilledRectangle(new RectangleF(position.X, position.Y, size.X, size.Y), Color.Zero, enoughMana ? new Color(40, 40, 40, 180) : new Color(25, 25, 130, 190), 0);
}
else
{
RendererManager.DrawFilledRectangle(new RectangleF(position.X, position.Y, size.X, size.Y), Color.Zero, new Color(0, 0, 0, 100), 0);
}
if (cooldown > 0)
{
var cooldownText = Math.Min(cooldown, 99).ToString(CultureInfo.InvariantCulture);
var cooldownSize = cooldown > 9 ? size.Y * 0.65f : size.Y * 0.7f;
var textSize = RendererManager.MeasureText(cooldownText, cooldownSize);
var pos = position + new Vector2(size.X / 2 - textSize.X / 2, size.Y / 2 - textSize.Y / 2);
RendererManager.DrawText(cooldownText, pos, Color.WhiteSmoke, cooldownSize);
}
if (!enoughMana && cooldown <= 0)
{
var manaCostText = Math.Min(Math.Ceiling(manaCost - mana), 99).ToString(CultureInfo.InvariantCulture);
var manaCostSize = size.Y * 0.65f;
var textSize = RendererManager.MeasureText(manaCostText, manaCostSize);
var pos = position + new Vector2(size.X / 2 - textSize.X / 2, size.Y / 2 - textSize.Y / 2);
RendererManager.DrawText(manaCostText, pos, Color.LightBlue, manaCostSize);
}
}
}
protected override void Draw()
{
//value fill
var fillPct = ((float)this.Value - this.MinValue) / (this.MaxValue - this.MinValue);
RendererManager.DrawLine(
this.Position + new Vector2(0, this.Size.Y / 2),
this.Position + new Vector2(this.Size.X * fillPct, this.Size.Y / 2),
this.MenuStyle.BackgroundColor,
this.Size.Y);
base.Draw();
//value text
var valuePosition = new Vector2(
(this.Position.X + this.Size.X) - this.MenuStyle.RightIndent - this.valueTextSize.X,
this.Position.Y + ((this.Size.Y - this.MenuStyle.TextSize) / 3.3f));
RendererManager.DrawText(this.Value.ToString(), valuePosition, Color.White, this.MenuStyle.Font, this.MenuStyle.TextSize);
}
protected override void EnemyNotVisibleTimer(Hero hero, TopPanel topPanel)
{
if (!VisibleStatusMenu.EnemyNotVisibleTimeItem)
{
return;
}
var notVisibleTime = (int)Math.Min(GameManager.Time - hero.LastVisibleTime, 99);
if (notVisibleTime <= 0)
{
return;
}
var text = notVisibleTime.ToString();
var size = VisibleStatusMenu.SizeItem.Value * HUDInfo.RatioPercentage;
var extraPos = new Vector2((31 * HUDInfo.RatioPercentage) - RendererManager.MeasureText(text, size).X / 2, (10 * HUDInfo.RatioPercentage) - (size * 0.4f));
var color = new Color(VisibleStatusMenu.RedItem.Value, VisibleStatusMenu.GreenItem.Value, VisibleStatusMenu.BlueItem.Value);
RendererManager.DrawText(text, topPanel.IconPosition + extraPos, color, size);
}
private void OnDraw()
{
try
{
if (this.modifier?.IsValid != true)
{
RendererManager.Draw -= this.OnDraw;
return;
}
if (this.unit?.IsVisible != true)
{
return;
}
var position = RendererManager.WorldToScreen(this.unit.Position);
if (position.IsZero)
{
return;
}
var ratio = Hud.Info.ScreenRatio;
var remainingTime = this.endTime - GameManager.RawGameTime;
var time = Math.Ceiling(remainingTime).ToString("N0");
var pct = (int)(100 - ((remainingTime / this.duration) * 100));
var rec = new Rectangle9(position, new Vector2(30 * ratio));
var outlinePosition = rec * 1.17f;
RendererManager.DrawTexture(AbilityId.abyssal_underlord_dark_rift, rec, AbilityTextureType.Round);
RendererManager.DrawTexture("o9k.modifier_bg", rec);
RendererManager.DrawTexture("o9k.outline_green", outlinePosition);
RendererManager.DrawTexture("o9k.outline_black" + pct, outlinePosition);
RendererManager.DrawText(time, rec, Color.White, FontFlags.Center | FontFlags.VerticalCenter, 22 * ratio);
}
catch (Exception e)
{
Logger.Error(e);
}
}
public void DrawInformation(float mySpeed, bool showDamage, bool showSpeed, Vector2 position, float size)
{
var hpBar = this.Unit.HealthBarPosition;
if (hpBar.IsZero)
{
return;
}
var hpSize = this.Unit.HealthBarSize;
var iconSize = size * 0.75f;
var iconPosition = hpBar + position + new Vector2(hpSize.X, size - iconSize);
var textPosition = hpBar + position + new Vector2(hpSize.X + iconSize + 3, 0);
if (showDamage)
{
RendererManager.DrawTexture("o9k.attack_minimalistic", new RectangleF(iconPosition.X, iconPosition.Y, iconSize, iconSize));
RendererManager.DrawText(this.Hits == 0 ? "?" : this.Hits.ToString(), textPosition, Color.White, size);
iconPosition += new Vector2(0, size);
textPosition += new Vector2(0, size);
}
if (showSpeed)
{
RendererManager.DrawTexture("o9k.speed_minimalistic", new RectangleF(iconPosition.X, iconPosition.Y, iconSize, iconSize));
var speed = (int)(mySpeed - this.Unit.Speed);
if (speed >= 0)
{
RendererManager.DrawText(speed.ToString(), textPosition, Color.White, size);
}
else
{
RendererManager.DrawText((speed * -1).ToString(), textPosition, Color.DarkOrange, size);
}
}
}
private void OnDraw()
{
try
{
var seconds = GameManager.GameTime % 60;
foreach (var camp in this.drawCamps)
{
var position = RendererManager.WorldToScreen(camp.DrawPosition);
if (position.IsZero)
{
continue;
}
var stackTime = Math.Ceiling(camp.StackTime - seconds);
if (stackTime <= -2)
{
continue;
}
var stackTimeText = stackTime <= 0 ? "now" : stackTime.ToString("N0");
RendererManager.DrawText("Stack in: " + stackTimeText, position, Color.White, 18 * Hud.Info.ScreenRatio);
//renderer.DrawText(
// position,
// "Stack in: " + stackTimeText + " " + (camp.StackTime - seconds) + " " + camp.StackTime,
// Color.White,
// 18 * Hud.Info.ScreenRatio);
}
}
catch (InvalidOperationException)
{
// ignore
}
catch (Exception e)
{
Logger.Error(e);
}
}