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 static void OnDraw()
{
if (!GameManager.IsInGame || !sideMessages.Any())
{
return;
}
if (LastTick != null)
{
for (var i = 0; i < sideMessages.Count; i++)
{
var message = sideMessages.ElementAt(i).Value;
if (!message.Visible)
{
continue;
}
var span = TickCount - message.CreateTick;
if (span < message.EnterTime)
{
message.SetX(RendererManager.ScreenSize.X - (message.Size.X - 1) * span / message.EnterTime);
}
else if (span < message.EnterTime + message.StayTime)
{
message.SetX(RendererManager.ScreenSize.X - message.Size.X + 1);
}
else if (span < message.EnterTime + message.StayTime + message.ExitTime)
{
message.SetX(RendererManager.ScreenSize.X - (message.Size.X - 1) * (message.EnterTime + message.StayTime + message.ExitTime - span) / message.ExitTime);
}
else
{
message.DestroyMessage();
}
}
for (var i = 0; i < sideMessages.Count; i++)
{
var message = sideMessages.ElementAt(i).Value;
if (!message.Visible)
{
continue;
}
//Drawing.DrawRect(message.MessagePosition, message.Size, message.BackgroundColor);
//Drawing.DrawRect(message.MessagePosition, message.Size, message.BackgroundOutlineColor, true);
RendererManager.DrawFilledRectangle(new RectangleF(message.MessagePosition.X, message.MessagePosition.Y, message.Size.X, message.Size.Y), message.BackgroundColor, message.BackgroundColor, 0);
RendererManager.DrawRectangle(new RectangleF(message.MessagePosition.X, message.MessagePosition.Y, message.Size.X, message.Size.Y), message.BackgroundOutlineColor, 1);
foreach (var component in message.components)
{
component.Value.Draw();
}
}
}
LastTick = (int?)TickCount;
}
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);
}
}
private void OnDrawDebug()
{
try
{
RendererManager.DrawRectangle(this.leftPanel, Color.White, 2);
RendererManager.DrawRectangle(this.rightPanel, Color.White, 2);
RendererManager.DrawRectangle(this.centerPanel, Color.White, 2);
}
catch
{
//ignore
}
}
private void OnDraw()
{
if (this.TimeLapse?.CanBeCasted() != true)
{
return;
}
var hero = this.Owner.Hero;
var hpPosition = hero.HealthBarPosition;
if (hpPosition.IsZero)
{
return;
}
var time = GameManager.RawGameTime;
var health = hero.Health;
var values = this.healthTime.OrderBy(x => x.Key).ToList();
var restore = values.Find(x => x.Key + 5f > time).Value;
if (restore <= health)
{
return;
}
var restorePercentage = restore / hero.MaximumHealth;
var healthBarSize = hero.HealthBarSize;
var start = hpPosition + new Vector2(0, healthBarSize.Y * 0.7f) + this.killSteal.AdditionalOverlayPosition;
var size = (healthBarSize * new Vector2(restorePercentage, 0.3f)) + this.killSteal.AdditionalOverlayPosition;
RendererManager.DrawFilledRectangle(new RectangleF(start.X, start.Y, size.X, size.Y), Color.DarkOliveGreen);
RendererManager.DrawRectangle(new RectangleF(start.X - 1, start.Y - 1, size.X + 1, size.Y + 1), Color.Black);
var restoreEarly = values.Find(x => x.Key + 4f > time).Value;
if (restoreEarly < restore)
{
var losePercentage = (restore - restoreEarly) / hero.MaximumHealth;
var size2 = (healthBarSize * new Vector2(losePercentage, 0.3f)) + this.killSteal.AdditionalOverlayPosition;
var start2 = hpPosition + new Vector2(Math.Max(size.X - size2.X, 0), healthBarSize.Y * 0.7f)
+ this.killSteal.AdditionalOverlayPosition;
RendererManager.DrawFilledRectangle(new RectangleF(start2.X, start2.Y, size2.X, size2.Y), Color.LightGreen);
RendererManager.DrawRectangle(new RectangleF(start2.X - 1, start2.Y - 1, size2.X + 1, size2.Y + 1), Color.Black);
}
}
private void OnDrawDebug()
{
try
{
var drawPosition = this.panel;
for (var i = 0; i < MaxNotifications; i++)
{
RendererManager.DrawRectangle(drawPosition, Color.White);
drawPosition += new Vector2(0, -(drawPosition.Height + 20));
}
}
catch
{
//ignore
}
}
private void OnDrawDebug()
{
try
{
RendererManager.DrawRectangle(this.minimap, Color.White, 2);
RendererManager.DrawCircle(this.WorldToMinimap(GameManager.MousePosition), 2, Color.White);
foreach (var tower in EntityManager9.Units.Where(x => x.IsTower))
{
RendererManager.DrawCircle(this.WorldToMinimap(tower.Position), 6, Color.White);
}
}
catch
{
//ignore
}
}
private void OnDraw()
{
try
{
foreach (var unitPair in this.unitDamage)
{
var unit = unitPair.Key;
if (!unit.IsValid)
{
continue;
}
var hpBarPosition = unit.Unit.HealthBarPosition;
if (hpBarPosition.IsZero)
{
continue;
}
var damage = unitPair.Value;
var hpBarSize = unit.Unit.HealthBarSize;
var attackDamage = damage.AutoAttackDamage;
var health = unit.Unit.Health;
if (this.menu.AttacksEnabled)
{
var attackDamagePct = attackDamage / unit.Unit.MaximumHealth;
Color color;
if (attackDamage > health)
{
color = unit.IsAlly ? Color.LawnGreen : Color.OrangeRed;
}
else
{
color = unit.IsAlly ? Color.DarkGreen : Color.DarkRed;
}
var bar = new Rectangle9(
hpBarPosition + new Vector2(this.menu.AttacksX, this.menu.AttacksY),
hpBarSize + new Vector2(this.menu.AttacksSizeX, this.menu.AttacksSizeY));
bar.Width *= Math.Min(attackDamagePct, unit.Unit.HealthPercentageBase);
RendererManager.DrawFilledRectangle(bar, color);
}
if (this.menu.AbilitiesEnabled)
{
var fullDamage = damage.AbilityDamage.Sum(x => x.Value);
if (fullDamage + attackDamage < health)
{
continue;
}
if (fullDamage > health)
{
var totalDamage = 0;
var drawAbilities = new List <string>();
foreach (var damagePair in damage.AbilityDamage)
{
totalDamage += damagePair.Value;
drawAbilities.Add(damagePair.Key.Name);
if (totalDamage > health)
{
break;
}
}
var count = drawAbilities.Count;
if (count > 0)
{
var barSize = new Vector2(this.menu.AbilitiesSize * count, this.menu.AbilitiesSize);
var startPosition = hpBarPosition + new Vector2((hpBarSize.X / 2f) - (barSize.X / 2f), -35)
+ new Vector2(this.menu.AbilitiesX, this.menu.AbilitiesY);
RendererManager.DrawRectangle(
new RectangleF(startPosition.X, startPosition.Y, barSize.X, barSize.Y),
Color.Green,
5);
foreach (var ability in drawAbilities)
{
RendererManager.DrawTexture(ability, new RectangleF(startPosition.X, startPosition.Y, barSize.Y, barSize.Y), TextureType.Ability);
startPosition += new Vector2(barSize.Y, 0);
}
}
}
else
{
var count = damage.AbilityDamage.Count;
if (count > 0)
{
var barSize = new Vector2(this.menu.AbilitiesSize * count, this.menu.AbilitiesSize);
var startPosition = hpBarPosition + new Vector2((hpBarSize.X / 2f) - (barSize.X / 2f), -35)
+ new Vector2(this.menu.AbilitiesX, this.menu.AbilitiesY);
RendererManager.DrawRectangle(
new RectangleF(startPosition.X, startPosition.Y, barSize.X, barSize.Y),
Color.Orange,
5);
foreach (var ability in damage.AbilityDamage.Select(x => x.Key))
{
RendererManager.DrawTexture(ability.Name, new RectangleF(startPosition.X, startPosition.Y, barSize.Y, barSize.Y));
startPosition += new Vector2(barSize.Y, 0);
}
}
}
}
}
}
catch (InvalidOperationException)
{
// ignore
}
catch (Exception e)
{
Logger.Error(e);
}
}
protected override void Draw()
{
base.Draw();
//drag ability
if (this.drawDrag)
{
RendererManager.DrawTexture(
this.dragItem,
new RectangleF(
this.dragAbilityPosition.X,
this.dragAbilityPosition.Y,
this.MenuStyle.TextureHeroSize.X,
this.MenuStyle.TextureHeroSize.Y),
TextureType.Unit);
this.dragTargetAbility = null;
}
//heroes
var startPosition = new Vector2(
(this.Position.X + this.Size.X) - this.MenuStyle.TextureHeroSize.X - 4,
this.Position.Y + ((this.Size.Y - this.MenuStyle.TextureHeroSize.Y) / 2.2f));
var priority = this.heroes.Count(x => x.Value);
var count = 0;
foreach (var ability in this.heroes.OrderByDescending(x => this.heroPriority[x.Key]))
{
count++;
if (this.drawDrag)
{
var border = 3;
if (ability.Key == this.dragItem)
{
border = 0;
}
if ((count == 1 && this.currentMousePosition.X > this.Position.X + this.Size.X) ||
(this.currentMousePosition.X >= startPosition.X - border && this.currentMousePosition.X
<= startPosition.X + this.MenuStyle.TextureHeroSize.X + border))
{
this.dragTargetAbility = ability.Key;
startPosition -= new Vector2(this.MenuStyle.TextureHeroSize.X + 4, 0);
this.increasePriority = false;
}
if (ability.Key == this.dragItem)
{
if (ability.Value)
{
priority--;
}
continue;
}
}
RendererManager.DrawRectangle(
new RectangleF(
startPosition.X - 1.5f,
startPosition.Y - 1.5f,
this.MenuStyle.TextureHeroSize.X + 3,
this.MenuStyle.TextureHeroSize.Y + 3),
ability.Value ? Color.LightGreen : Color.Red,
1.5f);
RendererManager.DrawTexture(
ability.Key,
new RectangleF(startPosition.X, startPosition.Y, this.MenuStyle.TextureHeroSize.X, this.MenuStyle.TextureHeroSize.Y),
TextureType.Unit);
if (ability.Value)
{
//priority
RendererManager.DrawLine(
startPosition + new Vector2(0, this.MenuStyle.TextureHeroSize.Y - 6),
startPosition + new Vector2(6, this.MenuStyle.TextureHeroSize.Y - 6),
Color.Black,
12);
RendererManager.DrawText(
priority--.ToString(),
startPosition + new Vector2(0, this.MenuStyle.TextureHeroSize.Y - 12),
Color.White,
this.MenuStyle.Font,
12);
}
startPosition -= new Vector2(this.MenuStyle.TextureHeroSize.X + 4, 0);
}
if (this.drawDrag && this.dragTargetAbility == null)
{
this.dragTargetAbility = this.heroes.Select(x => x.Key).OrderBy(x => this.heroPriority[x]).FirstOrDefault();
this.increasePriority = true;
}
}
protected override void EmemyItemPanel()
{
if (EmemyItemPanelMenu.EmemyItemPanelItem)
{
var size = EmemyItemPanelMenu.SizeItem.Value;
var sizeX = 20 + size * 0.4f;
var sizeY = sizeX / 1.30f;
var panelPosition = new Vector2(EmemyItemPanelMenu.PositionXItem, EmemyItemPanelMenu.PositionYItem);
var panelSize = new Vector2(sizeX * 7.31f, 5 * (sizeY + 2) + 2);
PanelMove.Size = new Vector2(panelSize.X + 9, panelSize.Y + 9);
RendererManager.DrawTexture("Divine.BeAware.Resources.Textures.item_panel.png", new RectangleF(panelPosition.X - 2, panelPosition.Y, panelSize.X, panelSize.Y));
var itemPosition = panelPosition;
foreach (var hero in Heroes)
{
itemPosition += new Vector2(0, 2);
RendererManager.DrawTexture(hero.Name, new RectangleF(itemPosition.X, itemPosition.Y, sizeX * 1.36f, sizeY), TextureType.Unit, true);
var mana = hero.Mana;
var maximumMana = hero.MaximumMana;
DrawTownPortalScroll(hero, itemPosition + new Vector2(sizeX * 0.85f, sizeY * 0.35f), new Vector2(sizeY * 0.65f), mana);
itemPosition += new Vector2(sizeX * 1.4f, 0);
foreach (var item in hero.Inventory.MainItems)
{
var itemSize = new Vector2(sizeX, sizeY);
RendererManager.DrawTexture(item.Name, new RectangleF(itemPosition.X, itemPosition.Y, itemSize.X, itemSize.Y), TextureType.Item, true);
var manaCost = item.ManaCost;
var enoughMana = mana >= manaCost;
var cooldown = Math.Ceiling(item.CooldownInFog);
if (cooldown > 0 || !enoughMana)
{
RendererManager.DrawFilledRectangle(new RectangleF(itemPosition.X, itemPosition.Y, itemSize.X, itemSize.Y), Color.Zero, enoughMana ? new Color(40, 40, 40, 180) : new Color(25, 25, 130, 190), 0);
}
else
{
RendererManager.DrawFilledRectangle(new RectangleF(itemPosition.X, itemPosition.Y, itemSize.X, itemSize.Y), Color.Zero, new Color(0, 0, 0, 100), 0);
}
if (cooldown > 0)
{
var cooldownText = Math.Min(cooldown, 99).ToString(CultureInfo.InvariantCulture);
var cooldownSize = itemSize.Y - 1;
var textSize = RendererManager.MeasureText(cooldownText, cooldownSize);
var pos = itemPosition + new Vector2(itemSize.X / 2 - textSize.X / 2, (itemSize.Y / 2) - (textSize.Y / 2));
RendererManager.DrawText(cooldownText, pos, Color.WhiteSmoke, cooldownSize);
}
if (!enoughMana && cooldown <= 0)
{
var manaCostText = Math.Min(Math.Ceiling(manaCost - mana), 999).ToString(CultureInfo.InvariantCulture);
var textSize = RendererManager.MeasureText(manaCostText, itemSize.Y - 1);
var pos = itemPosition + new Vector2(itemSize.X / 2 - textSize.X / 2, (itemSize.Y / 2) - (textSize.Y / 2));
RendererManager.DrawText(manaCostText, pos, Color.LightBlue, itemSize.Y - 1);
}
var itemId = item.Id;
if ((item.IsRequiringCharges || itemId == AbilityId.item_bottle || itemId == AbilityId.item_ward_dispenser || itemId == AbilityId.item_ward_observer || itemId == AbilityId.item_ward_sentry) && cooldown <= 0)
{
var currentCharges = item.CurrentCharges.ToString();
var tSize = itemSize.Y / 2;
var textSize = RendererManager.MeasureText(currentCharges, tSize);
var tPos = itemPosition + new Vector2(itemSize.X - textSize.X - 1, itemSize.Y - textSize.Y);
RendererManager.DrawFilledRectangle(new RectangleF(tPos.X - 1, tPos.Y, textSize.X + 1, textSize.Y), Color.Zero, new Color(0, 0, 0, 220), 0);
RendererManager.DrawText(currentCharges, tPos, new Color(168, 168, 168), tSize);
var secondcharges = item.SecondaryCharges;
if (secondcharges > 0)
{
tPos = itemPosition + new Vector2(2, itemSize.Y - textSize.Y);
currentCharges = secondcharges.ToString();
tSize = itemSize.Y - 1;
var textSize1 = RendererManager.MeasureText(currentCharges, tSize);
RendererManager.DrawFilledRectangle(new RectangleF(tPos.X - 1, tPos.Y, textSize.X + 1, textSize.Y + 1), Color.Zero, new Color(0, 0, 0, 220), 0);
RendererManager.DrawText(currentCharges, tPos, new Color(168, 168, 168), tSize);
}
}
itemPosition += new Vector2(sizeX - 1, 0);
}
itemPosition = new Vector2(panelPosition.X, sizeY + itemPosition.Y);
}
if (PanelMove.ActivateMove)
{
var text = PanelMove.Time.ToString();
var sizeText = RendererManager.MeasureText(text, panelSize.Y);
RendererManager.DrawText(text, panelPosition - new Vector2((sizeText.X * 0.5f) - (panelSize.X / 2), 0), new Color(255, 255, 255, 50), panelSize.X / 2);
RendererManager.DrawRectangle(new RectangleF(panelPosition.X - 5, panelPosition.Y - 5, PanelMove.Size.X, PanelMove.Size.Y), Color.WhiteSmoke, 1);
}
}
}
protected override void OverlaySpells(IEnumerable <Ability> spells, Vector2 position, HeroId heroId, float mana, Vector2 extraSize)
{
foreach (var spell in spells)
{
if (spell.IsHidden)
{
continue;
}
if (spell.IsInAbilityPhase)
{
RendererManager.DrawTexture("Divine.BeAware.Resources.Textures.spell_phase.png", new RectangleF(position.X, position.Y, extraSize.X, extraSize.Y));
}
var level = spell.Level;
var manaCast = spell.ManaCost;
var enoughMana = mana >= manaCast;
var cooldown = spell.Cooldown;
if (cooldown > 0 || !enoughMana || level <= 0)
{
var color = level <= 0 ? new Color(10, 10, 10, 210) : (enoughMana ? new Color(40, 40, 40, 180) : new Color(25, 25, 130, 190));
RendererManager.DrawFilledRectangle(new RectangleF(position.X + 1, position.Y, extraSize.X - 1, extraSize.Y), color, color, 0);
}
var notinvospell = heroId != HeroId.npc_dota_hero_invoker || (spell.AbilitySlot != AbilitySlot.Slot_4 && spell.AbilitySlot != AbilitySlot.Slot_5);
if (notinvospell)
{
var levelText = level.ToString();
var textSize = RendererManager.MeasureText(levelText, extraSize.X / 2);
RendererManager.DrawFilledRectangle(new RectangleF(position.X + 1, position.Y, textSize.X + 2, textSize.Y + 1), Color.Zero, new Color(0, 0, 0, 220), 0);
RendererManager.DrawText(levelText, new Vector2(position.X + 1, position.Y), new Color(168, 168, 168), extraSize.X / 2);
}
if (cooldown > 0)
{
var cooldownText = (cooldown > 1 ? Math.Min(Math.Ceiling(cooldown), 99) : Math.Round(cooldown, 1)).ToString();
var cooldownSize = extraSize.X / 2 + 3;
var textSize = RendererManager.MeasureText(cooldownText, cooldownSize);
RendererManager.DrawText(cooldownText, position + new Vector2(extraSize.X / 2 - textSize.X / 2, (extraSize.Y / 2) - (textSize.Y / 2)), Color.WhiteSmoke, cooldownSize);
}
if (!enoughMana && cooldown <= 0)
{
var manaText = Math.Min(Math.Ceiling(manaCast - mana), 999).ToString(CultureInfo.InvariantCulture);
var textSize = RendererManager.MeasureText(manaText, extraSize.X / 2 + 1);
Vector2 pos;
if (!notinvospell)
{
pos = position + new Vector2(extraSize.X / 2 - textSize.X / 2, (float)((extraSize.Y / 1.5) - (textSize.Y / 2)));
}
else
{
pos = position + new Vector2((float)(extraSize.X / 1.5 - textSize.X / 2), (float)((extraSize.Y / 1.5) - (textSize.Y / 2)));
}
RendererManager.DrawText(manaText, pos, Color.LightBlue, extraSize.X / 2 + 1);
}
RendererManager.DrawRectangle(new RectangleF(position.X, position.Y, extraSize.X + 1, extraSize.Y), Color.Black, 1);
position += new Vector2(extraSize.X, 0);
}
}
public void Draw(Rectangle9 position, float cooldownSize)
{
try
{
RendererManager.DrawTexture(this.Ability.TextureName, position, TextureType.Ability);
if (this.Ability.IsCasting || this.Ability.IsChanneling)
{
RendererManager.DrawRectangle(position - 3f, Color.LightGreen, 3);
}
else
{
RendererManager.DrawRectangle(position - 1, Color.Black);
}
if (this.displayLevel)
{
var level = this.Ability.Level;
if (level == 0)
{
RendererManager.DrawTexture("o9k.ability_0lvl_bg", position);
return;
}
var levelText = level.ToString("N0");
var levelSize = RendererManager.MeasureText(levelText, position.Width * 0.45f);
var levelPosition = position.SinkToBottomLeft(levelSize.X, levelSize.Y * 0.8f);
RendererManager.DrawTexture("o9k.ability_lvl_bg", levelPosition);
RendererManager.DrawText(levelText, levelPosition, Color.White, FontFlags.VerticalCenter, position.Width * 0.45f);
}
if (this.Ability.IsDisplayingCharges)
{
var chargesText = this.Ability.Charges.ToString("N0");
var chargesPosition = position.SinkToBottomRight(position.Width * 0.5f, position.Height * 0.5f);
RendererManager.DrawTexture("o9k.charge_bg", chargesPosition);
RendererManager.DrawTexture("o9k.outline_green", chargesPosition * 1.07f);
RendererManager.DrawText(chargesText, chargesPosition, Color.White, FontFlags.Center, position.Width * 0.45f);
}
if (this.Ability.IsChanneling)
{
return;
}
var cooldown = this.Ability.RemainingCooldown;
if (cooldown > 0)
{
RendererManager.DrawTexture("o9k.ability_cd_bg", position);
RendererManager.DrawText(
Math.Ceiling(cooldown).ToString("N0"),
position,
Color.White,
FontFlags.Center | FontFlags.VerticalCenter,
cooldownSize);
}
else if (this.Ability.ManaCost > this.Ability.Owner.Mana)
{
RendererManager.DrawTexture("o9k.ability_mana_bg", position);
RendererManager.DrawText(
Math.Ceiling((this.Ability.ManaCost - this.Ability.Owner.Mana) / this.Ability.Owner.ManaRegeneration)
.ToString("N0"),
position,
Color.White,
FontFlags.Center | FontFlags.VerticalCenter,
cooldownSize);
}
else if (!this.Ability.IsUsable)
{
RendererManager.DrawTexture("o9k.ability_0lvl_bg", position);
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void RenderManagerOnDraw()
{
var mousePos = GetMousePosition;
foreach (var bomb in _main.Updater.BombManager.RemoteMines.Where(x =>
x.Owner.IsValid && x.Owner.IsAlive && x.Stacker.IsActive))
{
if (_main.MenuManager.StackDontDrawSolo && bomb.Stacker.Counter == 1)
{
continue;
}
var topPos = CustomHUDInfo.GetHpBarPosition(bomb.Owner);
if (topPos.IsZero)
{
continue;
}
var size = new Vector2(CustomHUDInfo.HpBarSizeX, CustomHUDInfo.HpBarSizeY);
var text = bomb.Stacker.Counter.ToString();
var textSize = RendererManager.MeasureText(text, 30);
var textPos = topPos + new Vector2(size.X / 2 - textSize.X / 2, -size.Y * 2);
var extraRectangleSizeX = 50;
var extraRectangleSizeY = textSize.Y / 2;
var rectWidth = textSize.X + extraRectangleSizeX * 2;
var boxSize = new Vector2(rectWidth / 5);
var rectangle = new RectangleF(textPos.X - extraRectangleSizeX, textPos.Y - extraRectangleSizeY,
rectWidth + 2, textSize.Y + boxSize.X);
if (IsIn(rectangle, mousePos))
{
RendererManager.DrawFilledRectangle(rectangle, Color.White, new SharpDX.Color(200, 10, 10, 10), 1);
RendererManager.DrawText(text, new Vector2(rectangle.X + rectangle.Width / 2 - textSize.X / 2, rectangle.Y),
bomb.UnderTrueSight ? Color.OrangeRed : Color.White, 30);
var count = 0;
foreach (var target in TargetManager.Targets.GroupBy(x => x.HeroId).ToList())
{
var boxPos = new Vector2(rectangle.X + count++ *boxSize.X, rectangle.Y + textSize.Y);
var boxRect = new RectangleF(boxPos.X + 1, boxPos.Y - 1, boxSize.X, boxSize.Y);
RendererManager.DrawTexture(target.Key, new RectangleF(boxPos.X, boxPos.Y, boxSize.X, boxSize.Y), UnitTextureType.MiniUnit);
if (bomb.Stacker.DetonateDict.TryGetValue(target.Key, out var isEnable))
{
RendererManager.DrawRectangle(boxRect, isEnable ? Color.Green : Color.OrangeRed, 1);
}
else
{
bomb.Stacker.DetonateDict.Add(target.Key, true);
}
if (IsIn(boxRect, mousePos))
{
if (IsButtonClicked)
{
IsButtonClicked = false;
bomb.Stacker.DetonateDict[target.Key] = !bomb.Stacker.DetonateDict[target.Key];
}
}
else
{
RendererManager.DrawFilledRectangle(boxRect, Color.White, new SharpDX.Color(100, 50, 50, 50), 0);
}
}
}
else
{
RendererManager.DrawText(text, textPos, bomb.UnderTrueSight ? Color.OrangeRed : Color.White, 30);
}
}
}
protected override void OverlaySpells(IEnumerable <Ability> spells, Vector2 position, HeroId heroId, float mana, Vector2 extraSize)
{
foreach (var spell in spells)
{
if (spell.IsHidden)
{
continue;
}
if (spell.IsInAbilityPhase)
{
RendererManager.DrawTexture("Divine.BeAware.Resources.Textures.spell_phase.png", new RectangleF(position.X, position.Y, extraSize.X, extraSize.Y));
}
var level = spell.Level;
var manaCast = spell.ManaCost;
var isEnoughMana = mana >= manaCast;
var cooldown = spell.Cooldown;
var isCooldown = cooldown > 0;
var isLevel = level > 0;
var extraRange = new Vector2(level > 4 ? (level - 4) * 5.5f : 0, 0);
if (isCooldown || !isEnoughMana || !isLevel)
{
if (isLevel)
{
extraRange.Y = 13;
}
var color = !isLevel ? new Color(100, 10, 10, 190) : (isEnoughMana ? new Color(40, 40, 40, 180) : new Color(25, 25, 130, 190));
RendererManager.DrawFilledRectangle(new RectangleF(position.X + 1, position.Y, extraSize.X - 1, extraSize.Y), color, color, 0);
}
var notinvospell = heroId != HeroId.npc_dota_hero_invoker || (spell.AbilitySlot != AbilitySlot.Slot_4 && spell.AbilitySlot != AbilitySlot.Slot_5);
if (notinvospell)
{
for (var lvl = 1; lvl <= level; lvl++)
{
var rect = new RectangleF(position.X + (extraSize.X * 0.212f * lvl) - extraSize.X * 0.08f, position.Y + 3, extraSize.X * 0.115f, extraSize.X * 0.115f);
RendererManager.DrawFilledRectangle(rect, Color.Zero, new Color(255, 255, 0), 0);
}
}
if (isCooldown)
{
var cooldownText = (cooldown > 1 ? Math.Min(Math.Ceiling(cooldown), 99) : Math.Round(cooldown, 1)).ToString();
var cooldownSize = extraSize.X / 2 + 3;
var textSize = RendererManager.MeasureText(cooldownText, cooldownSize);
var pos = position + new Vector2(extraSize.X / 2 - textSize.X / 2, (extraSize.Y / 2) - (textSize.Y / 2) + (extraRange.Y - 2));
RendererManager.DrawText(cooldownText, pos, Color.WhiteSmoke, cooldownSize);
}
if (!isEnoughMana && !isCooldown)
{
var manaText = Math.Min(Math.Ceiling(manaCast - mana), 999).ToString(CultureInfo.InvariantCulture);
var textSize = RendererManager.MeasureText(manaText, extraSize.X / 2 + 1);
Vector2 pos;
if (!notinvospell)
{
pos = position + new Vector2(extraSize.X / 2 - textSize.X / 2, (extraSize.Y / 2) - (textSize.Y / 2) + (extraRange.Y - 2));
}
else
{
pos = position + new Vector2(extraSize.X / 2 - textSize.X / 2, (extraSize.Y / 2) - (textSize.Y / 2) + (extraRange.Y - 2));
}
RendererManager.DrawText(manaText, pos, Color.LightBlue, extraSize.X / 2 + 1);
}
RendererManager.DrawRectangle(new RectangleF(position.X, position.Y, extraSize.X + 1 + extraRange.X, extraSize.Y + extraRange.Y), Color.Black, 1);
position += new Vector2(extraSize.X + extraRange.X, 0);
}
}