// 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 static Vector3 AutoAttackDodge_ZipToAroundCircle(TrackingProjectile P, Hero me)
{
var zipTarget = new Vector3(0, 0, 0);
double X;
double Y;
double k;
switch (P.Source.Name)
{
case "npc_dota_hero_obsidian_destroyer":
{
if (me.Rotation < 0)
{
k = me.RotationRad + Math.PI / 2;
}
else
{
k = me.RotationRad - Math.PI / 2;
}
X = me.Position.X + 100 * Math.Cos(k);
Y = me.Position.Y + 100 * Math.Sin(k);
zipTarget.X = Convert.ToSingle(X);
zipTarget.Y = Convert.ToSingle(Y);
zipTarget.Z = me.Position.Z;
break;
}
default:
{
break;
}
}
return(zipTarget);
}
public void AddProjectile(TrackingProjectile projectile, Unit9 target)
{
this.Drawer.Dispose(AbilityObstacleDrawer.Type.Rectangle);
this.Projectile = projectile;
this.Target = target;
this.IsUpdated = true;
}
public override void Shoot()
{
TrackingProjectile cannonBall = Instantiate(ProjectilePrefab, FirePoint.transform.position, Quaternion.identity) as TrackingProjectile;
cannonBall.Damage = GetDamageInstance();
cannonBall.Target = Target.transform;
}
// Token: 0x060002C4 RID: 708 RVA: 0x00011870 File Offset: 0x0000FA70
private bool MoveToProjectile(Unit9 target)
{
if (!this.CanMove())
{
return(false);
}
TrackingProjectile trackingProjectile = ObjectManager.TrackingProjectiles.FirstOrDefault(delegate(TrackingProjectile x)
{
if (x.IsValid)
{
Entity source = x.Source;
EntityHandle?entityHandle = (source != null) ? new EntityHandle?(source.Handle) : null;
if (((entityHandle != null) ? new uint?(entityHandle.GetValueOrDefault()) : null) == base.Owner.Handle)
{
Entity target3 = x.Target;
return(target3 != null && target3.IsValid);
}
}
return(false);
});
if (trackingProjectile == null)
{
return(false);
}
Entity target2 = trackingProjectile.Target;
Vector3 predictedPosition = target.GetPredictedPosition(trackingProjectile.Position.Distance2D(target2.Position, false) / (float)trackingProjectile.Speed + Game.Ping / 1000f);
Vector3 position = Vector3Extensions.Extend2D(target2.Position, predictedPosition, -base.Owner.Distance(target2.Position));
base.Owner.BaseUnit.Move(position);
return(true);
}
private bool IsValid(TrackingProjectile projectile)
{
if (this.heroesOnly && !(projectile.Source is Hero))
{
return(false);
}
return(true);
}
public ProjectileObstacle(EvadableAbility ability, TrackingProjectile projectile, Unit9 target)
: base(ability)
{
//todo improve
this.Projectile = projectile;
this.Target = target;
this.Speed = ability.ActiveAbility.Speed;
}
/// <summary>
/// The projectile added.
/// </summary>
/// <param name="projectile">
/// The projectile.
/// </param>
public void ProjectileAdded(TrackingProjectile projectile)
{
this.StartTime = Game.RawGameTime - Game.AvgPing / 1000;
this.AbilitySkill.AreaOfEffect.AbilityProjectile(projectile);
foreach (var particleObserver in this.projectileObservers)
{
particleObserver.OnNext(this);
}
}
public virtual void AddProjectile(TrackingProjectile projectile, Unit9 target)
{
if (this.TargetableObstacle != null && this.EndCastTime + 0.5f > GameManager.RawGameTime)
{
this.TargetableObstacle.AddProjectile(projectile, target);
}
else
{
var projectileObstacle = new ProjectileObstacle(this, projectile, target);
this.Pathfinder.AddObstacle(projectileObstacle);
}
}
public StormHammerAoeObstacle(StormHammerEvadable ability, TrackingProjectile projectile, Unit9 target)
: this(ability)
{
const int RadiusIncrease = 50;
const int RangeIncrease = 100;
this.Speed = ability.RangedAbility.Speed;
this.Radius = ability.RangedAbility.Radius + RadiusIncrease;
this.Range = ability.RangedAbility.Range + RangeIncrease;
this.EndObstacleTime = GameManager.RawGameTime + (this.Range / this.Speed);
this.AddProjectile(projectile, target);
}
public override void AddProjectile(TrackingProjectile projectile, Unit9 target)
{
if (this.targetableObstacle != null && this.EndCastTime + 0.5f > GameManager.RawGameTime)
{
this.targetableObstacle.AddProjectile(projectile, target);
this.stormHammerAoeObstacle.AddProjectile(projectile, target);
}
else
{
var projectileObstacle = new ProjectileObstacle(this, projectile, target);
this.Pathfinder.AddObstacle(projectileObstacle);
var aoeObstacle = new StormHammerAoeObstacle(this, projectile, target);
this.Pathfinder.AddObstacle(aoeObstacle);
}
}
public static Vector3 AutoAttackDodge_ZipTo(TrackingProjectile P, Hero me, float D)
{
var zipTarget = new Vector3(0, 0, 0);
double X;
double Y;
switch (P.Source.Name)
{
case "npc_dota_hero_obsidian_destroyer":
{
X = me.Position.X + D * Math.Cos(me.RotationRad);
Y = me.Position.Y + D * Math.Sin(me.RotationRad);
zipTarget.X = Convert.ToSingle(X);
zipTarget.Y = Convert.ToSingle(Y);
zipTarget.Z = me.Position.Z;
break;
}
case "queenofpain_scream_of_pain":
{
X = me.Position.X + D * Math.Cos(me.RotationRad);
Y = me.Position.Y + D * Math.Sin(me.RotationRad);
zipTarget.X = Convert.ToSingle(X);
zipTarget.Y = Convert.ToSingle(Y);
zipTarget.Z = me.Position.Z;
break;
}
case "npc_dota_hero_centaur":
{
X = me.Position.X + D * Math.Cos(me.RotationRad);
Y = me.Position.Y + D * Math.Sin(me.RotationRad);
zipTarget.X = Convert.ToSingle(X);
zipTarget.Y = Convert.ToSingle(Y);
zipTarget.Z = me.Position.Z;
break;
}
default:
{
break;
}
}
return(zipTarget);
}
override protected void fireProjectile(GameObject bullet, Transform player)
{
if (channeler == null)
{
channeler = player.FindChild("channeler");
}
TrackingProjectile proj = bullet.GetComponent <TrackingProjectile>();
proj.SetOnCollision(onCollision, onCollisionTargets);
proj.maxTurn = projManeuverability;
bullet.transform.position = channeler.position;
float angle = 45 * Mathf.Sign(player.localScale.x);
Vector3 facingDir = player.right * Mathf.Sign(player.localScale.x);
Vector3 firingDir = Quaternion.AngleAxis(angle, Vector3.forward) * facingDir;
bullet.transform.right = firingDir;
//bullet.rigidbody2D.AddForce(firingDir*bulletVelocity);
}
public static Vector3 SpellDodge_ZipFront(TrackingProjectile P, Hero me, float D)
{
var zipTarget = new Vector3(0, 0, 0);
double X;
double Y;
if (P.Source.Name == "npc_dota_hero_queenofpain" && P.Speed == 900)
{
X = me.Position.X + D * Math.Cos(me.RotationRad);
Y = me.Position.Y + D * Math.Sin(me.RotationRad);
zipTarget.X = Convert.ToSingle(X);
zipTarget.Y = Convert.ToSingle(Y);
zipTarget.Z = me.Position.Z;
}
else
{
zipTarget = me.Position;
}
return(zipTarget);
}
/// <summary>
/// The distance between two projectiles
/// </summary>
/// <param name="p1">
/// The p 1.
/// </param>
/// <param name="p2">
/// The p 2.
/// </param>
/// <returns>
/// The <see cref="float" />.
/// </returns>
public static float Distance2D(this TrackingProjectile p1, TrackingProjectile p2)
{
return p1.Position.Distance2D(p2.Position);
}
/// <summary>
/// The distance between two projectiles
/// </summary>
/// <param name="p1">
/// The p 1.
/// </param>
/// <param name="p2">
/// The p 2.
/// </param>
/// <returns>
/// The <see cref="float" />.
/// </returns>
public static float Distance2D(this TrackingProjectile p1, TrackingProjectile p2)
{
return(p1.Position.Distance2D(p2.Position));
}
public void AddProjectile(TrackingProjectile projectile)
{
this.Projectile = projectile;
}
public TrackingProjectileCommand(TrackingProjectile tp)
{
m_MoveSpeed = tp.moveSpeed;
m_VisionRadius = tp.visionRadius;
}
public void AddProjectile(TrackingProjectile projectile, Unit9 target)
{
this.Projectile = projectile;
this.Target = target;
this.IsUpdated = true;
}
public static bool IsAutoAttackProjectile(this TrackingProjectile projectile)
{
return((projectile.Flags & 256) != 0);
}
private static void AutoAttackDodge(Hero enemy, Hero me, int ZipDistance, int DistanceInPosition, int projectileDistanceThreshold, TrackingProjectile attackProjectile, bool projectileInAir)
{
var zip = me.Spellbook.SpellR;
if (enemy.IsAttacking() && ObjectManager.GetEntities <Hero>()
.Where(x => Distance2D(x, enemy) < enemy.AttackRange + 150 && x.Team == me.Team) // Valid targets within range (over slightly to account for movement during abilityphase)
.OrderBy(x => RadiansToFace(enemy, x)) // Orders targets based on radians required to be facing exactly
.FirstOrDefault() == me &&
Distance2D(enemy, me) > DistanceInPosition &&
(!projectileInAir)
// || (projectileInAir && Distance2D(attackProjectile.Position, me.Position) > projectileDistanceThreshold))
)
{
var zipTarget = ZipZap.ZipFacingDirection(me, ZipDistance);
if (Utils.SleepCheck("AutoAttackDodge"))
{
me.Stop();
PowerTread.changePowerTread();
zip.UseAbility(zipTarget);
Utils.Sleep(1000, "AutoAttackDodge");
}
}
}
/// <summary>
/// The distance between projectile and entity.
/// </summary>
/// <param name="projectile">
/// The projectile.
/// </param>
/// <param name="entity">
/// The entity.
/// </param>
/// <returns>
/// The <see cref="float" />.
/// </returns>
public static float Distance2D(this TrackingProjectile projectile, Entity entity)
{
return(projectile.Position.Distance2D(entity.Position));
}
/// <summary>
/// The projectile added.
/// </summary>
/// <param name="projectile">
/// The projectile.
/// </param>
public void ProjectileAdded(TrackingProjectile projectile)
{
this.StartTime = Game.RawGameTime - Game.AvgPing / 1000;
this.AbilitySkill.AreaOfEffect.AbilityProjectile(projectile);
this.abilityProjectileProvider.Next(this);
}
public override void AddProjectile(TrackingProjectile projectile, Unit9 target)
{
var projectileObstacle = new ProjectileObstacle(this, projectile, target);
this.Pathfinder.AddObstacle(projectileObstacle);
}
// Token: 0x060002E6 RID: 742 RVA: 0x00011E14 File Offset: 0x00010014
public override bool Combo(TargetManager targetManager, ComboModeMenu comboModeMenu)
{
AbilityHelper abilityHelper = new AbilityHelper(targetManager, comboModeMenu, this);
Unit9 target = targetManager.Target;
if (abilityHelper.UseAbility(this.hex, true))
{
return(true);
}
if (abilityHelper.CanBeCasted(this.vortex, true, true, true, true) && (target.CanBecomeMagicImmune || target.CanBecomeInvisible) && abilityHelper.UseAbility(this.vortex, true))
{
return(true);
}
if (abilityHelper.UseAbility(this.bloodthorn, true))
{
return(true);
}
if (abilityHelper.UseAbility(this.orchid, true))
{
return(true);
}
if (abilityHelper.UseAbility(this.nullifier, true))
{
return(true);
}
if (abilityHelper.UseAbility(this.dagon, true))
{
return(true);
}
if (abilityHelper.UseAbility(this.shiva, true))
{
return(true);
}
bool flag = base.Owner.CanAttack(target, 25f) && base.Owner.HasModifier("modifier_storm_spirit_overload");
TrackingProjectile trackingProjectile = ObjectManager.TrackingProjectiles.FirstOrDefault(delegate(TrackingProjectile x)
{
Entity source = x.Source;
EntityHandle?entityHandle = (source != null) ? new EntityHandle?(source.Handle) : null;
if (((entityHandle != null) ? new uint?(entityHandle.GetValueOrDefault()) : null) == this.Handle)
{
Entity target = x.Target;
entityHandle = ((target != null) ? new EntityHandle?(target.Handle) : null);
if (((entityHandle != null) ? new uint?(entityHandle.GetValueOrDefault()) : null) == target.Handle)
{
return(ProjectileExtensions.IsAutoAttackProjectile(x));
}
}
return(false);
});
if (flag)
{
if (trackingProjectile == null)
{
return(false);
}
int num = (target.IsMoving && target.GetAngle(trackingProjectile.Position, false) > 1.5f) ? 250 : 450;
if (trackingProjectile.Position.Distance2D(trackingProjectile.TargetPosition, false) > (float)num)
{
return(false);
}
}
else
{
if (trackingProjectile != null)
{
Ability9 ability = base.Owner.Abilities.FirstOrDefault((Ability9 x) => x.Id == AbilityId.storm_spirit_overload);
if (ability != null)
{
int attackDamage = base.Owner.GetAttackDamage(target, 0, 0f);
int damage = ability.GetDamage(target);
float health = target.Health;
if ((float)attackDamage < health && (float)(attackDamage + damage) > health)
{
if (abilityHelper.CanBeCasted(this.remnant, false, false, true, true) && abilityHelper.ForceUseAbility(this.remnant, true, true))
{
return(true);
}
if (abilityHelper.CanBeCasted(this.ball, false, false, true, true) && trackingProjectile.Position.Distance2D(trackingProjectile.TargetPosition, false) / (float)trackingProjectile.Speed > this.ball.Ability.CastPoint && abilityHelper.ForceUseAbility(this.ball, true, true))
{
return(true);
}
}
}
}
if (abilityHelper.UseAbility(this.vortex, true))
{
base.ComboSleeper.ExtendSleep(0.1f);
BallLightning ballLightning = this.ball;
if (ballLightning != null)
{
ballLightning.Sleeper.Sleep(1f);
}
return(true);
}
if (abilityHelper.UseAbility(this.remnant, true))
{
base.ComboSleeper.ExtendSleep(0.1f);
BallLightning ballLightning2 = this.ball;
if (ballLightning2 != null)
{
ballLightning2.Sleeper.Sleep(1f);
}
return(true);
}
}
return(abilityHelper.UseAbility(this.ball, true));
}
public static bool IsAutoAttackProjectile(this TrackingProjectile projectile)
{
return(projectile.IsAttack);
}
