// 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);
}
}
public override bool Orbwalk(Unit9 target, bool attack, bool move, ComboModeMenu comboMenu = null)
{
if (this.razeOrbwalk && this.abilityHelper != null && target != null && this.Owner.Speed >= 305 &&
(target.IsRanged || target.GetImmobilityDuration() > 1))
{
var distance = this.Owner.Distance(target);
foreach (var raze in this.razes.OrderBy(x => Math.Abs(x.Ability.CastRange - distance)))
{
if (!this.abilityHelper.CanBeCasted(raze, false))
{
continue;
}
var position = target.Position.Extend2D(this.Owner.Position, raze.Ability.CastRange - (raze.Ability.Radius - 100));
var distance2 = this.Owner.Distance(position);
if (target.GetAttackRange(this.Owner) >= distance2 || target.GetImmobilityDuration() > 1)
{
if (distance2 > 50)
{
return(this.Move(position));
}
}
}
}
return(base.Orbwalk(target, attack, move, comboMenu));
}
private Vector3 GetBlinkPosition(Unit9 owner, Unit9 target, ComboModeMenu menu)
{
if (this.Disables.CanBeCasted(this.forceBlinkAbilities, menu, target))
{
if (target.IsMoving)
{
return(target.Position);
}
else
{
return(target.Position.Extend2D(owner.Position, 25));
}
}
if (this.Disables.CanBeCasted(
new HashSet <AbilityId>
{
AbilityId.item_cyclone
},
menu,
target) && this.Specials.CanBeCasted(
new HashSet <AbilityId>
{
AbilityId.item_cyclone
},
menu,
target))
{
return(target.Position.Extend2D(owner.Position, 25));
}
var position = owner.IsRanged ? target.Position.Extend2D(owner.Position, owner.GetAttackRange() * 0.75f) : target.InFront(25);
if (owner.Distance(target) < owner.GetAttackRange(target, 100))
{
return(Vector3.Zero);
}
return(position);
}
public override bool ShouldCast(Unit9 target)
{
if (target.IsLinkensProtected || target.IsSpellShieldProtected)
{
return(false);
}
if (this.Ability.Owner.Distance(target) < target.GetAttackRange() + 100)
{
return(true);
}
return(false);
}
protected virtual bool ShouldCastShield(Unit9 target, BlinkAbilityGroup blinks, ComboModeMenu menu)
{
var distance = this.Ability.Owner.Distance(target);
var attackRange = this.Ability.Owner.GetAttackRange(target);
if (blinks.GetBlinkAbilities(this.Ability.Owner, menu).Any(x => x.Blink.Range > distance - attackRange))
{
return(true);
}
if (distance > target.GetAttackRange(this.Owner, 125))
{
return(false);
}
return(true);
}
// Token: 0x060003B4 RID: 948 RVA: 0x0001CEDC File Offset: 0x0001B0DC
private void AttackStarted(Unit9 unit)
{
if (this.attackSleeper.IsSleeping(unit.Handle) || !unit.IsAlive)
{
return;
}
if (!unit.IsControllable && unit.IsHero)
{
unit.Target = (from x in EntityManager9.Units
where x.IsAlive && !x.IsAlly(unit) && x.Distance(unit) <= unit.GetAttackRange(x, 25f)
orderby unit.GetAngle(x.Position, false)
select x).FirstOrDefault((Unit9 x) => unit.GetAngle(x.Position, false) < 0.35f);
}
unit.IsAttacking = true;
this.attackSleeper.Sleep(unit.Handle, unit.GetAttackPoint(null));
UnitMonitor.EventHandler attackStart = this.AttackStart;
if (attackStart == null)
{
return;
}
attackStart(unit);
}
// Token: 0x0600087D RID: 2173 RVA: 0x000267C8 File Offset: 0x000249C8
protected virtual bool ShouldCastShield(Unit9 target, BlinkAbilityGroup blinks, ComboModeMenu menu)
{
float distance = base.Ability.Owner.Distance(target);
float attackRange = base.Ability.Owner.GetAttackRange(target, 0f);
return(blinks.GetBlinkAbilities(base.Ability.Owner, menu).Any((OldBlinkAbility x) => x.Blink.Range > distance - attackRange) || distance <= target.GetAttackRange(base.Owner, 125f));
}
private bool UseCircle(OldDisableAbility ability, Unit9 owner, Unit9 target, List <OldBlinkAbility> blinkAbilities, float range)
{
if (ability.Disable is CircleAbility circle)
{
var input = circle.GetPredictionInput(target, EntityManager9.EnemyHeroes);
input.CastRange += range;
var output = circle.GetPredictionOutput(input);
if (output.HitChance < HitChance.Low)
{
return(false);
}
var blinkPosition = owner.IsRanged
? owner.Position.Extend2D(
output.CastPosition,
Math.Min(range, owner.Position.Distance2D(output.CastPosition) - (owner.GetAttackRange() / 2)))
: output.CastPosition;
if (this.Blinks.Use(owner, blinkAbilities, blinkPosition, target))
{
// UpdateManager.BeginInvoke(() => circle.UseAbility(output.CastPosition), 50);
// ability.SetTimings(target);
return(true);
}
}
return(false);
}
public override void AddModifier(Modifier modifier, Unit9 modifierOwner)
{
var obstacle = new ModifierEnemyObstacle(this, modifier, modifierOwner, modifierOwner.GetAttackRange() + 100);
this.Pathfinder.AddObstacle(obstacle);
}
private void AttackStarted(Unit9 unit)
{
if (this.attackSleeper.IsSleeping(unit.Handle) || !unit.IsAlive)
{
return;
}
if (!unit.IsControllable && unit.IsHero)
{
unit.Target = EntityManager9.Units
.Where(x => x.IsAlive && !x.IsAlly(unit) && x.Distance(unit) <= unit.GetAttackRange(x, 25))
.OrderBy(x => unit.GetAngle(x.Position))
.FirstOrDefault(x => unit.GetAngle(x.Position) < 0.35f);
}
unit.IsAttacking = true;
this.attackSleeper.Sleep(unit.Handle, unit.GetAttackPoint());
this.AttackStart?.Invoke(unit);
}
// Token: 0x060008F8 RID: 2296 RVA: 0x00028588 File Offset: 0x00026788
private bool UseCircle(OldDisableAbility ability, Unit9 owner, Unit9 target, List <OldBlinkAbility> blinkAbilities, float range)
{
CircleAbility circleAbility;
if ((circleAbility = (ability.Disable as CircleAbility)) != null)
{
PredictionInput9 predictionInput = circleAbility.GetPredictionInput(target, EntityManager9.EnemyHeroes);
predictionInput.CastRange += range;
PredictionOutput9 predictionOutput = circleAbility.GetPredictionOutput(predictionInput);
if (predictionOutput.HitChance < 1)
{
return(false);
}
Vector3 position = owner.IsRanged ? Vector3Extensions.Extend2D(owner.Position, predictionOutput.CastPosition, Math.Min(range, owner.Position.Distance2D(predictionOutput.CastPosition, false) - owner.GetAttackRange(null, 0f) / 2f)) : predictionOutput.CastPosition;
if (this.Blinks.Use(owner, blinkAbilities, position, target))
{
return(true);
}
}
return(false);
}
// Token: 0x06000873 RID: 2163 RVA: 0x00006386 File Offset: 0x00004586
public override bool ShouldCast(Unit9 target)
{
return(!target.IsLinkensProtected && !target.IsSpellShieldProtected && base.Ability.Owner.Distance(target) < target.GetAttackRange(null, 0f) + 100f);
}
// Token: 0x06000245 RID: 581 RVA: 0x0000FCEC File Offset: 0x0000DEEC
public void Toss()
{
ActiveAbility tossAbility = base.Owner.Abilities.FirstOrDefault((Ability9 x) => x.Id == AbilityId.tiny_toss) as ActiveAbility;
ActiveAbility tossAbility2 = tossAbility;
if (tossAbility2 == null || !tossAbility2.CanBeCasted(true))
{
return;
}
Unit9 tower = (from x in EntityManager9.Units
where x.IsTower && x.IsAlly(this.Owner) && x.IsAlive
orderby x.Distance(this.Owner)
select x).FirstOrDefault((Unit9 x) => x.Distance(this.Owner) < 2000f);
if (tower == null)
{
return;
}
Unit9 unit = (from x in EntityManager9.Units
where x.IsUnit && !x.IsInvulnerable && !x.IsMagicImmune && x.IsAlive && x.IsVisible && x.Distance(this.Owner) < tossAbility.CastRange && x.Distance(tower) < tower.GetAttackRange(null, 0f)
orderby x.Distance(tower)
select x).FirstOrDefault <Unit9>();
if (unit == null)
{
return;
}
Unit9 unit2 = (from x in EntityManager9.Units
where x.IsUnit && !x.Equals(this.Owner) && !x.IsInvulnerable && !x.IsMagicImmune && x.IsAlive && x.IsVisible && x.Distance(this.Owner) < tossAbility.Radius
orderby x.Distance(this.Owner)
select x).FirstOrDefault <Unit9>();
if (unit2 == null || !unit2.IsHero || unit2.IsIllusion || unit2.IsAlly(base.Owner))
{
return;
}
tossAbility.UseAbility(unit, false, false);
}
