// Token: 0x060008C2 RID: 2242 RVA: 0x00027720 File Offset: 0x00025920
public bool Use(Hero9 target, ComboModeMenu menu, float useRange, float blinkRange)
{
foreach (IGrouping <Unit9, OldBlinkAbility> grouping in from x in base.Abilities
where x.Ability.IsValid
group x by x.Ability.Owner)
{
Unit9 key = grouping.Key;
if (key.Distance(target) >= useRange)
{
foreach (OldBlinkAbility oldBlinkAbility in grouping)
{
if (oldBlinkAbility.CanBeCasted(menu))
{
Vector3 vector = Vector3Extensions.Extend2D(target.Position, key.Position, blinkRange);
if (key.Distance(vector) <= oldBlinkAbility.Blink.Range)
{
if (oldBlinkAbility.Blink.PositionCast && oldBlinkAbility.Use(vector))
{
return(true);
}
if ((double)key.GetAngle(vector, false) < 0.2 && oldBlinkAbility.Use(key))
{
return(true);
}
}
}
}
}
}
return(false);
}
// Token: 0x06000A12 RID: 2578 RVA: 0x0002BE6C File Offset: 0x0002A06C
public bool UseDoubleBlinkCombo(ForceStaff force, BlinkAbility blink, float minDistance = 0f)
{
if (!this.CanBeCasted(force, false, true, true, true) || !this.CanBeCasted(blink, false, true, true, true))
{
return(false);
}
Unit9 target = this.TargetManager.Target;
Unit9 owner = force.Ability.Owner;
if (owner.Distance(target) < minDistance || owner.Distance(target) < blink.Ability.Range)
{
return(false);
}
float num = blink.Ability.Range + force.Ability.Range;
if (owner.Distance(target) > num)
{
return(false);
}
if (owner.GetAngle(target.Position, false) > 0.5f)
{
owner.BaseUnit.Move(target.Position);
this.comboSleeper.Sleep(0.1f);
return(false);
}
force.Ability.UseAbility(owner, false, false);
this.comboSleeper.Sleep(force.Ability.GetCastDelay() + 0.3f);
return(false);
}
// Token: 0x06000A73 RID: 2675 RVA: 0x0002CF90 File Offset: 0x0002B190
public override bool UseAbility(TargetManager targetManager, Sleeper comboSleeper, float minDistance, float blinkDistance)
{
Unit9 target = targetManager.Target;
if (base.Owner.Distance(target) < minDistance)
{
return(false);
}
if (target.Distance(base.Owner) > base.Ability.Range + blinkDistance)
{
return(false);
}
if (base.Owner.GetAngle(target.Position, false) > 0.5f)
{
return(base.Owner.BaseUnit.Move(target.Position));
}
if (!base.Ability.UseAbility(base.Owner, false, false))
{
return(false);
}
float castDelay = base.Ability.GetCastDelay();
comboSleeper.Sleep(base.Ability.GetHitTime(target.Position));
base.Sleeper.Sleep(castDelay + 0.5f);
base.OrbwalkSleeper.Sleep(castDelay);
return(true);
}
// Token: 0x060008C6 RID: 2246 RVA: 0x000279C0 File Offset: 0x00025BC0
private bool UseComboBlink(Unit9 owner, IEnumerable <OldBlinkAbility> blinkAbilities, float distance, Vector3 position, Unit9 target)
{
bool flag = false;
List <OldBlinkAbility> list = new List <OldBlinkAbility>();
foreach (OldBlinkAbility oldBlinkAbility in blinkAbilities)
{
distance -= oldBlinkAbility.Blink.Range;
list.Add(oldBlinkAbility);
if (distance < 0f)
{
flag = true;
break;
}
}
if (flag)
{
OldBlinkAbility oldBlinkAbility2 = list.LastOrDefault <OldBlinkAbility>();
if (oldBlinkAbility2 == null)
{
return(false);
}
float num = Math.Min(owner.Distance(position), oldBlinkAbility2.Blink.Range);
Vector3 position2 = Vector3Extensions.Extend2D(owner.Position, position, num);
if (this.UseSingleBlink(owner, new OldBlinkAbility[]
{
oldBlinkAbility2
}, position2, distance) == true)
{
return(true);
}
}
return(false);
}
// Token: 0x06000295 RID: 661 RVA: 0x000109A0 File Offset: 0x0000EBA0
public bool ShouldReturnChakram(TargetManager targetManager, int damagingChakrams)
{
if (base.Sleeper.IsSleeping || !this.chakram.ReturnChakram.CanBeCasted(true))
{
return(false);
}
Unit9 target = targetManager.Target;
if (this.IsDamaging(targetManager))
{
if (target.Health < (float)(base.Ability.GetDamage(target) / 2 * damagingChakrams))
{
return(true);
}
if (target.GetAngle(this.castPosition, false) < 0.75f)
{
return(false);
}
if (target.IsMoving && target.Distance(this.castPosition) > base.Ability.Radius - 50f)
{
return(true);
}
}
else if (target.GetAngle(this.castPosition, false) > 0.5f)
{
return(true);
}
return(false);
}
// Token: 0x06000A13 RID: 2579 RVA: 0x0002BF58 File Offset: 0x0002A158
public bool UseForceStaffAway(ForceStaff force, int range)
{
if (!this.CanBeCasted(force, true, true, true, true))
{
return(false);
}
Unit9 target = this.TargetManager.Target;
if (target.IsRanged || target.IsStunned || target.IsRooted || target.IsHexed || target.IsDisarmed)
{
return(false);
}
Unit9 owner = force.Ability.Owner;
if (target.Distance(owner) > (float)range)
{
return(false);
}
Vector3 mousePosition = Game.MousePosition;
if (owner.GetAngle(mousePosition, false) > 1f)
{
owner.BaseUnit.Move(mousePosition);
UpdateManager.BeginInvoke(delegate
{
force.Ability.UseAbility(owner, false, false);
}, 200);
return(true);
}
return(false);
}
// Token: 0x060009C3 RID: 2499 RVA: 0x0002A788 File Offset: 0x00028988
public override bool UseAbility(TargetManager targetManager, Sleeper comboSleeper, bool aoe)
{
Unit9 target = targetManager.Target;
float attackRange = base.Owner.GetAttackRange(target, 0f);
float num = target.Distance(base.Owner);
if (num <= attackRange + 100f)
{
return(false);
}
if (num <= attackRange + 250f && base.Owner.Speed > targetManager.Target.Speed + 50f)
{
return(false);
}
Vector3 vector = (target.GetAngle(base.Owner, false) < 1f) ? Vector3Extensions.Extend2D(target.Position, EntityManager9.EnemyFountain, 100f) : target.GetPredictedPosition(base.Ability.CastPoint + 0.3f);
if (base.Owner.Distance(vector) > base.Ability.CastRange)
{
return(false);
}
if (!base.Ability.UseAbility(vector, false, false))
{
return(false);
}
float castDelay = base.Ability.GetCastDelay(target);
comboSleeper.Sleep(castDelay);
base.Sleeper.Sleep(castDelay + 0.5f);
base.OrbwalkSleeper.Sleep(castDelay);
return(true);
}
// Token: 0x060008C1 RID: 2241 RVA: 0x000275C8 File Offset: 0x000257C8
public override bool Use(Unit9 target, ComboModeMenu menu, params AbilityId[] except)
{
foreach (IGrouping <Unit9, OldBlinkAbility> grouping in from x in base.Abilities
where x.Ability.IsValid
group x by x.Ability.Owner)
{
Unit9 key = grouping.Key;
foreach (OldBlinkAbility oldBlinkAbility in grouping)
{
if (!except.Contains(oldBlinkAbility.Ability.Id) && oldBlinkAbility.CanBeCasted(menu))
{
Vector3 blinkPosition = this.GetBlinkPosition(key, target, menu);
if (!blinkPosition.IsZero && key.Distance(blinkPosition) <= oldBlinkAbility.Blink.Range)
{
if (oldBlinkAbility.Blink.PositionCast && oldBlinkAbility.Use(blinkPosition))
{
return(true);
}
if ((double)key.GetAngle(blinkPosition, false) < 0.2 && oldBlinkAbility.Use(key))
{
return(true);
}
}
}
}
}
return(false);
}
// Token: 0x060003CC RID: 972 RVA: 0x0001554C File Offset: 0x0001374C
public override bool CanBeCasted(TargetManager targetManager, bool channelingCheck, IComboModeMenu comboMenu)
{
if (!base.CanBeCasted(targetManager, channelingCheck, comboMenu))
{
return(false);
}
if (comboMenu.GetAbilitySettingsMenu <TricksOfTheTradeMenu>(this).SmartUsage)
{
Unit9 target = targetManager.Target;
if (base.Owner.HealthPercentage < 25f)
{
return(true);
}
if (target.GetImmobilityDuration() > 1.5f)
{
return(true);
}
if (!target.IsRanged && target.Distance(base.Owner) < 200f && target.HealthPercentage < 40f)
{
return(true);
}
int damage = base.Ability.GetDamage(target);
if (Math.Floor((double)(base.Ability.Radius / target.Speed / this.tricks.AttackRate)) * (double)damage * 0.89999997615814209 < (double)target.Health)
{
return(false);
}
}
return(true);
}
private void OnUnitHealthChange(Unit9 unit, float health)
{
try
{
if (!unit.IsHero || unit.IsIllusion || unit.Team == this.ownerTeam)
{
return;
}
if (this.sleeper.IsSleeping(unit.Handle) || unit.Distance(Hud.CameraPosition) < 900)
{
return;
}
var hpPct = (health / unit.MaximumHealth) * 100;
if (hpPct > this.hpThreshold)
{
return;
}
this.notificator.PushNotification(new HealthNotification(unit, this.moveCamera));
this.sleeper.Sleep(unit.Handle, 20);
}
catch (Exception e)
{
Logger.Error(e);
}
}
// Token: 0x060008C5 RID: 2245 RVA: 0x000278CC File Offset: 0x00025ACC
private Vector3 GetBlinkPosition(Unit9 owner, Unit9 target, ComboModeMenu menu)
{
if (this.Disables.CanBeCasted(this.forceBlinkAbilities, menu, target))
{
if (target.IsMoving)
{
return(target.Position);
}
return(Vector3Extensions.Extend2D(target.Position, owner.Position, 25f));
}
else
{
if (this.Disables.CanBeCasted(new HashSet <AbilityId>
{
AbilityId.item_cyclone
}, menu, target) && this.Specials.CanBeCasted(new HashSet <AbilityId>
{
AbilityId.item_cyclone
}, menu, target))
{
return(Vector3Extensions.Extend2D(target.Position, owner.Position, 25f));
}
Vector3 result = owner.IsRanged ? Vector3Extensions.Extend2D(target.Position, owner.Position, owner.GetAttackRange(null, 0f) * 0.75f) : target.InFront(25f, 0f, true);
if (owner.Distance(target) < owner.GetAttackRange(target, 100f))
{
return(Vector3.Zero);
}
return(result);
}
}
private float GetRequiredTime(Unit9 ally, Vector3 movePosition, float remainingTime, out DodgeAbility speedBuffAbility)
{
var turnTime = ally.GetTurnTime(movePosition);
var distance = ally.Distance(movePosition);
var speed = ally.Speed;
var requiredTime = turnTime + (distance / speed);
if (remainingTime > requiredTime)
{
speedBuffAbility = null;
return(requiredTime);
}
speedBuffAbility = this.dodgeAbilities.Where(x => x.CanBeCasted(ally, null, null))
.OrderByDescending(x => x.SpeedBuffAbility.GetSpeedBuff(ally))
.FirstOrDefault();
if (speedBuffAbility == null)
{
return(requiredTime);
}
return(turnTime + (distance / (speed + speedBuffAbility.SpeedBuffAbility.GetSpeedBuff(ally))));
}
// Token: 0x06000445 RID: 1093 RVA: 0x00017400 File Offset: 0x00015600
public override bool CanHit(TargetManager targetManager, IComboModeMenu comboMenu)
{
Unit9 target = targetManager.Target;
PredictionInput9 predictionInput = base.Ability.GetPredictionInput(target, null);
if (base.Ability.GetPredictionOutput(predictionInput).HitChance <= 0)
{
return(false);
}
if (target.Distance(base.Owner) < 300f || target.GetImmobilityDuration() > 0f)
{
return(true);
}
if (!target.Equals(this.lastTarget))
{
this.lastTarget = target;
this.rotationTime = Game.RawGameTime;
this.rotation = target.BaseUnit.NetworkRotationRad;
return(false);
}
if ((double)Math.Abs(this.rotation - target.BaseUnit.NetworkRotationRad) > 0.1)
{
this.rotationTime = Game.RawGameTime;
this.rotation = target.BaseUnit.NetworkRotationRad;
return(false);
}
MeatHookMenu abilitySettingsMenu = comboMenu.GetAbilitySettingsMenu <MeatHookMenu>(this);
return(this.rotationTime + abilitySettingsMenu.Delay / 1000f <= Game.RawGameTime);
}
// Token: 0x060005ED RID: 1517 RVA: 0x0001D97C File Offset: 0x0001BB7C
public override bool Orbwalk(Unit9 target, bool attack, bool move, ComboModeMenu comboMenu = null)
{
if (comboMenu != null && target != null && comboMenu.IsHarassCombo)
{
ActiveAbility ability = this.tidebringer.Ability;
if (ability.CanBeCasted(true))
{
Vector3 ownerPosition = base.Owner.Position;
float num = base.Owner.GetAttackPoint(null) + Game.Ping / 1000f + 0.3f;
Vector3 targetPredictedPosition = target.GetPredictedPosition(num);
Unit9 unit = (from x in EntityManager9.Units
where x.IsUnit && !x.Equals(target) && x.IsAlive && x.IsVisible && !x.IsInvulnerable && !x.IsAlly(this.Owner) && x.Distance(target) < ability.Range
orderby Vector3Extensions.AngleBetween(ownerPosition, x.Position, targetPredictedPosition)
select x).FirstOrDefault <Unit9>();
if (unit != null)
{
Vector3 position = unit.Position;
if (this.CanAttack(unit, 0f) && Vector3Extensions.AngleBetween(ownerPosition, position, targetPredictedPosition) < 45f)
{
base.LastMovePosition = Vector3.Zero;
base.LastTarget = unit;
base.OrbwalkSleeper.Sleep(0.05f);
return(this.Attack(unit, comboMenu));
}
float num2 = Math.Min(Math.Max(unit.Distance(ownerPosition), 150f), base.Owner.GetAttackRange(null, 0f));
Vector3 movePosition = Vector3Extensions.Extend2D(position, targetPredictedPosition, -num2);
base.OrbwalkSleeper.Sleep(0.05f);
return(base.Move(movePosition));
}
}
}
return(base.Orbwalk(target, attack, move, comboMenu));
}
// Token: 0x060004B6 RID: 1206 RVA: 0x00018CB0 File Offset: 0x00016EB0
public override bool UseAbility(TargetManager targetManager, Sleeper comboSleeper, Vector3 toPosition)
{
if (base.Owner.Distance(toPosition) < 300f)
{
return(false);
}
Vector3 vector = Vector3Extensions.Extend2D(base.Owner.Position, toPosition, Math.Min(base.Ability.CastRange - 25f, base.Owner.Distance(toPosition)));
Unit9 target = targetManager.Target;
if (target != null && target.Distance(vector) < this.swashbuckle.Range)
{
if (!this.swashbuckle.UseAbility(vector, target.Position, false, false))
{
return(false);
}
}
else if (!this.swashbuckle.UseAbility(vector, vector, false, false))
{
return(false);
}
float castDelay = base.Ability.GetCastDelay(vector);
comboSleeper.Sleep(castDelay);
base.Sleeper.Sleep(castDelay + 0.5f);
base.OrbwalkSleeper.Sleep(castDelay);
return(true);
}
public override bool CanBeCasted(Unit9 ally, Unit9 enemy, IObstacle obstacle)
{
if (!base.CanBeCasted(ally, enemy, obstacle))
{
return(false);
}
switch (obstacle.EvadableAbility.Ability.Id)
{
case AbilityId.slark_pounce:
{
var center = this.Pounce?.GetControlPoint(3);
if (center == null)
{
return(false);
}
if (ally.Distance(center.Value) < 370)
{
return(false);
}
this.usePosition = ally.Position.Extend2D(center.Value, 20);
return(true);
}
case AbilityId.disruptor_kinetic_field:
{
var center = this.KineticField?.Owner.Position;
if (center == null)
{
return(false);
}
var distance = ally.Distance(center.Value);
if (distance < 325 || distance > 340 || ally.GetAngle(center.Value) < 2)
{
return(false);
}
this.usePosition = ally.Position.Extend2D(center.Value, 20);
return(true);
}
}
return(false);
}
private bool Check(Unit9 ally, Unit9 enemy, List <Unit9> enemies, bool ignoreStatusCheck)
{
if (this.settings.MaxCastRange > 0 && enemy.Distance(ally) > this.settings.MaxCastRange)
{
return(false);
}
if (!ignoreStatusCheck)
{
if (!this.settings.HexStack && enemy.IsHexed)
{
return(false);
}
if (!this.settings.SilenceStack && enemy.IsSilenced)
{
return(false);
}
if (!this.settings.DisarmStack && enemy.IsDisarmed)
{
return(false);
}
if (!this.settings.RootStack && enemy.IsRooted)
{
return(false);
}
if (!this.settings.StunStack && enemy.IsStunned)
{
return(false);
}
}
if (enemy.IsDarkPactProtected)
{
return(false);
}
if (this.Ability.UnitTargetCast && enemy.IsBlockingAbilities)
{
return(false);
}
if (this.settings.Delay > 0)
{
UpdateManager.BeginInvoke(this.settings.Delay, () => this.Ability.UseAbility(enemy, enemies, HitChance.Medium, this.settings.EnemiesCount));
}
else
{
this.Ability.UseAbility(enemy, enemies, HitChance.Medium, this.settings.EnemiesCount);
}
enemy.SetExpectedUnitState(
this.Disable.AppliesUnitState,
this.Ability.GetHitTime(enemy.Position) + (this.settings.Delay / 1000f) + 0.3f);
return(true);
}
// Token: 0x060003BA RID: 954 RVA: 0x00015170 File Offset: 0x00013370
protected override bool ForceMove(Unit9 target, bool attack)
{
Vector3 mousePosition = Game.MousePosition;
Vector3 vector = mousePosition;
if (target != null && attack)
{
Vector3 position = target.Position;
vector = target.InFront(100f, 180f, false);
if (base.Menu.OrbwalkingMode == "Move to target" || this.CanAttack(target, 400f))
{
vector = position;
}
if (base.Menu.DangerRange > 0)
{
int num = Math.Min((int)base.Owner.GetAttackRange(null, 0f), base.Menu.DangerRange);
float num2 = base.Owner.Distance(target);
if (base.Menu.DangerMoveToMouse)
{
if (num2 < (float)num)
{
vector = mousePosition;
}
}
else if (num2 < (float)num)
{
float num3 = (position - base.Owner.Position).AngleBetween(vector - position);
if (num3 < 90f)
{
if (num3 < 30f)
{
vector = Vector3Extensions.Extend2D(position, vector, (float)((num - 25) * -1));
}
else
{
Vector3 vector2 = (mousePosition - position).Rotated(MathUtil.DegreesToRadians(90f)).Normalized() * (float)(num - 25);
Vector3 vector3 = position + vector2;
Vector3 vector4 = position - vector2;
vector = ((base.Owner.Distance(vector3) < base.Owner.Distance(vector4)) ? vector3 : vector4);
}
}
else if (target.Distance(vector) < (float)num)
{
vector = Vector3Extensions.Extend2D(position, vector, (float)(num - 25));
}
}
}
}
if (vector == base.LastMovePosition)
{
return(false);
}
if (!base.Owner.BaseUnit.Move(vector))
{
return(false);
}
base.LastMovePosition = vector;
return(true);
}
public override bool IsIntersecting(Unit9 unit, bool checkPrediction)
{
if (this.Projectile != null)
{
return(unit.Distance(this.Target) < this.Radius + 50);
}
return(base.IsIntersecting(unit, checkPrediction));
}
// Token: 0x06000049 RID: 73 RVA: 0x0000F924 File Offset: 0x0000DB24
private void CheckCollision(PredictionInput9 input, PredictionOutput9 output)
{
if (input.CollisionTypes != CollisionTypes.None)
{
Unit9 caster = input.Caster;
float scanRange = caster.Distance(output.CastPosition);
List <Unit9> list = new List <Unit9>();
List <CollisionObject> list2 = new List <CollisionObject>();
List <Unit9> source = (from x in EntityManager9.Units
where x.IsUnit && !x.Equals(caster) && !x.Equals(input.Target) && x.IsAlive && x.IsVisible && x.Distance(caster) < scanRange
select x).ToList <Unit9>();
if ((input.CollisionTypes & CollisionTypes.AllyCreeps) == CollisionTypes.AllyCreeps)
{
list.AddRange(from x in source
where x.IsAlly(caster)
select x);
}
if ((input.CollisionTypes & CollisionTypes.EnemyCreeps) == CollisionTypes.EnemyCreeps)
{
list.AddRange(from x in source
where !x.IsAlly(caster)
select x);
}
if ((input.CollisionTypes & CollisionTypes.AllyHeroes) == CollisionTypes.AllyHeroes)
{
list.AddRange(from x in source
where x.IsHero && x.IsAlly(caster)
select x);
}
if ((input.CollisionTypes & CollisionTypes.EnemyHeroes) == CollisionTypes.EnemyHeroes)
{
list.AddRange(from x in source
where x.IsHero && !x.IsAlly(caster)
select x);
}
foreach (Unit9 unit in list)
{
PredictionInput9 input2 = new PredictionInput9
{
Target = unit,
Caster = input.Caster,
Delay = input.Delay,
Speed = input.Speed,
CastRange = input.CastRange,
Radius = input.Radius,
RequiresToTurn = input.RequiresToTurn
};
PredictionOutput9 simplePrediction = this.GetSimplePrediction(input2);
list2.Add(new CollisionObject(unit, simplePrediction.TargetPosition, unit.HullRadius + 10f));
}
if (Collision.GetCollision(caster.Position.ToVector2(), output.CastPosition.ToVector2(), input.Radius, list2).Collides)
{
output.HitChance = HitChance.Impossible;
}
}
}
public override bool Orbwalk(Unit9 target, bool attack, bool move, ComboModeMenu comboMenu = null)
{
if (this.OrbwalkSleeper.IsSleeping)
{
return(false);
}
if (target != null && comboMenu?.IsHarassCombo == true && target.Distance(this.Owner) > this.Owner.GetAttackRange(target))
{
if (this.MoveSleeper.IsSleeping)
{
return(false);
}
if (this.MoveToProjectile(target))
{
return(true);
}
var psi = (PsiBlades)this.Owner.Abilities.First(x => x.Id == AbilityId.templar_assassin_psi_blades);
var ownerPosition = this.Owner.Position;
var attackDelay = this.Owner.GetAttackPoint() + (GameManager.Ping / 1000) + 0.3f;
var targetPredictedPosition = target.GetPredictedPosition(attackDelay);
var unitTarget = EntityManager9.Units
.Where(
x => x.IsUnit && !x.Equals(target) && x.IsAlive && x.IsVisible && !x.IsInvulnerable &&
(!x.IsAlly(this.Owner) || (x.IsCreep && x.HealthPercentage < 50)) &&
x.Distance(target) < psi.SplitRange - 75)
.OrderBy(x => ownerPosition.AngleBetween(x.Position, targetPredictedPosition))
.FirstOrDefault();
if (unitTarget != null)
{
var unitTargetPosition = unitTarget.Position;
if (this.CanAttack(unitTarget) && ownerPosition.AngleBetween(unitTargetPosition, targetPredictedPosition) < 15)
{
this.LastMovePosition = Vector3.Zero;
this.LastTarget = unitTarget;
this.OrbwalkSleeper.Sleep(0.05f);
return(this.Attack(unitTarget, comboMenu));
}
var range = Math.Min(Math.Max(unitTarget.Distance(ownerPosition), 150), this.Owner.GetAttackRange());
var movePosition = unitTargetPosition.Extend2D(targetPredictedPosition, -range);
this.OrbwalkSleeper.Sleep(0.05f);
return(this.Move(movePosition));
}
attack = false;
}
return(base.Orbwalk(target, attack, move, comboMenu));
}
// Token: 0x060003E6 RID: 998 RVA: 0x00015B70 File Offset: 0x00013D70
public override bool ShouldCast(TargetManager targetManager)
{
if (!base.ShouldCast(targetManager))
{
return(false);
}
Unit9 target = targetManager.Target;
return(target.Distance(base.Owner) <= 400f || target.GetImmobilityDuration() >= 2f);
}
// Token: 0x06000161 RID: 353 RVA: 0x0000C820 File Offset: 0x0000AA20
public override bool ShouldCast(TargetManager targetManager)
{
if (!base.ShouldCast(targetManager))
{
return(false);
}
Unit9 target = targetManager.Target;
return(!target.IsEthereal && ((target.Distance(base.Owner) < 300f && target.HealthPercentage < 50f) || target.IsStunned || target.IsRooted || target.IsHexed));
}
// Token: 0x0600021C RID: 540 RVA: 0x00010E40 File Offset: 0x0000F040
public LanePosition GetCreepLane(Unit9 unit)
{
foreach (KeyValuePair <LanePosition, Vector3[]> keyValuePair in this.Lanes)
{
if (unit.Distance(keyValuePair.Value[0]) < 300f)
{
return(keyValuePair.Key);
}
}
return(LanePosition.Unknown);
}
public override float GetEvadeTime(Unit9 ally, bool blink)
{
if (this.Projectile == null)
{
var range = 100;
if (ally.IsMoving)
{
if (ally.GetAngle(this.Position) < 1)
{
range += 25;
}
else
{
range -= 25;
}
}
var distance = Math.Max(ally.Distance(this.Position) - ((Game.Ping / 1000) * this.Speed) - range, 0);
return((this.EndCastTime + (distance / this.Speed)) - Game.RawGameTime);
}
if (this.Projectile.IsValid)
{
var range = 50;
if (ally.IsMoving)
{
if (ally.GetAngle(this.Projectile.Position) < 1)
{
range += 25;
}
else
{
range -= 25;
}
}
return(Math.Max(ally.Distance(this.Projectile.Position) - ((Game.Ping / 1000) * this.Speed) - range, 0) / this.Speed);
}
return(0);
}
// Token: 0x06000D05 RID: 3333 RVA: 0x00026254 File Offset: 0x00024454
public override Damage GetRawDamage(Unit9 unit, float?remainingHealth = null)
{
float num = Math.Max(unit.Distance(base.Owner) - 100f, 0f);
float value = this.maxDamageData.GetValue(this.Level);
float value2 = this.minDamageData.GetValue(this.Level);
float value3 = Math.Max(Math.Min(num / this.Radius * value, value), value2);
Damage damage = new Damage();
DamageType damageType = this.DamageType;
damage[damageType] = value3;
return(damage);
}
public LanePosition GetCreepLane(Unit9 unit)
{
foreach (var lane in this.Lanes)
{
if (unit.Distance(lane.Value[0]) < 500)
{
return(lane.Key);
}
}
return(LanePosition.Unknown);
}
// Token: 0x060003CB RID: 971 RVA: 0x000154C8 File Offset: 0x000136C8
public bool CancelChanneling(TargetManager targetManager)
{
if (base.Owner.HasAghanimsScepter)
{
return(false);
}
if (!base.Ability.IsChanneling || !base.Ability.BaseAbility.IsChanneling)
{
return(false);
}
Unit9 target = targetManager.Target;
return(!target.IsStunned && !target.IsRooted && target.Distance(base.Owner) >= base.Ability.Radius && base.Owner.BaseUnit.Stop());
}
public override Damage GetRawDamage(Unit9 unit, float?remainingHealth = null)
{
var distance = Math.Max(unit.Distance(this.Owner) - 100, 0);
var max = this.maxDamageData.GetValue(this.Level);
var min = this.minDamageData.GetValue(this.Level);
var damage = Math.Max(Math.Min((distance / this.Radius) * max, max), min);
return(new Damage
{
[this.DamageType] = damage
});
}
// Token: 0x06000435 RID: 1077 RVA: 0x00017230 File Offset: 0x00015430
private void OnAttackStart(Unit9 unit)
{
try
{
if (unit.Team != base.Owner.Team && unit.Distance(base.Owner) <= 2000f)
{
this.attacks[unit] = Game.RawGameTime - Game.Ping / 2000f;
}
}
catch (Exception ex)
{
Logger.Error(ex, null);
}
}
