private void OnModifierAdded(Unit sender, ModifierChangedEventArgs args)
{
try
{
if (sender.Team == this.OwnerTeam)
{
return;
}
if (args.Modifier.Name != "modifier_slark_dark_pact")
{
return;
}
this.unit = EntityManager9.GetUnit(sender.Handle);
if (this.unit == null)
{
return;
}
this.effect = new ParticleEffect(
"particles/units/heroes/hero_slark/slark_dark_pact_start.vpcf",
sender,
ParticleAttachment.AbsOriginFollow);
Unit.OnModifierRemoved += this.OnModifierRemoved;
this.handler.IsEnabled = true;
}
catch (Exception e)
{
Logger.Error(e);
}
}
// Token: 0x06000434 RID: 1076 RVA: 0x00017138 File Offset: 0x00015338
private void OnAddTrackingProjectile(TrackingProjectileEventArgs args)
{
try
{
TrackingProjectile projectile = args.Projectile;
Entity target = projectile.Target;
EntityHandle? entityHandle = (target != null) ? new EntityHandle?(target.Handle) : null;
if (!(((entityHandle != null) ? new uint?(entityHandle.GetValueOrDefault()) : null) != base.Owner.HeroHandle))
{
Unit unit = projectile.Source as Unit;
if (!(unit == null))
{
Unit9 unit2 = EntityManager9.GetUnit(unit.Handle);
if (!(unit2 == null))
{
this.projectiles[projectile] = unit2.GetAttackDamage(base.Owner, 2, 0f);
}
}
}
}
catch (Exception ex)
{
Logger.Error(ex, null);
}
}
public bool ShouldBlock(ExecuteOrderEventArgs args)
{
if (!this.menu.BlockTooFastReaction)
{
return(false);
}
switch (args.OrderId)
{
case OrderId.AttackTarget:
case OrderId.AbilityTarget:
case OrderId.MoveTarget:
{
var target = EntityManager9.GetUnitFast(args.Target.Handle);
if (target == null)
{
return(false);
}
if (Game.RawGameTime - target.LastNotVisibleTime < RNG.Randomize(0.25f, 0.03f))
{
return(true);
}
break;
}
}
return(false);
}
private void OnHandlePropertyChange(Entity sender, HandlePropertyChangeEventArgs args)
{
try
{
if (args.NewValue == args.OldValue || args.PropertyName != "m_hTowerAttackTarget")
{
return;
}
var unit = EntityManager9.GetUnit(args.NewValue);
if (unit == null || !unit.IsHero || unit.IsIllusion || unit.Distance(this.owner) > 1000)
{
return;
}
this.effect?.Dispose();
this.effect = new ParticleEffect(@"materials\ensage_ui\particles\target.vpcf", unit.Position);
this.effect.SetControlPoint(2, sender.Position);
this.effect.SetControlPoint(5, new Vector3(255, 0, 0));
this.effect.SetControlPoint(6, new Vector3(255));
this.tower = (Tower)sender;
this.towerTarget = unit;
this.handler.IsEnabled = true;
}
catch (Exception e)
{
Logger.Error(e);
}
}
public override void AddDrawableAbility(
List <IDrawableAbility> drawableAbilities,
ParticleEffect particle,
Team allyTeam,
INotificator notificator)
{
if (particle.GetControlPoint(1) == new Vector3(-1))
{
return;
}
var owner = this.SearchOwner || !(particle.Owner is Unit)
? EntityManager9.Abilities.FirstOrDefault(x => x.Id == this.AbilityId && x.Owner.Team != allyTeam)?.Owner
: EntityManager9.GetUnit(particle.Owner.Handle);
if (owner?.IsVisible != false)
{
return;
}
string ownerName;
if (owner.IsHero)
{
ownerName = owner.Name;
}
else
{
ownerName = owner.Owner?.Name;
if (ownerName == null)
{
return;
}
}
var drawableAbility = new DrawableAbility
{
AbilityTexture = this.AbilityId + "_rounded",
HeroTexture = ownerName + "_rounded",
MinimapHeroTexture = ownerName + "_icon",
ShowUntil = Game.RawGameTime + this.TimeToShow,
Position = (this.RawParticlePosition ? particle.Position : particle.GetControlPoint(this.ControlPoint)).SetZ(350)
};
owner.ChangeBasePosition(drawableAbility.Position);
if (this.Replace)
{
var exist = drawableAbilities.LastOrDefault(
x => x.AbilityTexture == drawableAbility.AbilityTexture && x.HeroTexture == drawableAbility.HeroTexture);
if (exist != null)
{
drawableAbilities.Remove(exist);
}
}
drawableAbilities.Add(drawableAbility);
}
private void OnModifierAdded(ModifierAddedEventArgs e)
{
try
{
var modifier = e.Modifier;
var sender = modifier.Owner;
if (sender.Team == this.OwnerTeam)
{
return;
}
if (modifier.Name != "modifier_slark_dark_pact")
{
return;
}
this.unit = EntityManager9.GetUnit(sender.Handle);
if (this.unit == null)
{
return;
}
this.effect = ParticleManager.CreateParticle(
"particles/units/heroes/hero_slark/slark_dark_pact_start.vpcf",
ParticleAttachment.AbsOriginFollow,
sender);
ModifierManager.ModifierRemoved += this.OnModifierRemoved;
this.handler.IsEnabled = true;
}
catch (Exception ex)
{
Logger.Error(ex);
}
}
// Token: 0x06000316 RID: 790 RVA: 0x0001B808 File Offset: 0x00019A08
public override void AddDrawableAbility(List <IDrawableAbility> drawableAbilities, ParticleEffect particle, Team allyTeam, INotificator notificator)
{
Unit9 unit = EntityManager9.GetUnit(particle.Owner.Handle);
if (unit == null || unit.IsVisible)
{
return;
}
Vector3 v = base.RawParticlePosition ? particle.Position : particle.GetControlPoint(base.ControlPoint);
if (v.Distance2D(unit.BaseUnit.Position, false) < 50f)
{
return;
}
string name = unit.Name;
DrawableAbility drawableAbility = new DrawableAbility
{
AbilityTexture = base.AbilityId + "_rounded",
HeroTexture = name + "_rounded",
MinimapHeroTexture = name + "_icon",
ShowUntil = Game.RawGameTime + base.TimeToShow,
Position = v.SetZ(new float?((float)350))
};
if (base.Replace)
{
IDrawableAbility drawableAbility2 = drawableAbilities.LastOrDefault((IDrawableAbility x) => x.AbilityTexture == drawableAbility.AbilityTexture && x.HeroTexture == drawableAbility.HeroTexture);
if (drawableAbility2 != null)
{
drawableAbilities.Remove(drawableAbility2);
}
}
drawableAbilities.Add(drawableAbility);
}
private void OnOrderAdding(OrderAddingEventArgs e)
{
var order = e.Order;
if (order.IsQueued || !e.Process)
{
return;
}
try
{
switch (order.Type)
{
case OrderType.AttackTarget:
{
SetTarget(order.Units, order.Target.Handle);
break;
}
case OrderType.Hold:
case OrderType.Stop:
{
var units = order.Units;
DropTarget(units);
StopChanneling(units);
break;
}
case OrderType.MovePosition:
case OrderType.MoveTarget:
{
DropTarget(order.Units);
break;
}
case OrderType.CastTarget:
{
var target = EntityManager9.GetUnitFast(order.Target.Handle);
if (target?.IsLinkensProtected == true)
{
return;
}
StartChanneling(order.Ability.Handle);
break;
}
case OrderType.Cast:
case OrderType.CastPosition:
{
StartChanneling(order.Ability.Handle);
break;
}
}
}
catch (Exception ex)
{
Logger.Error(ex);
}
}
// Token: 0x06000111 RID: 273 RVA: 0x0000A8A4 File Offset: 0x00008AA4
private void OnAbilityRemoved(Ability9 ability)
{
try
{
if (ability.IsItem)
{
Unit9 unit = ability.Owner;
if (unit is SpiritBear)
{
unit = EntityManager9.GetUnit(unit.Owner.Handle);
if (unit == null)
{
return;
}
}
if (this.units.ContainsKey(unit))
{
Dictionary <Unit9, int> dictionary = this.units;
Unit9 key = unit;
dictionary[key] -= (int)ability.BaseItem.Cost;
}
}
}
catch (Exception exception)
{
Logger.Error(exception, null);
}
}
public override bool IsIntersecting(Unit9 unit, bool checkPrediction)
{
var position = this.missileUnit.NetworkPosition;
if (this.initialPosition == position)
{
return(false);
}
var missile = EntityManager9.GetUnit(this.missileUnit.Handle);
if (missile == null)
{
return(false);
}
var target = EntityManager9.Units.Where(x => x.IsEnemy(this.Caster) && x.IsAlive && x.IsUnit)
.OrderBy(x => missile.GetAngle(x.Position))
.FirstOrDefault();
if (target == null)
{
return(false);
}
return(unit.Equals(target));
}
// Token: 0x060003B9 RID: 953 RVA: 0x0001D1F8 File Offset: 0x0001B3F8
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
if (args.IsQueued)
{
return;
}
try
{
OrderId orderId = args.OrderId;
switch (orderId)
{
case OrderId.MoveLocation:
case OrderId.MoveTarget:
UnitMonitor.DropTarget(args.Entities);
goto IL_DE;
case OrderId.AttackLocation:
case OrderId.AbilityTargetTree:
case OrderId.ToggleAbility:
goto IL_DE;
case OrderId.AttackTarget:
UnitMonitor.SetTarget(args.Entities, args.Target.Handle);
goto IL_DE;
case OrderId.AbilityLocation:
case OrderId.Ability:
UnitMonitor.StartChanneling(args.Ability.Handle);
goto IL_DE;
case OrderId.AbilityTarget:
{
Unit9 unitFast = EntityManager9.GetUnitFast(args.Target.Handle);
if (unitFast != null && unitFast.IsLinkensProtected)
{
return;
}
UnitMonitor.StartChanneling(args.Ability.Handle);
goto IL_DE;
}
case OrderId.Hold:
break;
default:
if (orderId != OrderId.Stop)
{
goto IL_DE;
}
break;
}
UnitMonitor.DropTarget(args.Entities);
UnitMonitor.StopChanneling(args.Entities);
IL_DE :;
}
catch (Exception exception)
{
Logger.Error(exception, null);
}
}
// Token: 0x060008DB RID: 2267 RVA: 0x000226F8 File Offset: 0x000208F8
internal override void SetOwner(Unit9 owner)
{
base.SetOwner(owner);
Ability ability = EntityManager9.BaseAbilities.FirstOrDefault(delegate(Ability x)
{
if (x.Id == AbilityId.zuus_static_field)
{
Entity owner2 = x.Owner;
EntityHandle?entityHandle = (owner2 != null) ? new EntityHandle?(owner2.Handle) : null;
return(((entityHandle != null) ? new uint?(entityHandle.GetValueOrDefault()) : null) == owner.Handle);
}
return(false);
});
if (ability != null)
{
this.staticField = (StaticField)EntityManager9.AddAbility(ability);
}
ability = EntityManager9.BaseAbilities.FirstOrDefault(delegate(Ability x)
{
if (x.Id == AbilityId.zuus_lightning_bolt)
{
Entity owner2 = x.Owner;
EntityHandle?entityHandle = (owner2 != null) ? new EntityHandle?(owner2.Handle) : null;
return(((entityHandle != null) ? new uint?(entityHandle.GetValueOrDefault()) : null) == owner.Handle);
}
return(false);
});
if (ability != null)
{
this.lightningBolt = (LightningBolt)EntityManager9.AddAbility(ability);
}
}
private void OnOrderAdding(OrderAddingEventArgs e)
{
try
{
if (!e.Process || !e.IsCustom)
{
return;
}
var order = e.Order;
if (order.Type != OrderType.CastPosition)
{
return;
}
var ability = EntityManager9.GetAbility(order.Ability.Handle);
if (ability == null)
{
return;
}
if (this.IsIgnored(ability))
{
return;
}
this.abilityPositions[ability.Handle] = order.Position;
}
catch (Exception ex)
{
Logger.Error(ex);
}
}
private void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
try
{
if (!args.Process || args.IsPlayerInput || args.OrderId != OrderId.AbilityLocation)
{
return;
}
var ability = EntityManager9.GetAbility(args.Ability.Handle);
if (ability == null)
{
return;
}
if (this.IsIgnored(ability))
{
return;
}
this.abilityPositions[ability.Handle] = args.TargetPosition;
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void OnBoolPropertyChange(Entity sender, BoolPropertyChangeEventArgs args)
{
try
{
if (args.OldValue == args.NewValue || (!args.OldValue && args.NewValue) || args.PropertyName != "m_bIsWaitingToSpawn")
{
return;
}
if (this.spawnSleeper)
{
return;
}
var unit = EntityManager9.GetUnit(sender.Handle);
if (unit == null || !unit.IsLaneCreep || unit.Team != this.ownerTeam)
{
return;
}
foreach (var creepWave in this.creepWaves.Where(x => !x.IsSpawned))
{
creepWave.Spawn();
}
this.spawnSleeper.Sleep(25);
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void OnAddTrackingProjectile(TrackingProjectileAddedEventArgs args)
{
if (!this.Menu.AbilitySettings.IsCounterEnabled(this.Ability.Name))
{
return;
}
try
{
var projectile = args.TrackingProjectile;
if (projectile.Target?.Handle != this.Owner.Handle)
{
return;
}
var source = projectile.Source as Unit;
if (source == null)
{
return;
}
var unit = EntityManager9.GetUnit(source.Handle);
if (unit == null)
{
return;
}
this.projectiles[projectile] = unit.GetAttackDamage(this.Owner, DamageValue.Maximum);
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void OnHandlePropertyChange(Entity sender, HandlePropertyChangeEventArgs args)
{
if (sender.Team == this.allyTeam || args.NewValue == args.OldValue || !args.OldValue.IsValid ||
args.PropertyName != "m_hKillCamUnit")
{
return;
}
try
{
// respawn
var handle = ((Player)sender).Hero?.Handle;
var unit = (Hero9)EntityManager9.GetUnitFast(handle);
if (unit == null)
{
return;
}
UpdateManager.BeginInvoke(() => RespawnUnit(unit), 500);
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void OnModifierRemoved(ModifierRemovedEventArgs e)
{
var modifier = e.Modifier;
var sender = modifier.Owner;
try
{
if (sender.Team != this.owner.Team || modifier.IsHidden || !this.denyModifiers.Contains(modifier.Name))
{
return;
}
var unit = EntityManager9.GetUnit(sender.Handle);
if (unit == null || !this.units.TryGetValue(unit, out var effect))
{
return;
}
effect?.Dispose();
this.units.Remove(unit);
}
catch (Exception ex)
{
Logger.Error(ex, sender);
}
}
private void OnModifierAdded(ModifierAddedEventArgs e)
{
var modifier = e.Modifier;
var sender = modifier.Owner;
try
{
if (sender.Team != this.owner.Team || modifier.IsHidden || !this.denyModifiers.Contains(modifier.Name))
{
return;
}
var unit = EntityManager9.GetUnit(sender.Handle);
if (unit == null || unit.IsMyHero || unit.IsIllusion || !unit.IsHero)
{
return;
}
this.units[unit] = null;
this.handler.IsEnabled = true;
}
catch (Exception ex)
{
Logger.Error(ex, sender);
}
}
private void OnBoolPropertyChange(Entity sender, BoolPropertyChangeEventArgs args)
{
try
{
if (args.NewValue == args.OldValue || args.PropertyName != "m_bInAbilityPhase")
{
return;
}
var ability = EntityManager9.GetAbility(sender.Handle) as ActiveAbility;
if (ability?.IsControllable != true)
{
return;
}
if (this.IsIgnored(ability))
{
return;
}
if (!(ability is AreaOfEffectAbility) && !(ability is PredictionAbility))
{
return;
}
if (args.NewValue)
{
if (ability is AreaOfEffectAbility)
{
if (ability.CastRange > 0)
{
UpdateManager.BeginInvoke(
() => this.abilityPositions[ability.Handle] = ability.Owner.InFront(ability.CastRange),
10);
}
else
{
UpdateManager.BeginInvoke(() => this.abilityPositions[ability.Handle] = ability.Owner.Position, 10);
}
}
this.abilityTimings[ability] = Game.RawGameTime + ability.CastPoint;
this.failSafeHandler.IsEnabled = true;
}
else
{
this.abilityTimings.Remove(ability);
this.abilityPositions.Remove(ability.Handle);
if (this.abilityTimings.Count <= 0)
{
this.failSafeHandler.IsEnabled = false;
}
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
// Token: 0x060002E4 RID: 740 RVA: 0x0001ACFC File Offset: 0x00018EFC
public override void AddDrawableAbility(List <IDrawableAbility> drawableAbilities, ParticleEffect particle, Team allyTeam, INotificator notificator)
{
Vector3 position = particle.GetControlPoint(base.ControlPoint);
if (particle.Name.Contains("detonate"))
{
DrawableRemoteMinesAbility drawableRemoteMinesAbility = drawableAbilities.OfType <DrawableRemoteMinesAbility>().FirstOrDefault((DrawableRemoteMinesAbility x) => x.Position.Distance2D(position, false) < 10f);
if (drawableRemoteMinesAbility != null)
{
if (drawableRemoteMinesAbility.IsShowingRange)
{
drawableRemoteMinesAbility.RemoveRange();
}
drawableAbilities.Remove(drawableRemoteMinesAbility);
return;
}
}
else
{
if (ObjectManager.GetEntitiesFast <Unit>().FirstOrDefault((Unit x) => x.Name == "npc_dota_techies_remote_mine" && x.Distance2D(position) < 10f) != null)
{
return;
}
Unit9 owner = EntityManager9.GetUnit(particle.Owner.Handle);
if (owner == null)
{
return;
}
UpdateManager.BeginInvoke(delegate
{
try
{
if (particle.IsValid)
{
DrawableRemoteMinesAbility drawableRemoteMinesAbility2 = new DrawableRemoteMinesAbility
{
AbilityTexture = this.AbilityId + "_rounded",
HeroTexture = owner.Name + "_rounded",
MinimapHeroTexture = owner.Name + "_icon",
Position = position.SetZ(new float?((float)350)),
Duration = this.Duration,
IsShowingRange = this.ShowRange,
Range = this.Range,
RangeColor = this.RangeColor,
ShowUntil = Game.RawGameTime + this.Duration,
ShowHeroUntil = Game.RawGameTime + this.TimeToShow,
Owner = owner.BaseEntity
};
drawableRemoteMinesAbility2.DrawRange();
drawableAbilities.Add(drawableRemoteMinesAbility2);
}
}
catch (Exception exception)
{
Logger.Error(exception, null);
}
}, 1000);
}
}
public bool ShouldBlock(ExecuteOrderEventArgs args)
{
if (!this.menu.SlowDown)
{
return(false);
}
if (!args.Entities.Any())
{
return(false);
}
switch (args.OrderId)
{
case OrderId.Ability:
case OrderId.AbilityTarget:
case OrderId.AbilityLocation:
case OrderId.AbilityTargetRune:
case OrderId.AbilityTargetTree:
{
var handle = args.Entities.First().Handle;
if (this.abilitySleeper.IsSleeping(handle))
{
return(true);
}
var ability = (ActiveAbility)EntityManager9.GetAbilityFast(args.Ability.Handle);
if (ability == null)
{
return(false);
}
if (this.lowDelayAbilities.Contains(ability.Id))
{
this.abilitySleeper.Sleep(handle, ability.CastPoint + AbilityLowDelay);
}
else
{
this.abilitySleeper.Sleep(handle, ability.CastPoint + AbilityDelay);
}
return(false);
}
case OrderId.Hold:
case OrderId.Stop:
//case OrderId.MoveLocation:
//case OrderId.AttackTarget:
{
var handle = args.Entities.First().Handle;
this.abilitySleeper.Reset(handle);
break;
}
}
return(false);
}
private void OnGameEvent(GameEventEventArgs e)
{
try
{
var gameEvent = e.GameEvent;
switch (gameEvent.Name)
{
case "dota_player_kill":
case "dota_player_deny":
{
var id = gameEvent.GetInt32("victim_userid");
var handle = EntityManager.GetPlayerById(id)?.Hero?.Handle;
var unit = (Hero9)EntityManager9.GetUnitFast(handle);
if (unit == null || unit.Team == this.allyTeam)
{
break;
}
unit.BaseIsAlive = false;
if (unit.IsVisible)
{
var delay = (int)(((unit.BaseHero.RespawnTime - GameManager.RawGameTime) + 0.5f) * 1000);
if (delay <= 0)
{
break;
}
UpdateManager.BeginInvoke(delay, () => RespawnUnit(unit));
}
}
break;
case "dota_buyback":
{
var id = gameEvent.GetInt32("player_id");
var handle = EntityManager.GetPlayerById(id)?.Hero?.Handle;
var unit = EntityManager9.GetUnitFast(handle);
if (unit == null || unit.Team == this.allyTeam)
{
break;
}
unit.BaseIsAlive = true;
unit.BaseHealth = unit.MaximumHealth;
unit.BaseMana = unit.MaximumMana;
}
break;
}
}
catch (Exception ex)
{
Logger.Error(ex);
}
}
private void OnAddTrackingProjectile(TrackingProjectileEventArgs args)
{
try
{
var projectile = args.Projectile;
if (projectile.IsAutoAttackProjectile())
{
return;
}
var target = EntityManager9.GetUnit(projectile.Target.Handle);
if (target == null || target.Team != this.myTeam)
{
return;
}
var source = args.Projectile.Source;
if (source != null)
{
//// enemy ability, but added though ally
//// might add some ability prediction problems...
//var thoughAlly = target.Team == this.myTeam && source.Team == this.myTeam;
//var ability = this.evadableAbilities.OfType<IProjectile>()
// .FirstOrDefault(
// x => (int)x.ActiveAbility.Speed == projectile.Speed && x.ActiveAbility.TimeSinceCasted < 1.5f
// && (thoughAlly || x.ActiveAbility.Owner.Handle == source.Handle));
var ability = this.evadableAbilities
.Where(
x => x.Ability.Owner.Handle == source.Handle &&
(x.Ability.TimeSinceCasted < 1.5f + (x.Ability is IChanneled channeled ? channeled.ChannelTime : 0) ||
x.Ability.BaseAbility.IsHidden))
.OfType <IProjectile>()
.FirstOrDefault(x => (int)x.ActiveAbility.Speed == projectile.Speed);
ability?.AddProjectile(projectile, target);
return;
}
var predictedAbilities = this.evadableAbilities.Where(
x => !x.Ability.Owner.IsVisible || x.Ability.TimeSinceCasted < 1.5f
/*+ x.AdditionalDelay*/)
.OfType <IProjectile>()
.Where(x => (int)x.ActiveAbility.Speed == projectile.Speed)
.ToList();
if (predictedAbilities.Count == 1)
{
predictedAbilities[0].AddProjectile(projectile, target);
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
// Token: 0x060003BA RID: 954 RVA: 0x0001D300 File Offset: 0x0001B500
private void OnInt32PropertyChange(Entity sender, Int32PropertyChangeEventArgs args)
{
int newValue = args.NewValue;
if (newValue == args.OldValue)
{
return;
}
try
{
Unit9 unitFast = EntityManager9.GetUnitFast(sender.Handle);
if (!(unitFast == null))
{
string propertyName = args.PropertyName;
if (!(propertyName == "m_iHealth"))
{
if (propertyName == "m_NetworkActivity")
{
if (unitFast.IsValid)
{
if (this.attackActivities.Contains(newValue))
{
this.AttackStarted(unitFast);
}
else
{
this.AttackStopped(unitFast);
}
}
}
}
else if (newValue > 0)
{
UnitMonitor.HealthEventHandler unitHealthChange = this.UnitHealthChange;
if (unitHealthChange != null)
{
unitHealthChange(unitFast, (float)newValue);
}
}
else
{
unitFast.DeathTime = Game.RawGameTime;
this.AttackStopped(unitFast);
this.attackSleeper.Remove(unitFast.Handle);
UnitMonitor.EventHandler unitDied = this.UnitDied;
if (unitDied != null)
{
unitDied(unitFast);
}
}
}
}
catch (Exception exception)
{
Logger.Error(exception, sender, null);
}
}
// Token: 0x060002ED RID: 749 RVA: 0x0001AF90 File Offset: 0x00019190
public override void AddDrawableAbility(List <IDrawableAbility> drawableAbilities, ParticleEffect particle, Team allyTeam, INotificator notificator)
{
if (particle.GetControlPoint(1u) == new Vector3(-1f))
{
return;
}
Unit9 unit;
if (!base.SearchOwner && particle.Owner is Unit)
{
unit = EntityManager9.GetUnit(particle.Owner.Handle);
}
else
{
Ability9 ability = EntityManager9.Abilities.FirstOrDefault((Ability9 x) => x.Id == this.AbilityId && x.Owner.Team != allyTeam);
unit = ((ability != null) ? ability.Owner : null);
}
Unit9 unit2 = unit;
if (unit2 == null || unit2.IsVisible)
{
return;
}
string text;
if (unit2.IsHero)
{
text = unit2.Name;
}
else
{
Unit9 owner = unit2.Owner;
text = ((owner != null) ? owner.Name : null);
if (text == null)
{
return;
}
}
DrawableAbility drawableAbility = new DrawableAbility
{
AbilityTexture = base.AbilityId + "_rounded",
HeroTexture = text + "_rounded",
MinimapHeroTexture = text + "_icon",
ShowUntil = Game.RawGameTime + base.TimeToShow,
Position = (base.RawParticlePosition ? particle.Position : particle.GetControlPoint(base.ControlPoint)).SetZ(new float?((float)350))
};
if (base.Replace)
{
IDrawableAbility drawableAbility2 = drawableAbilities.LastOrDefault((IDrawableAbility x) => x.AbilityTexture == drawableAbility.AbilityTexture && x.HeroTexture == drawableAbility.HeroTexture);
if (drawableAbility2 != null)
{
drawableAbilities.Remove(drawableAbility2);
}
}
drawableAbilities.Add(drawableAbility);
}
private static void OnExecuteOrder(Player sender, ExecuteOrderEventArgs args)
{
if (args.IsQueued || !args.Process)
{
return;
}
try
{
switch (args.OrderId)
{
case OrderId.AttackTarget:
{
SetTarget(args.Entities, args.Target.Handle);
break;
}
case OrderId.Hold:
case OrderId.Stop:
{
DropTarget(args.Entities);
StopChanneling(args.Entities);
break;
}
case OrderId.MoveLocation:
case OrderId.MoveTarget:
{
DropTarget(args.Entities);
break;
}
case OrderId.AbilityTarget:
{
var target = EntityManager9.GetUnitFast(args.Target.Handle);
if (target?.IsLinkensProtected == true)
{
return;
}
StartChanneling(args.Ability.Handle);
break;
}
case OrderId.Ability:
case OrderId.AbilityLocation:
{
StartChanneling(args.Ability.Handle);
break;
}
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
private static void StartChanneling(uint abilityHandle)
{
if (!(EntityManager9.GetAbilityFast(abilityHandle) is IChanneled channeled))
{
return;
}
channeled.Owner.ChannelEndTime = Game.RawGameTime + channeled.GetCastDelay() + 1f;
}
private void CheckTeleport(ParticleEffect particle, bool start)
{
try
{
if (!particle.IsValid)
{
return;
}
var colorCp = particle.GetControlPoint(2);
var color = Color.FromArgb(
(int)(255 * Math.Round(colorCp.X, 2)),
(int)(255 * Math.Round(colorCp.Y, 2)),
(int)(255 * Math.Round(colorCp.Z, 2)));
if (!this.colors.TryGetValue(color, out var id))
{
return;
}
var player = ObjectManager.GetPlayerById(id);
if (player == null || player.Hero == null || player.Team == this.ownerTeam)
{
return;
}
var hero = (Hero9)EntityManager9.GetUnit(player.Hero.Handle);
if (hero == null || (hero.IsVisible && start))
{
return;
}
var position = particle.GetControlPoint(0);
var heroId = hero.Id;
var duration = 3f;
// if (hero.Abilities.Any(x => x.Id == AbilityId.item_travel_boots && x.CanBeCasted(false)))
{
duration = this.GetDuration(heroId, position, start);
}
this.AddTeleport(new Teleport(particle, heroId, position, duration, start));
if (start)
{
hero.ChangeBasePosition(position);
}
else
{
UpdateManager.BeginInvoke(() => this.SetPosition(particle, position, hero), (int)(duration * 1000) - 200);
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void OnInt32PropertyChange(Entity sender, Int32PropertyChangeEventArgs args)
{
var newValue = args.NewValue;
if (newValue == args.OldValue)
{
return;
}
try
{
var unit = EntityManager9.GetUnitFast(sender.Handle);
if (unit == null)
{
return;
}
switch (args.PropertyName)
{
case "m_iHealth":
{
if (newValue > 0)
{
this.UnitHealthChange?.Invoke(unit, newValue);
break;
}
unit.DeathTime = Game.RawGameTime;
this.AttackStopped(unit);
this.attackSleeper.Remove(unit.Handle);
this.UnitDied?.Invoke(unit);
break;
}
case "m_NetworkActivity":
{
if (this.attackActivities.Contains(newValue))
{
this.AttackStarted(unit);
}
else
{
this.AttackStopped(unit);
}
break;
}
}
}
catch (Exception e)
{
Logger.Error(e, sender);
}
}
