// 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); } }