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);
}
protected override void Draw()
{
base.Draw();
//abilities
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));
foreach (var ability in this.heroes.Reverse())
{
RendererManager.DrawFilledRectangle(
new RectangleF(
startPosition.X - 1.5f,
startPosition.Y - 1.5f,
this.MenuStyle.TextureHeroSize.X + 3,
this.MenuStyle.TextureHeroSize.Y + 3),
Color.Zero,
ability.Value ? Color.LightGreen : Color.Red,
0);
RendererManager.DrawTexture(
ability.Key,
new RectangleF(startPosition.X, startPosition.Y, this.MenuStyle.TextureHeroSize.X, this.MenuStyle.TextureHeroSize.Y),
TextureType.Unit);
startPosition -= new Vector2(this.MenuStyle.TextureHeroSize.X + 4, 0);
}
}
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;
}
private void OnRendererManagerDraw()
{
var color = new Color(BloodseekerRuptureMenu.RedItem, BloodseekerRuptureMenu.GreenItem, BloodseekerRuptureMenu.BlueItem, BloodseekerRuptureMenu.AlphaItem);
var screenSize = RendererManager.ScreenSize;
RendererManager.DrawFilledRectangle(new RectangleF(0, 0, screenSize.X, screenSize.Y), Color.Zero, color, 0);
}
protected override void Draw()
{
base.Draw();
//rectangle
RendererManager.DrawFilledRectangle(
new RectangleF(
(this.Position.X + this.Size.X) - this.MenuStyle.TextureArrowSize - this.MenuStyle.RightIndent,
this.Position.Y + ((this.Size.Y - this.MenuStyle.TextureArrowSize) / 2.2f),
this.MenuStyle.TextureArrowSize,
this.MenuStyle.TextureArrowSize),
this.IsEnabled ? Color.White : this.MenuStyle.BackgroundColor,
new Color(50, 50, 50, 255),
2);
}
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);
}
}
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 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);
}
}
}
private void RendererManagerOnDraw()
{
if (ColorScreen)
{
var color = new Color(
SpiritBreakerChargeMenu.RedItem.Value,
SpiritBreakerChargeMenu.GreenItem.Value,
SpiritBreakerChargeMenu.BlueItem.Value,
SpiritBreakerChargeMenu.AlphaItem.Value);
var screenSize = RendererManager.ScreenSize;
RendererManager.DrawFilledRectangle(new RectangleF(0, 0, screenSize.X, screenSize.Y), Color.Zero, color, 0);
}
if (OnMinimap)
{
var startPos = startChargePosition.WorldToMinimap();
var endPos = endChargePosition.WorldToMinimap();
RendererManager.DrawLine(startPos, endPos, Color.WhiteSmoke, 1);
RendererManager.DrawTexture(@"mini_heroes\npc_dota_hero_spirit_breaker.png", new RectangleF(startPos.X - 11, startPos.Y - 13, 24, 24));
}
}
protected override void ManaBar(float mana, float maximumMana, float manaPerc, Vector2 hpBarPosition, float manaBarSizeY)
{
if (!ManaBarMenu.ManaBarItem)
{
return;
}
var manaBarPosition = ManaBarUtils.ManaBarPosition(hpBarPosition);
var pos = ManaBarUtils.ManaBarBackPosition(manaBarPosition);
var size = new Vector2(HUDInfo.HpBarSizeX - 1, manaBarSizeY + 3);
var size2 = new Vector2(ManaBarUtils.ManaBarSizeX(manaPerc), manaBarSizeY);
RendererManager.DrawFilledRectangle(new RectangleF(pos.X, pos.Y, size.X, size.Y), Color.Zero, Color.Black, 0);
RendererManager.DrawTexture("Divine.BeAware.Resources.Textures.ui_manabar.png", new RectangleF(manaBarPosition.X, manaBarPosition.Y, size2.X, size2.Y));
if (ManaBarMenu.ManaBarValueItem)
{
var manaText = $"{ (int)mana }/{ (int)maximumMana }";
var sizeText = 12.5f * HUDInfo.RatioPercentage;
var measureText = RendererManager.MeasureText(manaText, sizeText);
RendererManager.DrawText(manaText, ManaBarUtils.ManaBarValuePosition(manaBarPosition, measureText.X), Color.WhiteSmoke, sizeText);
}
}
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);
}
}
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);
}
}
}
private void DrawMap()
{
try
{
var center = GameManager.MousePosition;
const int CellCount = 40;
for (var i = 0; i < CellCount; ++i)
{
for (var j = 0; j < CellCount; ++j)
{
Vector2 p;
p.X = (this.pathfinder.NavMesh.CellSize * (i - (CellCount / 2))) + center.X;
p.Y = (this.pathfinder.NavMesh.CellSize * (j - (CellCount / 2))) + center.Y;
Color color;
var isFlying = this.owner.Hero.MoveCapability == MoveCapability.Fly ||
(this.owner.Hero.UnitState & UnitState.Flying) != 0;
var flag = this.pathfinder.NavMesh.GetCellFlags(p);
if (!isFlying && (flag & MapMeshCellFlags.Walkable) != 0)
{
color = (flag & MapMeshCellFlags.Tree) != 0 ? SharpDX.Color.Purple : SharpDX.Color.Green;
if ((flag & MapMeshCellFlags.GridFlagObstacle) != 0)
{
color = Color.Pink;
}
}
else if (isFlying && (flag & MapMeshCellFlags.MovementBlocker) == 0)
{
color = Color.Green;
}
else
{
color = Color.Red;
}
RendererManager.DrawFilledRectangle(new RectangleF(i * 10, 50 + ((CellCount - j - 1) * 10), 9, 9), color);
}
}
this.pathfinder.NavMesh.GetCellPosition(this.owner.Hero.Position - center, out var heroX, out var heroY);
heroX += CellCount / 2;
heroY += CellCount / 2;
if (heroX >= 0 && heroX < CellCount && heroY >= 0 && heroY < CellCount)
{
RendererManager.DrawFilledRectangle(new RectangleF(heroX * 10, 50 + ((CellCount - heroY - 1) * 10), 9, 9), Color.Blue);
}
//this.pathfinder.NavMesh.GetCellPosition(GameManager.MousePosition - center, out var mouseX, out var mouseY);
//mouseX += CellCount / 2;
//mouseY += CellCount / 2;
//if (mouseX >= 0 && mouseX < CellCount && mouseY >= 0 && mouseY < CellCount)
//{
// Drawing.DrawRect(
// new Vector2(mouseX * 10, 50 + ((CellCount - mouseY - 1) * 10)),
// new Vector2(9),
// SharpDX.Color.White,
// false);
//}
}
catch (Exception e)
{
Logger.Warn(e.ToString());
}
}
private void DrawAbilities()
{
var abilities = this.abilityBuilder.Abilities;
var maxLevel = abilities.Max(x => x.LearnLevel);
var build = new Dictionary <uint, LearnableAbility>();
for (var i = 1u; i < maxLevel; i++)
{
var currentLevelAbilities = abilities.Where(
x => x.LearnLevel == i && this.abilityBuilder.IsLearnable(
x,
i,
i,
(uint)build.Count(z => z.Value.Ability == x.Ability)))
.ToList();
if (currentLevelAbilities.Count == 0)
{
continue;
}
var ability = this.abilitiesType.Selected == BuildType.WinRate
? currentLevelAbilities.OrderByDescending(x => x.WinRate).ThenByDescending(x => x.PickRate).First()
: currentLevelAbilities.OrderByDescending(x => x.PickRate).First();
build.Add(i, ability);
}
var ratio = Hud.Info.ScreenRatio;
var xStart = Hud.Info.ScreenSize.X * 0.35f;
var yStart = Hud.Info.ScreenSize.Y * 0.55f;
var uniqueAbilities = build.Values.GroupBy(x => x.Ability).Select(x => x.First()).OrderBy(x => x.Ability.AbilitySlot).ToList();
var positions = new Dictionary <Ability, float>();
RendererManager.DrawFilledRectangle(
new RectangleF(xStart - 2, yStart, ((build.Count + 1) * 48 * ratio) + 2, uniqueAbilities.Count * 40 * ratio),
new Color(75, 75, 75, 175));
for (var i = 0; i < uniqueAbilities.Count; i++)
{
//Drawing.DrawRect(
// new Vector2(xStart, yStart + (i * 40 * ratio)),
// new Vector2(45 * ratio, 40 * ratio),
// uniqueAbilities[i].Texture);
positions.Add(uniqueAbilities[i].Ability, yStart + (i * 40 * ratio));
RendererManager.DrawFilledRectangle(
new RectangleF(xStart - 2, (yStart - 2) + (i * 40 * ratio), (build.Count + 1) * 48 * ratio, 2),
Color.Silver);
}
RendererManager.DrawFilledRectangle(
new RectangleF(xStart - 2, (yStart - 2) + (uniqueAbilities.Count * 40 * ratio), (build.Count + 1) * 48 * ratio, 2),
Color.Silver);
for (var i = 1u; i <= build.Count; i++)
{
var size = RendererManager.MeasureText(i.ToString(), "Arial", 35 * ratio);
RendererManager.DrawFilledRectangle(
new RectangleF((xStart - 2) + (i * 48 * ratio), yStart - 2, 2, uniqueAbilities.Count * 40 * ratio),
Color.Silver);
if (!build.TryGetValue(i, out var buildAbility))
{
continue;
}
RendererManager.DrawText(
i.ToString(),
new Vector2(
xStart + (45 * ratio) + ((i - 1) * 48 * ratio) + (((48 * ratio) - size.X) / 2),
positions[buildAbility.Ability]),
Color.White,
"Arial",
35 * ratio);
}
RendererManager.DrawFilledRectangle(
new RectangleF((xStart - 2) + ((build.Count + 1) * 48 * ratio), yStart - 2, 2, (uniqueAbilities.Count * 40 * ratio) + 2),
Color.Silver);
RendererManager.DrawFilledRectangle(
new RectangleF(xStart - 2, yStart - 2, 2, (uniqueAbilities.Count * 40 * ratio) + 2),
Color.Silver);
}
public SuicideDamage(TechiesCrappahilationPaid main)
{
_main = main;
var suicide = main.MenuManager.VisualSubMenu.CreateMenu("Suicide");
ShowSuicideDamage = suicide.CreateSwitcher("Show suicide damage on heroes", true);
SuicideType = suicide.CreateSwitcher("Suicide Draw type" /*, new StringList("text", "icon")*/);
var settings = suicide.CreateMenu("Settings");
PositionX = settings.CreateSlider("extra position x", 0, -100, 100);
PositionY = settings.CreateSlider("extra position y", 0, -100, 100);
TextSize = settings.CreateSlider("text size", 13, 5, 25);
PlayerPositions = new Dictionary <Hero, Vector2>();
RendererManager.Draw += () =>
{
foreach (var enemy in TargetManager.Targets)
{
if (enemy != null && enemy.IsValid)
{
if (PlayerPositions.ContainsKey(enemy))
{
PlayerPositions[enemy] = CustomHUDInfo.GetHpBarPosition(enemy);
}
else
{
PlayerPositions.Add(enemy, CustomHUDInfo.GetHpBarPosition(enemy));
}
}
}
};
RendererManager.Draw += () =>
{
if (!ShowSuicideDamage.Value)
{
return;
}
foreach (var g in PlayerPositions.ToList())
{
var enemy = g.Key;
if (!_main.Updater.BombDamageManager.DamageDictionary.ContainsKey(enemy.HeroId) ||
!enemy.IsVisible || !enemy.IsAlive)
{
continue;
}
var pos = g.Value;
// var w2s = Drawing.WorldToScreen(pos);
if (pos.IsZero)
{
continue;
}
var drawPos = pos;
// if (SuicideType.Value.SelectedIndex == 0)
if (SuicideType.Value)
{
var damage = Math
.Round(_main.Updater.BombDamageManager.DamageDictionary[enemy.HeroId].HealthAfterSuicide, 1)
.ToString(CultureInfo.InvariantCulture);
var size = RendererManager.MeasureText(damage, TextSize);
drawPos.X -= size.X + 5;
RendererManager.DrawFilledRectangle(
new RectangleF(drawPos.X - 1 + PositionX, drawPos.Y + PositionY, size.X, size.Y),
Color.Black,
Color.Black, 1);
RendererManager.DrawText(damage, drawPos + new Vector2(PositionX, PositionY), Color.White,
TextSize);
}
else
{
var willDie = _main.Updater.BombDamageManager.DamageDictionary[enemy.HeroId].HeroWillDieSuicide;
var rect = new RectangleF(drawPos.X - 26 + PositionX, drawPos.Y + PositionY, TextSize * 2 - 2,
TextSize * 2 - 2);
RendererManager.DrawTexture($"{AbilityId.techies_suicide}_icon", rect);
var clr = willDie ? Color.LimeGreen : Color.Red;
RendererManager.DrawFilledRectangle(rect,
new SharpDX.Color((float)clr.R, clr.G, clr.B, 35),
willDie ? Color.LimeGreen : Color.Red, 0.5f);
}
}
};
}
public void DrawManaBar(
Rectangle9 hpBar,
int mpPositionY,
int mpSizeY,
bool showMpRestore,
bool showMpAmount,
int manaTextSize)
{
try
{
var mana = this.unit.Mana;
var maxMana = this.unit.MaximumMana;
var mpBar = new RectangleF(
hpBar.BottomLeft.X,
hpBar.BottomLeft.Y + mpPositionY,
hpBar.Size.Width * (mana / maxMana),
hpBar.Size.Height + mpSizeY);
var borderBar = new RectangleF(
mpBar.X - this.borderSize,
mpBar.Y - this.borderSize,
hpBar.Width + (this.borderSize * 2),
mpBar.Height + (this.borderSize * 2));
RendererManager.DrawFilledRectangle(borderBar, this.borderColor);
RendererManager.DrawFilledRectangle(mpBar, this.manaColor);
if (showMpRestore)
{
var restore = 0f;
foreach (var ability in this.manaRestore)
{
if (!ability.IsValid || !ability.CanBeCasted(false))
{
continue;
}
if (ability is EnchantedMango mango)
{
restore += ability.GetManaRestore(this.unit) * mango.Charges;
}
else
{
restore += ability.GetManaRestore(this.unit);
}
}
restore = Math.Min(restore, maxMana - mana);
if (restore > 0)
{
var restoreBar = new RectangleF(
mpBar.TopRight.X,
mpBar.TopRight.Y,
hpBar.Width * (restore / maxMana),
mpBar.Height);
RendererManager.DrawFilledRectangle(restoreBar, this.manaRestoreColor);
}
}
if (showMpAmount)
{
RendererManager.DrawText(
mana.ToString("N0"),
borderBar,
Color.White,
FontFlags.Center | FontFlags.VerticalCenter,
manaTextSize);
}
}
catch (InvalidOperationException)
{
//ignore
}
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);
}
}
}
private void OnDraw()
{
try
{
var heroPosition = this.position.Value;
foreach (var unit in this.units)
{
if (!unit.IsValid)
{
continue;
}
RendererManager.DrawTexture(unit.TextureName, new RectangleF(heroPosition.X, heroPosition.Y, this.heroSize.X, this.heroSize.Y), TextureType.Unit);
var borderPosition = new Rectangle9(
heroPosition.X + this.heroSize.X + 1,
heroPosition.Y,
this.itemSize.X,
this.itemSize.Y);
for (var i = 0; i < 7; i++)
{
RendererManager.DrawTexture("o9k.inventory_item_bg", borderPosition + new Vector2((this.itemSize.X + 1) * i, 0));
}
foreach (var ability in unit.Abilities.OrderBy(x => x.Id == AbilityId.item_tpscroll))
{
if (ability.Id == AbilityId.item_tpscroll)
{
var tpPosition = new Rectangle9(
heroPosition + new Vector2(this.heroSize.X * 0.65f, this.heroSize.Y * 0.4f),
this.itemSize.X * 0.6f,
this.itemSize.X * 0.6f);
RendererManager.DrawTexture("o9k.outline", tpPosition + 1);
RendererManager.DrawTexture(ability.TextureName, tpPosition, TextureType.RoundAbility);
if (this.showCooldown)
{
var cooldown = ability.RemainingCooldown;
if (cooldown > 0)
{
RendererManager.DrawTexture("o9k.inventory_tp_cd_bg", tpPosition);
RendererManager.DrawText(
Math.Ceiling(cooldown).ToString("N0"),
tpPosition,
Color.White,
FontFlags.Center | FontFlags.VerticalCenter,
this.size * 0.35f);
}
}
continue;
}
if (!ability.IsItem || !ability.IsUsable)
{
continue;
}
var itemPosition = borderPosition - 4;
RendererManager.DrawTexture(ability.TextureName, itemPosition, TextureType.Ability);
if (this.showCharges && ability.IsDisplayingCharges)
{
var chargesText = ability.BaseItem.CurrentCharges.ToString("N0");
var chargesSize = RendererManager.MeasureText(chargesText, this.size * 0.35f);
var chargesPosition = itemPosition.SinkToBottomRight(chargesSize.X * 1.1f, chargesSize.Y * 0.8f);
RendererManager.DrawFilledRectangle(chargesPosition, Color.Black);
RendererManager.DrawText(chargesText, chargesPosition, Color.White, FontFlags.Left, this.size * 0.35f);
}
if (this.showCooldown)
{
var cooldown = ability.RemainingCooldown;
if (cooldown > 0)
{
RendererManager.DrawTexture("o9k.inventory_item_cd_bg", itemPosition);
RendererManager.DrawText(
Math.Ceiling(cooldown).ToString("N0"),
itemPosition,
Color.White,
FontFlags.Center | FontFlags.VerticalCenter,
this.size * 0.7f);
}
}
borderPosition += new Vector2(this.itemSize.X + 1, 0);
}
heroPosition += new Vector2(0, this.size + 1);
}
}
catch (InvalidOperationException)
{
//ignore
}
catch (Exception e)
{
Logger.Error(e);
}
}
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);
}
}
private void DrawTalents()
{
var ratio = Hud.Info.ScreenRatio;
var xStart = Hud.Info.ScreenSize.X * 0.6f;
var yStart = Hud.Info.ScreenSize.Y * 0.3f;
var groups = this.abilityBuilder.Talents.GroupBy(x => x.LearnLevel).ToList();
var talents = new Dictionary <uint, string>();
var nameSize = new Vector2();
foreach (var group in groups)
{
var ability = this.talentsType.Selected == BuildType.WinRate
? group.OrderByDescending(x => x.WinRate).First()
: group.OrderByDescending(x => x.PickRate).First();
var measure = RendererManager.MeasureText(ability.DisplayName, "Arial", 35 * ratio);
if (measure.X > nameSize.X)
{
nameSize = measure;
}
talents.Add(group.Key, ability.DisplayName);
}
var levelSize = RendererManager.MeasureText(talents.ElementAt(0).Key.ToString(), "Arial", 35 * ratio);
RendererManager.DrawFilledRectangle(
new RectangleF(xStart, yStart, nameSize.X + levelSize.X + 24, talents.Count * 40 * ratio),
new Color(75, 75, 75, 175));
for (var i = 0; i < talents.Count; i++)
{
RendererManager.DrawText(
talents.ElementAt(i).Key.ToString(),
new Vector2(xStart + 2, yStart + (i * 40 * ratio)),
Color.White,
"Arial",
35 * ratio);
var size = RendererManager.MeasureText(talents.ElementAt(i).Key.ToString(), "Arial", 35 * ratio);
RendererManager.DrawText(
talents.ElementAt(i).Value,
new Vector2(xStart + size.X + 10 + 2, yStart + (i * 40 * ratio)),
Color.White,
"Arial",
35 * ratio);
RendererManager.DrawFilledRectangle(
new RectangleF(xStart - 2, (yStart - 2) + (i * 40 * ratio), nameSize.X + levelSize.X + 24, 2),
Color.Silver);
}
RendererManager.DrawFilledRectangle(
new RectangleF(xStart - 2, yStart - 2, 2, (talents.Count * 40 * ratio) + 2),
Color.Silver);
RendererManager.DrawFilledRectangle(
new RectangleF((xStart - 2) + levelSize.X + 8, yStart - 2, 2, (talents.Count * 40 * ratio) + 2),
Color.Silver);
RendererManager.DrawFilledRectangle(
new RectangleF((xStart - 2) + nameSize.X + levelSize.X + 24, yStart - 2, 2, (talents.Count * 40 * ratio) + 2),
Color.Silver);
RendererManager.DrawFilledRectangle(
new RectangleF(xStart - 2, (yStart - 2) + (talents.Count * 40 * ratio), nameSize.X + levelSize.X + 24, 2),
Color.Silver);
}
public void DrawHealthBar(
Rectangle9 hpBar,
int hpPositionY,
int hpSizeY,
bool showHpRestore,
bool showHpAmount,
int hpTextSize)
{
try
{
var hp = this.unit.Health;
if (showHpRestore)
{
var maxHp = this.unit.MaximumHealth;
var restore = 0f;
var faerieAdded = false;
foreach (var ability in this.healthRestore)
{
if (!ability.IsValid || !ability.CanBeCasted(false))
{
continue;
}
if (ability.Id == AbilityId.item_faerie_fire)
{
// dont stack faerie hp restore cuz they have cooldown
if (faerieAdded)
{
continue;
}
faerieAdded = true;
}
restore += ability.GetHealthRestore(this.unit);
}
restore = Math.Min(restore, maxHp - hp);
if (restore > 0)
{
var restoreBar = new RectangleF(
hpBar.TopLeft.X + ((hpBar.Width * (hp / maxHp)) + 1),
hpBar.TopLeft.Y + hpPositionY,
hpBar.Width * (restore / maxHp),
hpBar.Height + hpSizeY);
//var borderBar = new RectangleF(
// restoreBar.X - this.borderSize,
// restoreBar.Y - this.borderSize,
// restoreBar.Width + this.borderSize * 2,
// restoreBar.Height + this.borderSize * 2);
//renderer.DrawFilledRectangle(borderBar, this.borderColor);
RendererManager.DrawFilledRectangle(restoreBar, this.healthRestoreColor);
}
}
if (showHpAmount)
{
RendererManager.DrawText(
hp.ToString("N0"),
new RectangleF(hpBar.X - (hpBar.Width / 2), hpBar.Y - (hpBar.Height / 2), hpBar.Width * 2, hpBar.Height * 2),
Color.White,
FontFlags.Center | FontFlags.VerticalCenter,
hpTextSize);
}
}
catch (InvalidOperationException)
{
//ignore
}
catch (Exception e)
{
Logger.Error(e);
}
}
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);
}
}