private void OnTrackingProjectile(TrackingProjectileEventArgs args)
{
var sourceCreep = args.Projectile.Source as Creep;
var sourceTower = args.Projectile.Source as Tower;
if (sourceCreep != null)
{
if (this.Owner.Distance2D(sourceCreep) > 3000)
{
return;
}
if (sourceCreep.IsNeutral)
{
return;
}
var creepStatus = this.GetCreepStatusEntry(sourceCreep);
creepStatus.Target = args.Projectile.Target as Creep;
}
else if (sourceTower != null)
{
if (this.Owner.Distance2D(sourceTower) > 3000)
{
return;
}
var creepStatus = this.GetCreepStatusEntry(sourceTower);
creepStatus.LastAttackAnimationTime = Game.RawGameTime - creepStatus.AttackPoint - (Game.Ping / 2000f);
}
}
// 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);
}
}
private void OnAddTrackingProjectile(TrackingProjectileEventArgs args)
{
if (!this.Menu.AbilitySettings.IsCounterEnabled(this.Ability.Name))
{
return;
}
try
{
var projectile = args.Projectile;
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 OnTrackingProjectileRemoved(TrackingProjectileEventArgs args)
{
var menu = mainMenu.OnAddRemove.Projectiles;
if (!menu.OnRemoveEnabled || menu.HeroesOnly && !(args.Projectile?.Source is Hero))
{
return;
}
var projectile = args.Projectile;
if (projectile?.Source == null)
{
return;
}
const Color Color = Color.Red;
const Logger.Type Type = Logger.Type.Projectile;
logger.Write("Projectile removed", Type, Color, true);
logger.Write("Source name: " + projectile.Source.Name, Type, Color);
logger.Write("Source classID: " + projectile.Source.ClassId, Type, Color);
logger.Write("Speed: " + projectile.Speed, Type, Color);
logger.Write("Position: " + projectile.Position, Type, Color);
logger.Write("Target name: " + projectile.Target?.Name, Type, Color);
logger.Write("Target classID: " + projectile.Target?.ClassId, Type, Color);
logger.Write("Target position: " + projectile.TargetPosition, Type, Color);
logger.EmptyLine();
}
/// <summary>
/// The object manager_ on add tracking projectile.
/// </summary>
/// <param name="args">
/// The args.
/// </param>
public void ObjectManager_OnAddTrackingProjectile(TrackingProjectileEventArgs args)
{
if (args.Projectile.Source.Equals(this.Skill.Owner.SourceUnit) &&
this.Skill.SourceAbility.GetProjectileSpeed().Equals(args.Projectile.Speed))
{
this.Skill.AbilityProjectile.ProjectileAdded(args.Projectile);
}
}
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);
}
}
private void OnRemoveTrackingProjectile(TrackingProjectileEventArgs args)
{
try
{
this.projectiles.Remove(args.Projectile);
}
catch (Exception e)
{
Logger.Error(e);
}
}
public void OnAddTrackingProjectile(TrackingProjectileEventArgs args)
{
Debugger.WriteLine("==== projectile", Debugger.Type.Projectiles);
if (args.Projectile.Source != null)
{
Debugger.WriteLine("source: " + args.Projectile.Source.Name, Debugger.Type.Projectiles);
}
Debugger.WriteLine("speed: " + args.Projectile.Speed, Debugger.Type.Projectiles);
if (args.Projectile.Target != null)
{
Debugger.WriteLine("target: " + args.Projectile.Target.Name, Debugger.Type.Projectiles);
}
}
private static void ObjectManager_OnAddTrackingProjectile(TrackingProjectileEventArgs args)
{
var source = args.Projectile.Source as Unit;
var creep = args.Projectile.Target as Creep;
if (creep == null || source == null)
{
return;
}
var damage = (source.MinimumDamage + source.MaximumDamage) / 2 + source.BonusDamage;
var time = source.Distance2D(creep) / args.Projectile.Speed;
if (damage <= 0 || time <= 0)
{
return;
}
List <HealthEntry> healthInfo;
if (!HealthInformation.TryGetValue(creep, out healthInfo))
{
healthInfo = new List <HealthEntry>();
HealthInformation.Add(creep, healthInfo);
}
var latestEntry =
healthInfo.Where(x => x.Time > Game.RawGameTime).OrderByDescending(x => x.Time).FirstOrDefault();
int latestHealth;
if (latestEntry != null)
{
latestHealth = latestEntry.Health;
if (latestHealth > creep.Health)
{
latestHealth = (int)(creep.Health - (latestHealth - creep.Health));
}
}
else
{
latestHealth = (int)creep.Health;
}
healthInfo.Add(new HealthEntry(latestHealth - damage, time));
if (healthInfo.Count > 100)
{
healthInfo.RemoveRange(0, healthInfo.Count - 100);
}
}
private void ObjectManager_OnAddTrackingProjectile(TrackingProjectileEventArgs args)
{
DelayAction.Add(
-1,
() =>
{
if (args.Projectile.Source == null ||
args.Projectile.Target == null && args.Projectile.TargetPosition == Vector3.Zero)
{
return;
}
foreach (var projectileSkill in this.projectileSkills)
{
projectileSkill.Value.DataReceiver.ObjectManager_OnAddTrackingProjectile(args);
}
});
}
private void OnRemoveTrackingProjectile(TrackingProjectileEventArgs args)
{
var projectile = args.Projectile;
if (!this.IsValid(projectile))
{
return;
}
var item = new LogItem(LogType.Projectile, Color.LightPink, "Projectile removed");
item.AddLine("Source name: " + projectile.Source?.Name, projectile.Source?.Name);
item.AddLine("Source network name: " + projectile.Source?.NetworkName, projectile.Source?.NetworkName);
item.AddLine("Source classID: " + projectile.Source?.ClassId, projectile.Source?.ClassId);
item.AddLine("Speed: " + projectile.Speed, projectile.Speed);
item.AddLine("Position: " + projectile.Position, projectile.Position);
item.AddLine("Target name: " + projectile.Target?.Name, projectile.Target?.Name);
item.AddLine("Target network name: " + projectile.Target?.NetworkName, projectile.Target?.NetworkName);
item.AddLine("Target classID: " + projectile.Target?.ClassId, projectile.Target?.ClassId);
item.AddLine("Target position: " + projectile.TargetPosition, projectile.TargetPosition);
this.log.Display(item);
}
private void OnAddTrackingProjectile(TrackingProjectileEventArgs args)
{
try
{
var source = args.Projectile.Source;
if (source?.IsValid != true)
{
return;
}
var controllable = this.controllableUnits.Find(x => x.Handle == source.Handle);
if (controllable == null)
{
return;
}
controllable.MoveSleeper.Reset();
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void OnAddTrackingProjectile(TrackingProjectileEventArgs args)
{
try
{
if (!this.Menu.AbilitySettings.IsCounterEnabled(this.Ability.Name))
{
return;
}
var projectile = args.Projectile;
if (projectile == null || projectile.Source == null)
{
return;
}
if (projectile.Target?.Handle != this.Ability.Owner.Handle)
{
return;
}
var unit = EntityManager9.GetUnit(projectile.Source.Handle);
if (unit == null || unit.Team == this.Ability.Owner.Team)
{
return;
}
if (this.Ability.CanBeCasted())
{
this.ActiveAbility.UseAbility(false, true);
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void ObjectManagerOnAddTrackingProjectile(TrackingProjectileEventArgs args)
{
evader.OnAddTrackingProjectile(args);
}
public void OnAddTrackingProjectile(TrackingProjectileEventArgs args)
{
Debugger.WriteLine("==== projectile", Debugger.Type.Projectiles);
if (args.Projectile.Source != null)
{
Debugger.WriteLine("source: " + args.Projectile.Source.Name, Debugger.Type.Projectiles);
Debugger.WriteLine("source id: " + args.Projectile.Source.ClassID, Debugger.Type.Projectiles);
}
Debugger.WriteLine("speed: " + args.Projectile.Speed, Debugger.Type.Projectiles);
if (args.Projectile.Target != null)
{
Debugger.WriteLine("target: " + args.Projectile.Target.Name, Debugger.Type.Projectiles);
}
}
private void ObjectManagerOnAddTrackingProjectile(TrackingProjectileEventArgs args)
{
evader.OnAddTrackingProjectile(args);
}
private void OnRemoveTrackingProjectile(TrackingProjectileEventArgs args)
{
this.Add(new AbilityObject(null, args.Projectile.ParticleEffect));
}
private void OnAddTrackingProjectile(TrackingProjectileEventArgs args)
{
try
{
var projectile = args.Projectile;
if (!projectile.IsAutoAttackProjectile())
{
return;
}
var source = this.unitManager.GetUnit(projectile.Source);
if (source?.IsControllable != false)
{
return;
}
var target = projectile.Target;
if (target == null)
{
return;
}
var allUnits = this.unitManager.Units.ToList();
var damages = allUnits.SelectMany(x => x.IncomingDamage).OfType <RangedDamage>().ToList();
var damage = damages.LastOrDefault(
x => x.Projectile == null && !x.IsPredicted && x.MinDamage > 0 && x.Source.Unit.Handle == source.Unit.Handle &&
x.Target.Unit.Handle == target.Handle);
if (damage != null)
{
if (Game.RawGameTime < damage.HitTime)
{
damage.AddProjectile(projectile);
}
}
else
{
damage = damages.Find(x => x.Projectile == null && x.Source.Unit.Handle == source.Unit.Handle);
if (damage != null)
{
//wrong projectile target
damage.Delete();
this.AttackCanceled?.Invoke(this, damage);
}
var newTarget = allUnits.Find(x => x.Unit.Handle == target.Handle);
if (newTarget == null)
{
return;
}
damage = (RangedDamage)source.AddDamage(newTarget, 0, false, true);
damage.AddProjectile(projectile);
}
}
catch (Exception e)
{
Logger.Error(e);
}
}
private void OnAddTrackingProjectile(TrackingProjectileEventArgs args)
{
Messenger <TrackingProjectileEventArgs> .Publish(args);
}
