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 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);
}
}
public override void Draw(RectangleF position, IMinimap minimap)
{
RendererManager.DrawTexture("o9k.ping", minimap.WorldToMinimap(this.pingPosition, 25 * Hud.Info.ScreenRatio * this.GetPingSize()));
}
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);
}
}
}
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);
}
}
};
}
private void OnRendererManagerDraw()
{
var pos = phantomAssassin.Position.WorldToMinimap();
RendererManager.DrawTexture(@"mini_heroes\npc_dota_hero_phantom_assassin.png", new RectangleF(pos.X - 11, pos.Y - 13, 24, 24));
}
protected override void OverlaySpells(IEnumerable <Ability> spells, Vector2 position, HeroId heroId, float mana, Vector2 extraSize)
{
foreach (var spell in spells)
{
if (spell.IsHidden)
{
continue;
}
var rect = new RectangleF(position.X, position.Y, extraSize.X, extraSize.Y);
RendererManager.DrawTexture(spell.Name, rect, TextureType.Ability, true);
if (spell.IsInAbilityPhase)
{
RendererManager.DrawTexture("Divine.BeAware.Resources.Textures.spell_phase.png", rect);
}
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 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);
}
}