// Token: 0x0600070D RID: 1805 RVA: 0x00021360 File Offset: 0x0001F560
public bool?BodyBlock(TargetManager targetManager, Vector3 blockPosition, ComboModeMenu menu)
{
if (!this.Owner.CanMove(true) || this.MoveSleeper.IsSleeping)
{
return(new bool?(false));
}
Unit9 target = targetManager.Target;
float angle = target.GetAngle(this.Owner.Position, false);
if ((double)angle > 1.2)
{
if (this.Owner.Speed <= target.Speed + 35f)
{
return(null);
}
float num = angle * 0.6f;
Vector3 vector = target.InFront((float)this.BodyBlockRange, MathUtil.RadiansToDegrees(num), true);
Vector3 vector2 = target.InFront((float)this.BodyBlockRange, MathUtil.RadiansToDegrees(-num), true);
if (this.Move((this.Owner.Distance(vector) < this.Owner.Distance(vector2)) ? vector : vector2))
{
this.MoveSleeper.Sleep(0.1f);
return(new bool?(true));
}
return(new bool?(false));
}
else if ((double)angle < 0.36)
{
if (!target.IsMoving && this.CanAttack(target, 400f))
{
return(new bool?(this.Attack(target, menu)));
}
if (this.Owner.IsMoving && !this.AttackSleeper.IsSleeping)
{
this.MoveSleeper.Sleep(0.2f);
return(new bool?(this.Owner.BaseUnit.Stop()));
}
return(new bool?(false));
}
else
{
if (this.Move(Vector3Extensions.Extend2D(target.Position, blockPosition, (float)this.BodyBlockRange)))
{
this.MoveSleeper.Sleep(0.1f);
return(new bool?(true));
}
return(new bool?(false));
}
}
// 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);
}
// Token: 0x06000742 RID: 1858 RVA: 0x00005AF5 File Offset: 0x00003CF5
public override bool Orbwalk(Unit9 target, bool attack, bool move, ComboModeMenu comboMenu = null)
{
if (target != null && base.Owner.HasModifier("modifier_juggernaut_blade_fury"))
{
return(base.Move(target.InFront(100f, 0f, true)));
}
return(base.Orbwalk(target, attack, move, comboMenu));
}
// Token: 0x06000322 RID: 802 RVA: 0x0001BBC4 File Offset: 0x00019DC4
public override void AddDrawableAbility(List <IDrawableAbility> drawableAbilities, ParticleEffect particle, Team allyTeam, INotificator notificator)
{
Unit9 unit;
if (!base.SearchOwner && particle.Owner is Unit)
{
unit = EntityManager9.GetUnit(particle.Owner.Handle);
}
else
{
Ability9 ability = EntityManager9.Abilities.FirstOrDefault((Ability9 x) => x.Id == this.AbilityId && x.Owner.Team != allyTeam);
unit = ((ability != null) ? ability.Owner : null);
}
Unit9 unit2 = unit;
if (unit2 == null || unit2.IsVisible)
{
return;
}
if (Game.RawGameTime - unit2.LastVisibleTime >= 1f)
{
DrawableAbility item = new DrawableAbility
{
AbilityTexture = base.AbilityId + "_rounded",
HeroTexture = unit2.Name + "_rounded",
MinimapHeroTexture = unit2.Name + "_icon",
ShowUntil = Game.RawGameTime + base.TimeToShow,
Position = particle.GetControlPoint(base.ControlPoint)
};
drawableAbilities.Add(item);
return;
}
Ability9 ability2 = unit2.Abilities.FirstOrDefault((Ability9 x) => x.Id == this.AbilityId);
if (ability2 == null)
{
return;
}
DrawableAbility item2 = new DrawableAbility
{
AbilityTexture = base.AbilityId + "_rounded",
HeroTexture = unit2.Name + "_rounded",
MinimapHeroTexture = unit2.Name + "_icon",
ShowUntil = Game.RawGameTime + base.TimeToShow,
Position = unit2.InFront(ability2.Range, 0f, true)
};
drawableAbilities.Add(item2);
}
public virtual bool IsIntersecting(Unit9 unit, bool checkPrediction)
{
if (this.Polygon == null)
{
return(false);
}
if (!this.Polygon.IsOutside(unit.Position.To2D()))
{
return(true);
}
if (!checkPrediction || this.NavMeshId == null || (!unit.IsMoving && !unit.IsRotating))
{
return(false);
}
return(!this.Polygon.IsOutside(unit.InFront(100).To2D()));
}
// Token: 0x06000378 RID: 888 RVA: 0x00013CB8 File Offset: 0x00011EB8
public override bool UseAbility(TargetManager targetManager, Sleeper comboSleeper, bool aoe)
{
Unit9 target = targetManager.Target;
if (base.Owner.HasAghanimsScepter && (target.GetImmobilityDuration() > 0f || !target.IsMoving) && !targetManager.EnemyHeroes.Any((Unit9 x) => !x.Equals(target) && x.Distance(target) < 900f))
{
Vector3 vector = target.InFront(base.Ability.Radius + (float)(target.IsMoving ? 30 : 10), 0f, true);
if (base.Owner.Distance(vector) > base.Ability.CastRange)
{
return(false);
}
if (!base.Ability.UseAbility(vector, false, false))
{
return(false);
}
}
else
{
PredictionInput9 predictionInput = base.Ability.GetPredictionInput(target, null);
predictionInput.Delay += 0.3f;
PredictionOutput9 predictionOutput = base.Ability.GetPredictionOutput(predictionInput);
if (predictionOutput.HitChance < 1)
{
return(false);
}
if (!base.Ability.UseAbility(predictionOutput.CastPosition, false, false))
{
return(false);
}
}
float castDelay = base.Ability.GetCastDelay(targetManager.Target);
comboSleeper.Sleep(castDelay);
base.Sleeper.Sleep(castDelay + 0.5f);
base.OrbwalkSleeper.Sleep(castDelay);
return(true);
}
protected override bool ForceMove(Unit9 target, bool attack)
{
var mousePosition = GameManager.MousePosition;
var movePosition = mousePosition;
if (target != null && attack)
{
var targetPosition = target.Position;
movePosition = target.InFront(100, 180, false);
if (this.Menu.OrbwalkingMode == "Move to target" || this.CanAttack(target, 400))
{
movePosition = targetPosition;
}
if (this.Menu.DangerRange > 0)
{
var dangerRange = Math.Min((int)this.Owner.GetAttackRange(), this.Menu.DangerRange);
var targetDistance = this.Owner.Distance(target);
if (this.Menu.DangerMoveToMouse)
{
if (targetDistance < dangerRange)
{
movePosition = mousePosition;
}
}
else
{
if (targetDistance < dangerRange)
{
var angle = (targetPosition - this.Owner.Position).AngleBetween(movePosition - targetPosition);
if (angle < 90)
{
if (angle < 30)
{
movePosition = targetPosition.Extend2D(movePosition, (dangerRange - 25) * -1);
}
else
{
var difference = mousePosition - targetPosition;
var rotation = difference.Rotated(MathUtil.DegreesToRadians(90));
var end = rotation.Normalized() * (dangerRange - 25);
var right = targetPosition + end;
var left = targetPosition - end;
movePosition = this.Owner.Distance(right) < this.Owner.Distance(left) ? right : left;
}
}
else if (target.Distance(movePosition) < dangerRange)
{
movePosition = targetPosition.Extend2D(movePosition, dangerRange - 25);
}
}
}
}
}
if (movePosition == this.LastMovePosition)
{
return(false);
}
if (!this.Owner.BaseUnit.Move(movePosition))
{
return(false);
}
this.LastMovePosition = movePosition;
return(true);
}
public override float GetRequiredTime(Unit9 ally, Unit9 enemy, IObstacle obstacle)
{
var additionalTime = 0f;
this.position = Vector3.Zero;
switch (obstacle.EvadableAbility)
{
case HomingMissileEvadable _:
{
var missilePosition = ((HomingMissileObstacle)obstacle).Position;
this.position = ally.Position.Extend2D(missilePosition, 199);
additionalTime += ally.GetTurnTime(this.position);
break;
}
case PhantomsEmbraceEvadable _:
{
var casterPosition = obstacle.Caster.Position;
var range = 225 + (50 * this.Ability.Level);
this.position = ally.Position.Extend2D(casterPosition, range);
additionalTime += ally.GetTurnTime(this.position) + 0.07f;
break;
}
case ChargeOfDarknessEvadable _:
{
var spiritBreakerPosition = obstacle.Caster.Position;
var range = 175 + (50 * this.Ability.Level);
this.position = ally.Position.Extend2D(spiritBreakerPosition, range);
additionalTime += ally.GetTurnTime(this.position) + 0.3f;
break;
}
case TargetableProjectileEvadable projectile:
{
if (!projectile.IsDisjointable)
{
this.position = ally.Position.Extend2D(enemy.Position, 199);
additionalTime += ally.GetTurnTime(this.position);
}
if (obstacle.EvadableAbility.Ability.Id == AbilityId.sven_storm_bolt)
{
this.position = ally.InFront(300);
}
additionalTime += 0.05f;
break;
}
case LinearProjectileEvadable _:
case ConeProjectileEvadable _:
case AreaOfEffectEvadable _ when obstacle.EvadableAbility.Ability.Id == AbilityId.venomancer_poison_nova:
{
var path = this.pathfinder.GetPathFromObstacle(ally, ally.Speed, ally.Position, 69, out var success);
if (!success)
{
return(69);
}
this.position = path.Last();
additionalTime += ally.GetTurnTime(this.position) + 0.05f;
break;
}
case AreaOfEffectEvadable _:
{
//todo more aoe spells with speed
var pathAoe = this.pathfinder.GetPathFromObstacle(ally, ally.Speed, ally.Position, 69, out var success);
if (!success)
{
return(69);
}
var safePosition = pathAoe.Last().Extend2D(this.Owner.Position, -50);
switch (obstacle.EvadableAbility.Ability.Id)
{
case AbilityId.nevermore_requiem:
{
if (ally.Distance(enemy.Position) < 600)
{
this.position = safePosition;
}
else
{
var jumpPosition = ally.Position.Extend2D(enemy.Position, 600);
this.position = this.Owner.Distance(jumpPosition) > this.Owner.Distance(safePosition)
? safePosition
: jumpPosition;
}
additionalTime += ally.GetTurnTime(this.position) + 0.15f;
break;
}
case AbilityId.tidehunter_ravage:
{
if (ally.Distance(enemy.Position) < 600)
{
this.position = safePosition;
}
else
{
var jumpPosition = ally.Position.Extend2D(enemy.Position, 600);
this.position = this.Owner.Distance(jumpPosition) > this.Owner.Distance(safePosition)
? safePosition
: jumpPosition;
}
additionalTime += ally.GetTurnTime(this.position) + 0.1f;
break;
}
}
break;
}
}
if (this.position.IsZero)
{
this.position = ally.InFront(ally.IsMoving ? 190 : 90);
}
return(this.ActiveAbility.GetHitTime(ally) + additionalTime);
}
public override bool Use(Unit9 ally, Unit9 enemy, IObstacle obstacle)
{
this.MoveCamera(ally.Position);
return(this.ActiveAbility.UseAbility(ally.InFront(100), false, true));
}
// 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 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);
}
// Token: 0x06000755 RID: 1877 RVA: 0x0002243C File Offset: 0x0002063C
protected override void Execute()
{
if (this.sleeper.IsSleeping)
{
return;
}
Unit9 unit = this.ward;
if (unit == null || !unit.IsValid || !this.ward.IsAlive)
{
return;
}
Vector3 fountain = base.TargetManager.Fountain;
Unit9 owner = this.ward.Owner;
HealingWard healingWard = (HealingWard)owner.Abilities.First((Ability9 x) => x.Id == AbilityId.juggernaut_healing_ward);
List <Unit9> list = (from x in base.TargetManager.AllyHeroes
where x.HealthPercentage < 90f || x.IsMyHero
orderby x.HealthPercentage
select x).ToList <Unit9>();
Unit9 unit2 = (owner.HealthPercentage < 80f && owner.IsAlive) ? owner : list.FirstOrDefault <Unit9>();
if (unit2 == null || !unit2.IsAlive)
{
return;
}
PredictionInput9 predictionInput = healingWard.GetPredictionInput(unit2, list);
predictionInput.CastRange = 2000f;
PredictionOutput9 predictionOutput = healingWard.GetPredictionOutput(predictionInput);
if (predictionOutput.HitChance < 1)
{
return;
}
Vector3 vector = predictionOutput.CastPosition;
if (predictionOutput.AoeTargetsHit.Count == 1)
{
vector = predictionOutput.TargetPosition;
}
if (!unit2.Equals(owner) || owner.HealthPercentage > 50f)
{
foreach (Unit9 unit3 in from x in base.TargetManager.EnemyHeroes
orderby x.GetAttackRange(null, 0f) descending
select x)
{
float num = unit3.GetAttackRange(null, 0f) * (unit3.IsRanged ? 2f : 3f);
if (unit3.Distance(vector) <= num)
{
vector = unit2.InFront(5f, 0f, false);
break;
}
}
}
if (this.ward.Position == vector)
{
return;
}
this.ward.BaseUnit.Move(vector);
this.sleeper.Sleep(0.15f);
}
// Token: 0x0600031A RID: 794 RVA: 0x0001B924 File Offset: 0x00019B24
public override void AddDrawableAbility(List <IDrawableAbility> drawableAbilities, ParticleEffect particle, Team allyTeam, INotificator notificator)
{
Vector3 position = particle.GetControlPoint(base.ControlPoint);
List <Ability9> list = (from x in EntityManager9.Abilities
where x.Id == this.AbilityId && x.Owner.CanUseAbilities && x.Owner.IsAlive
select x).ToList <Ability9>();
if (list.Count == 0 || list.All((Ability9 x) => x.Owner.Team == allyTeam))
{
return;
}
if (list.Any((Ability9 x) => x.Owner.IsVisible && x.Owner.Distance(position) < 1500f && x.TimeSinceCasted < 0.5f))
{
return;
}
List <Ability9> list2 = (from x in list
where x.Owner.Team != allyTeam && !x.Owner.IsVisible && x.RemainingCooldown <= 0f
select x).ToList <Ability9>();
if (list2.Count == 0)
{
return;
}
if (list2.Count == 1)
{
Unit9 owner = list2[0].Owner;
DrawableAbility item = new DrawableAbility
{
AbilityTexture = base.AbilityId + "_rounded",
HeroTexture = owner.Name + "_rounded",
MinimapHeroTexture = owner.Name + "_icon",
ShowUntil = Game.RawGameTime + base.TimeToShow,
Position = ((Game.RawGameTime - owner.LastVisibleTime < 0.5f) ? owner.InFront(list2[0].Range - 200f, 0f, true) : position.SetZ(new float?((float)350)))
};
drawableAbilities.Add(item);
return;
}
Ability9 ability = list2.Find((Ability9 x) => x.Owner.Distance(position) < 100f && Game.RawGameTime - x.Owner.LastVisibleTime < 0.5f);
Unit9 unit = (ability != null) ? ability.Owner : null;
if (unit != null)
{
DrawableAbility item2 = new DrawableAbility
{
AbilityTexture = base.AbilityId + "_rounded",
HeroTexture = unit.Name + "_rounded",
MinimapHeroTexture = unit.Name + "_icon",
ShowUntil = Game.RawGameTime + base.TimeToShow,
Position = unit.InFront(list2[0].Range - 200f, 0f, true)
};
drawableAbilities.Add(item2);
return;
}
SimpleDrawableAbility item3 = new SimpleDrawableAbility
{
AbilityTexture = base.AbilityId + "_rounded",
ShowUntil = Game.RawGameTime + base.TimeToShow,
Position = (base.RawParticlePosition ? particle.Position : particle.GetControlPoint(base.ControlPoint)).SetZ(new float?((float)350))
};
drawableAbilities.Add(item3);
}
public override EvadeResult Evade(Unit9 ally, IObstacle obstacle)
{
var result = new EvadeResult
{
Ally = ally.DisplayName,
EnemyAbility = obstacle.EvadableAbility.Ability.DisplayName,
IsModifier = obstacle.IsModifierObstacle,
Mode = EvadeMode.Dodge,
ObstacleId = obstacle.Id
};
if (!obstacle.CanBeDodged || ally.IsCourier)
{
result.State = EvadeResult.EvadeState.Ignore;
return(result);
}
if (this.pathfinderMode == Pathfinder.EvadeMode.None)
{
result.State = EvadeResult.EvadeState.Ignore;
return(result);
}
if ((this.pathfinderMode == Pathfinder.EvadeMode.Disables || ally.IsCharging) && !obstacle.EvadableAbility.Ability.IsDisable())
{
result.State = EvadeResult.EvadeState.Ignore;
return(result);
}
if (!ally.CanUseAbilities)
{
result.State = EvadeResult.EvadeState.Ignore;
return(result);
}
if (ally.IsInvulnerable || (!obstacle.EvadableAbility.Ability.CanHitSpellImmuneEnemy && ally.IsMagicImmune))
{
result.State = EvadeResult.EvadeState.Successful;
return(result);
}
if (!ally.CanMove(false))
{
result.State = EvadeResult.EvadeState.Failed;
return(result);
}
if (!ally.IsControllable || this.ActionManager.IsInputBlocked(ally))
{
result.State = EvadeResult.EvadeState.Failed;
return(result);
}
var remainingTime = obstacle.GetEvadeTime(ally, true) - (Game.Ping / 2000f);
if (remainingTime <= 0)
{
result.State = EvadeResult.EvadeState.Failed;
return(result);
}
var movingIntoObstacle = !obstacle.IsIntersecting(ally, false);
var path = movingIntoObstacle
? this.pathfinder.GetPathFromObstacle(ally, ally.Speed, ally.InFront(100), 69, out var success)
: this.pathfinder.GetPathFromObstacle(ally, ally.Speed, ally.Position, 69, out success);
if (!success)
{
result.State = EvadeResult.EvadeState.Failed;
return(result);
}
var ignoreTime = obstacle.EvadableAbility.IgnoreRemainingTime(obstacle, null);
var movePosition = path.Last();
var requiredTime = this.GetRequiredTime(ally, movePosition, remainingTime, out var speedBuffAbility) - 0.15f;
if (obstacle is AreaOfEffectObstacle)
{
remainingTime -= 0.15f;
}
if (!ignoreTime)
{
if (requiredTime > remainingTime)
{
result.State = EvadeResult.EvadeState.Failed;
return(result);
}
if (requiredTime + 0.15 < remainingTime)
{
if (EvadeModeManager.MoveCamera && !Hud.IsPositionOnScreen(movePosition))
{
Hud.CameraPosition = movePosition;
}
result.State = EvadeResult.EvadeState.TooEarly;
return(result);
}
}
if (ally.IsRuptured && ally.Distance(movePosition) > 300)
{
result.State = EvadeResult.EvadeState.Failed;
return(result);
}
if (!this.ChannelCanceled(ally, obstacle, remainingTime, null))
{
result.State = EvadeResult.EvadeState.Failed;
return(result);
}
if (!this.PhaseCanceled(ally, obstacle, null))
{
result.State = EvadeResult.EvadeState.Failed;
return(result);
}
if (speedBuffAbility != null)
{
speedBuffAbility.Use(ally, null, null);
result.AllyAbility = speedBuffAbility.Ability.DisplayName;
}
if (EvadeModeManager.MoveCamera && !Hud.IsPositionOnScreen(movePosition))
{
Hud.CameraPosition = movePosition;
}
ally.BaseUnit.Move(movePosition, false, true);
this.ActionManager.BlockInput(ally, obstacle, requiredTime + 0.2f);
this.ActionManager.IgnoreObstacle(ally, obstacle, requiredTime + 0.5f);
result.State = EvadeResult.EvadeState.Successful;
return(result);
}
