// Use this for initialization
void Start ()
{
if (mySpellDetector == null)
mySpellDetector = FindObjectOfType<SpellDetector>();
originalMaterial = readyIndicator.material;
}
private static void OnCreateObj_ViktorDeathRay3(GameObject obj, EventArgs args)
{
if (!obj.IsValid <MissileClient>())
{
return;
}
MissileClient missile = (MissileClient)obj;
SpellData spellData;
if (missile.SpellCaster != null && missile.SpellCaster.Team != ObjectManager.Player.Team &&
missile.SData.Name != null && missile.SData.Name.ToLower() == "viktoreaugmissile" &&
SpellDetector.onMissileSpells.TryGetValue("viktordeathray3", out spellData) &&
missile.StartPosition != null && missile.EndPosition != null)
{
var newData = (SpellData)spellData.Clone();
var missileDist = missile.EndPosition.To2D().Distance(missile.StartPosition.To2D());
newData.spellDelay = missileDist / 1.5f + 1000;
SpellDetector.CreateSpellData(missile.SpellCaster, missile.StartPosition, missile.EndPosition, newData);
}
}
private static void OnCreateObj_FizzMarinerDoom(GameObject obj, SpellData spellData)
{
// need to fix obj.isvalid on a previous thing.. I set it to just check the type
if (obj.IsValid)
{
if (obj.Type != GameObjectType.MissileClient)
{
return;
}
}
var missile = (MissileClient)obj;
var dist = missile.StartPosition.Distance(missile.EndPosition);
var radius = dist > 910 ? 400 : (dist >= 455 ? 300 : 200);
if (missile.SpellCaster != null && missile.SpellCaster.CheckTeam() &&
missile.SpellData.Name == "FizzRMissile")
{
SpellDetector.CreateSpellData(missile.SpellCaster, missile.StartPosition, missile.EndPosition,
spellData, null, 500, true, SpellType.Circular, false, radius);
}
}
private static void OnDeleteObj_FizzMarinerDoom(GameObject obj, SpellData spellData)
{
//need to track where bait is attached to
if (obj.IsValid)
{
if (obj.Type != GameObjectType.MissileClient)
{
return;
}
}
var missile = (MissileClient)obj;
var dist = missile.StartPosition.Distance(missile.EndPosition);
var radius = dist > 910 ? 400 : (dist >= 455 ? 300 : 200);
if (missile.SpellCaster != null && missile.SpellCaster.CheckTeam() &&
missile.SpellData.Name == "FizzRMissile")
{
SpellDetector.CreateSpellData(missile.SpellCaster, missile.StartPosition, missile.EndPosition,
spellData, null, 1000, true, SpellType.Circular, false, radius);
}
}
private void Game_OnUpdate(EventArgs args)
{
var sion = HeroManager.Enemies.FirstOrDefault(x => x.ChampionName == "Sion");
if (sion != null && sion.HasBuff("SionR"))
{
foreach (var spell in SpellDetector.detectedSpells.Where(x => x.Value.heroID == sion.NetworkId && x.Value.info.spellName == "SionR"))
{
var facingPos = sion.ServerPosition.To2D() + sion.Direction.To2D().Perpendicular();
var endPos = sion.ServerPosition.To2D() + (facingPos - sion.ServerPosition.To2D()).Normalized() * 450;
spell.Value.startPos = sion.ServerPosition.To2D();
spell.Value.endPos = endPos;
if (EvadeUtils.TickCount - spell.Value.startTime >= 1000)
{
SpellDetector.CreateSpellData(sion, sion.ServerPosition, endPos.To3D(), spell.Value.info, null, 0, false, SpellType.Line, false);
spell.Value.startTime = EvadeUtils.TickCount;
break;
}
}
}
}
private void GameObject_OnCreate(GameObject sender)
{
//var emitter = sender as Obj_GeneralParticleEmitter;
//if (emitter != null && emitter.CheckTeam())
//{
// SpellData spellData;
// if (SpellDetector.onProcessTraps.TryGetValue(emitter.Name.ToLower(), out spellData))
// {
// var trapData = (SpellData) spellData.Clone();
// if (!trapData.spellName.Contains("_trap"))
// trapData.spellName = trapData.spellName + "_trap";
// SpellDetector.CreateSpellData(null, emitter.Position, emitter.Position, trapData, emitter, 1337f);
// }
//}
var aiBase = sender as Obj_AI_Base;
if (aiBase != null && aiBase.CheckTeam())
{
SpellData spellData;
if (SpellDetector.OnProcessTraps.TryGetValue(aiBase.UnitSkinName.ToLower(), out spellData))
{
var trapData = (SpellData)spellData.Clone();
if (!trapData.SpellName.Contains("_trap"))
{
trapData.SpellName = trapData.SpellName + "_trap";
}
SpellDetector.CreateSpellData(aiBase, aiBase.ServerPosition, aiBase.ServerPosition, trapData, aiBase, 1337f);
}
}
}
private static void OnCreateObj_jayceshockblast(GameObject obj, EventArgs args, AIHeroClient hero, SpellData spellData)
{
if (obj.IsEnemy && obj.Type == GameObjectType.obj_GeneralParticleEmitter &&
obj.Name.Contains("Jayce") && obj.Name.Contains("accel_gate_start"))
{
var dir = ObjectTracker.GetLastHiuOrientation();
var pos1 = obj.Position.To2D() - dir * 470;
var pos2 = obj.Position.To2D() + dir * 470;
var gateTracker = new ObjectTrackerInfo(obj, "AccelGate");
gateTracker.Direction = dir.To3D();
ObjectTracker.ObjTracker.Add(obj.NetworkId, gateTracker);
foreach (var entry in SpellDetector.Spells)
{
var spell = entry.Value;
if (spell.Info.SpellName == "JayceShockBlast")
{
var tHero = spell.HeroId;
var intersection = spell.StartPos.Intersection(spell.EndPos, pos1, pos2);
var projection = intersection.Point.ProjectOn(spell.StartPos, spell.EndPos);
if (intersection.Intersects && projection.IsOnSegment)
{
SpellDetector.CreateSpellData(hero, intersection.Point.To3D(), spell.EndPos.To3D(), spellData, spell.SpellObject);
DelayAction.Add(1, () => SpellDetector.DeleteSpell(entry.Key));
}
}
}
SpellDetector.CreateSpellData(hero, pos1.To3D(), pos2.To3D(), spellData, null, 0);
}
}
private static void BardR(Obj_AI_Base sender, MissileClient missile, SpellData data, SpellArgs spellArgs)
{
if (data.MenuName != "BardR" || !missile.SData.Name.Contains("Fixed"))
{
return;
}
var newData = (SpellData)data.Clone();
newData.MissileSpeed = newData.MissileMinSpeed;
var spell =
Evade.DetectedSpells.Values.FirstOrDefault(
i => i.Data.MenuName == data.MenuName && i.Unit.NetworkId == sender.NetworkId);
if (spell == null)
{
spellArgs.NewData = newData;
return;
}
Evade.DetectedSpells.Remove(spell.SpellId);
SpellDetector.AddSpell(sender, missile.StartPosition, missile.EndPosition, newData, missile);
}
private static void OnDash(Obj_AI_Base sender, Dash.DashItem args, SpellData data)
{
var caster = sender as AIHeroClient;
if (caster == null || !caster.IsValid || (!caster.IsEnemy && !Configs.Debug) ||
caster.ChampionName != data.ChampName)
{
return;
}
if (Utils.GameTimeTickCount - lastQTick > 100)
{
return;
}
var newData = (SpellData)data.Clone();
if (caster.HasBuff("RivenFengShuiEngine"))
{
newData.Radius += 75;
}
SpellDetector.AddSpell(caster, args.StartPos, args.EndPos, newData, null, SpellType.None, true, lastQTick);
}
private static void ProcessSpell_ZiggsQ(Obj_AI_Base hero, GameObjectProcessSpellCastEventArgs args, SpellData spellData, SpecialSpellEventArgs specialSpellArgs)
{
if (spellData.SpellName == "ZiggsQ")
{
var startPos = hero.ServerPosition.To2D();
var endPos = args.End.To2D();
var dir = (endPos - startPos).Normalized();
if (endPos.Distance(startPos) > 850)
{
endPos = startPos + dir * 850;
}
SpellDetector.CreateSpellData(hero, args.Start, endPos.To3D(), spellData, null, 0, false);
var endPos2 = endPos + dir * 0.4f * startPos.Distance(endPos);
SpellDetector.CreateSpellData(hero, args.Start, endPos2.To3D(), spellData, null, 250, false);
var endPos3 = endPos2 + dir * 0.6f * endPos.Distance(endPos2);
SpellDetector.CreateSpellData(hero, args.Start, endPos3.To3D(), spellData, null, 800);
specialSpellArgs.NoProcess = true;
}
}
private static void ProcessSpell_LuluQ(Obj_AI_Base hero, GameObjectProcessSpellCastEventArgs args, SpellData spellData,
SpecialSpellEventArgs specialSpellArgs)
{
if (spellData.spellName == "LuluQ")
{
foreach (KeyValuePair <int, ObjectTrackerInfo> entry in ObjectTracker.objTracker)
{
var info = entry.Value;
if (entry.Value.Name == "RobotBuddy")
{
if (info.obj == null || !info.obj.IsValid || info.obj.IsDead || info.obj.IsVisible)
{
continue;
}
else
{
Vector3 endPos2 = info.obj.Position.Extend(args.End, spellData.range);
SpellDetector.CreateSpellData(hero, info.obj.Position, endPos2, spellData, null, 0, false);
}
}
}
}
}
private static void ProcessSpell_LuluQ(Obj_AI_Base hero, Obj_AI_BaseMissileClientDataEventArgs args,
SpellData spellData,
SpecialSpellEventArgs specialSpellArgs)
{
if (spellData.spellName == "LuluQ")
{
foreach (var entry in ObjectTracker.objTracker)
{
var info = entry.Value;
if (entry.Value.Name == "RobotBuddy")
{
if (info.obj == null || !info.obj.IsValid || info.obj.IsDead || info.obj.IsVisible)
{
}
else
{
var endPos2 = info.obj.Position.Extend(args.End, spellData.range);
SpellDetector.CreateSpellData(hero, info.obj.Position, endPos2, spellData, null, 0, false);
}
}
}
}
}
private static void OnCreateObj_ViktorDeathRay3(GameObject obj, EventArgs args)
{
if (obj.GetType() != typeof(MissileClient) || !((MissileClient)obj).IsValidMissile())
{
return;
}
MissileClient missile = (MissileClient)obj;
SpellData spellData;
if (missile.SpellCaster != null && missile.SpellCaster.Team != ObjectManager.Player.Team &&
missile.SData.Name != null && missile.SData.Name == "viktoreaugmissile" &&
SpellDetector.onMissileSpells.TryGetValue("ViktorDeathRay3", out spellData) &&
missile.StartPosition != null && missile.EndPosition != null)
{
var missileDist = missile.EndPosition.To2D().Distance(missile.StartPosition.To2D());
var delay = missileDist / 1.5f + 600;
spellData.spellDelay = delay;
SpellDetector.CreateSpellData(missile.SpellCaster, missile.StartPosition, missile.EndPosition, spellData);
}
}
private static void ProcessSpell_AzirSoldier(Obj_AI_Base hero, GameObjectProcessSpellCastEventArgs args, SpellData spellData, SpecialSpellEventArgs specialSpellArgs)
{
if (spellData.spellName == "AzirQWrapper")
{
foreach (KeyValuePair <int, ObjectTrackerInfo> entry in ObjectTracker.objTracker)
{
var info = entry.Value;
if (info.Name == "AzirQSoldier")
{
foreach (var objEntry in info.objList)
{
var soldier = objEntry.Value;
if (soldier == null || !soldier.IsValid || soldier.IsDead)
{
continue;
}
SpellDetector.CreateSpellData(hero, soldier.Position, args.End, spellData);
}
}
}
specialSpellArgs.noProcess = true;
}
}
private static void OnCreateObj_jayceshockblast(GameObject obj, EventArgs args, Obj_AI_Hero hero, SpellData spellData)
{
if (obj.Type == GameObjectType.obj_GeneralParticleEmitter &&
obj.Name.Contains("Jayce") &&
obj.Name.Contains("accel_gate_end") &&
obj.Name.Contains("RED"))
{
foreach (var tracker in ObjectTracker.objTracker)
{
var gateObj = tracker.Value;
if (gateObj.Name == "AccelGate")
{
DelayAction.Add(0, () => ObjectTracker.objTracker.Remove(tracker.Key));
}
}
}
if (obj.Type == GameObjectType.obj_GeneralParticleEmitter &&
obj.Name.Contains("Jayce") &&
obj.Name.Contains("accel_gate_start") &&
obj.Name.Contains("RED"))
{
//var particle = obj as Obj_GeneralParticleEmitter;
/*var dir = obj.Orientation.To2D();
* var pos1 = obj.Position.To2D() - dir * 470;
* var pos2 = obj.Position.To2D() + dir * 470;
*
* //Draw.RenderObjects.Add(new Draw.RenderLine(pos1, pos2, 3500));
* Draw.RenderObjects.Add(new Draw.RenderCircle(pos1, 3500));*/
var gateTracker = new ObjectTrackerInfo(obj, "AccelGate");
//gateTracker.direction = dir.To3D();
ObjectTracker.objTracker.Add(obj.NetworkId, gateTracker);
foreach (var entry in SpellDetector.spells) //check currently moving skillshot
{
var spell = entry.Value;
if (spell.info.spellName == "jayceshockblast")
{
var tHero = spell.heroID;
Vector2 int1, int2;
var intersection =
MathUtils.FindLineCircleIntersections(obj.Position.To2D(), 470, spell.startPos, spell.endPos,
out int1, out int2);
var projection = obj.Position.To2D().ProjectOn(spell.startPos, spell.endPos);
//var intersection = spell.startPos.Intersection(spell.endPos, pos1, pos2);
//var projection = intersection.Point.ProjectOn(spell.startPos, spell.endPos);
//if (intersection.Intersects && projection.IsOnSegment)
if (intersection > 0 && projection.IsOnSegment)
{
SpellDetector.CreateSpellData(hero, projection.SegmentPoint.To3D(), spell.endPos.To3D(),
spellData, spell.spellObject);
DelayAction.Add(1, () => SpellDetector.DeleteSpell(entry.Key));
break;
}
}
}
//SpellDetector.CreateSpellData(hero, pos1.To3D(), pos2.To3D(), spellData, null, 0);
}
}
private void SpellDetector_OnProcessSpecialSpell(Obj_AI_Base hero, GameObjectProcessSpellCastEventArgs args, SpellData spellData, SpecialSpellEventArgs specialSpellArgs)
{
if (spellData.spellName.ToLower() == "syndrae")
{
var estart = args.Start;
var eend = args.Start + (args.End - args.Start).Normalized() * 700;
foreach (var sphere in _spheres.Where(s => s.IsValid && !s.IsDead))
{
// check if e whill hit the sphere
var proj = sphere.Position.To2D().ProjectOn(estart.To2D(), eend.To2D());
if (proj.IsOnSegment && sphere.Position.To2D().Distance(proj.SegmentPoint) <= sphere.BoundingRadius + 155)
{
var start = sphere.Position;
var end = hero.ServerPosition + (sphere.Position - hero.ServerPosition).Normalized() * spellData.range;
var data = spellData.CopyData();
data.spellDelay = sphere.Distance(hero.ServerPosition) / spellData.projectileSpeed * 1000;
SpellDetector.CreateSpellData(hero, start, end, data, sphere);
}
}
foreach (var entry in _qSpots)
{
var spherePosition = entry.Value;
// check if e whill hit the sphere
var proj = spherePosition.To2D().ProjectOn(estart.To2D(), eend.To2D());
if (proj.IsOnSegment && spherePosition.To2D().Distance(proj.SegmentPoint) <= 155)
{
var start = spherePosition;
var end = hero.ServerPosition + (spherePosition - hero.ServerPosition).Normalized() * spellData.range;
var data = spellData.CopyData();
data.spellDelay = spherePosition.Distance(hero.ServerPosition) / spellData.projectileSpeed * 1000;
SpellDetector.CreateSpellData(hero, start, end, data, null);
}
}
specialSpellArgs.noProcess = true;
}
if (spellData.spellName.ToLower() == "syndraq")
{
var end = args.End;
if (args.Start.Distance(end) > spellData.range)
{
end = args.Start + (args.End - args.Start).Normalized() * spellData.range;
}
_qSpots.Add(Game.Time, end);
}
if (spellData.spellName.ToLower() == "syndrawcast")
{
var end = args.End;
if (args.Start.Distance(end) > spellData.range)
{
end = args.Start + (args.End - args.Start).Normalized() * spellData.range;
}
_qSpots.Add(Game.Time, end);
}
}
private static void ProcessSpell_OrianaIzunaCommand(Obj_AI_Base hero, GameObjectProcessSpellCastEventArgs args, SpellData spellData,
SpecialSpellEventArgs specialSpellArgs)
{
if (spellData.SpellName == "OrianaIzunaCommand")
{
foreach (KeyValuePair <int, ObjectTrackerInfo> entry in ObjectTracker.ObjTracker)
{
var info = entry.Value;
if (entry.Value.Name == "TheDoomBall")
{
if (info.UsePosition)
{
SpellDetector.CreateSpellData(hero, info.Position, args.End, spellData, null, 0, false);
SpellDetector.CreateSpellData(hero, info.Position, args.End,
spellData, null, 150, true, SpellType.Circular, false, spellData.SecondaryRadius);
}
else
{
if (info.Obj == null)
{
return;
}
SpellDetector.CreateSpellData(hero, info.Obj.Position, args.End, spellData, null, 0, false);
SpellDetector.CreateSpellData(hero, info.Obj.Position, args.End,
spellData, null, 150, true, SpellType.Circular, false, spellData.SecondaryRadius);
}
info.Position = args.End;
info.UsePosition = true;
}
}
specialSpellArgs.NoProcess = true;
}
if (spellData.SpellName == "OrianaDetonateCommand" || spellData.SpellName == "OrianaDissonanceCommand")
{
foreach (KeyValuePair <int, ObjectTrackerInfo> entry in ObjectTracker.ObjTracker)
{
var info = entry.Value;
if (entry.Value.Name == "TheDoomBall")
{
if (info.UsePosition)
{
Vector3 endPos2 = info.Position;
SpellDetector.CreateSpellData(hero, endPos2, endPos2, spellData, null, 0);
}
else
{
if (info.Obj == null)
{
return;
}
Vector3 endPos2 = info.Obj.Position;
SpellDetector.CreateSpellData(hero, endPos2, endPos2, spellData, null, 0);
}
}
}
specialSpellArgs.NoProcess = true;
}
}
private void Game_OnGameLoad()
{
try
{
Obj_AI_Base.OnIssueOrder += Game_OnIssueOrder;
SpellBook.OnCastSpell += Game_OnCastSpell;
Game.OnUpdate += Game_OnGameUpdate;
Obj_AI_Base.OnProcessSpellCast += Game_OnProcessSpell;
Game.OnEnd += Game_OnGameEnd;
SpellDetector.OnProcessDetectedSpells += SpellDetector_OnProcessDetectedSpells;
var orbwalkerInst = Orbwalker.OrbwalkerInstances.FirstOrDefault();
if (orbwalkerInst != null)
{
orbwalkerInst.PreAttack += Orbwalker_PreAttack;
}
Menu = new Menu("ezevadeeeeeeeee", "EzEvade", true);
MainMenu = new Menu("MainMenu", "Main Menu")
{
new MenuKeyBind("DodgeSkillShots", "Dodge SkillShots", KeyCode.K, KeybindType.Toggle),
new MenuBool("DodgeDangerous", "Dodge Only Dangerous", false),
new MenuBool("DodgeCircularSpells", "Dodge Circular Spells"),
new MenuKeyBind("ActivateEvadeSpells", "Activate Evade Spells", KeyCode.K, KeybindType.Toggle),
new MenuBool("DodgeFOWSpells", "Dodge FOW Spells")
};
Menu.Add(MainMenu);
KeyMenu = new Menu("KeyMenu", "Key Menu")
{
new MenuBool("DodgeOnlyOnComboKeyEnabled", "Dodge Only On Combo Key Enabled", false),
new MenuKeyBind("DodgeComboKey", "Dodge Combo Key", KeyCode.Space, KeybindType.Press),
new MenuBool("DodgeDangerousKeyEnabled", "Enable Dodge Only Dangerous Keys", false),
new MenuKeyBind("DodgeDangerousKey", "Dodge Only Dangerous Key", KeyCode.Space, KeybindType.Press),
new MenuKeyBind("DodgeDangerousKey2", "Dodge Only Dangerous Key 2", KeyCode.V, KeybindType.Press),
new MenuBool("DontDodgeKeyEnabled", "Dont Dodge Key Enabled", false),
new MenuKeyBind("DontDodgeKey", "Dodge Combo Key", KeyCode.Z, KeybindType.Press)
};
Menu.Add(KeyMenu);
var loadTestMenu = new Menu("LoadTests", "Tests")
{
new MenuBool("LoadPingTester", "Load Ping Tester", false), new MenuBool("LoadSpellTester", "Load Spell Tester", false)
};
loadTestMenu["LoadPingTester"].OnValueChanged += OnLoadPingTesterChange;
loadTestMenu["LoadSpellTester"].OnValueChanged += OnLoadSpellTesterChange;
MiscMenu = new Menu("MiscMenu", "Misc Menu")
{
new MenuBool("HigherPrecision", "Higher Precision"),
new MenuBool("RecalculatePosition", "Recalculate Position"),
new MenuBool("ContinueMovement", "Continue Previous Movement"),
new MenuBool("ClickRemove", "Click Remove"),
new MenuBool("CalculateWindupDelay", "Calculate Windup Delay"),
new MenuBool("AdvancedSpellDetection", "Advanced Spell Detection"),
new MenuBool("CheckSpellCollision", "Check Spell Collision"),
new MenuList("EvadeMode", "Evade Profile", new[] { "Smooth", "Very Smooth", "Fastest", "Hawk", "Kurisu", "GuessWho" }, 0),
new MenuBool("PreventDodgingUnderTower", "Prevent Dodging Under Tower"),
new MenuBool("PreventDodgingNearEnemy", "Prevent Dodging Near Enemy"),
loadTestMenu
};
Menu.Add(MiscMenu);
MiscMenu["EvadeMode"].OnValueChanged += OnEvadeModeChange;
BufferMenu = new Menu("BufferMenu", "Buffer Menu")
{
new MenuSlider("ExtraSpellRadius", "Extra Spell Radius", 0),
new MenuSlider("ExtraPingBuffer", "Extra Ping Buffer", 65, 0, 200),
new MenuSlider("ExtraAvoidDistance", "Extra Avoid Distance", 50, 0, 300),
new MenuSlider("ExtraEvadeDistance", "Extra Evade Distance", 100, 0, 300),
new MenuSlider("ExtraCPADistance", "Extra Collision Distance", 10, 0, 150),
new MenuSlider("MinComfortZone", "Min Distance to Champion", 550, 0, 1000)
};
Menu.Add(BufferMenu);
LimiterMenu = new Menu("LimiterMenu", "Humanizer Menu")
{
new MenuSlider("SpellDetectionTime", "Spell Detection Time", 0, 0, 1000),
new MenuSlider("ReactionTime", "Reaction Time", 0, 0, 500),
new MenuSlider("DodgeInterval", "Dodge Interval Time", 0, 0, 2000),
new MenuSlider("TickLimiter", "Tick Limiter", 100, 0, 500),
new MenuBool("EnableEvadeDistance", "Extended Evade"),
new MenuBool("ClickOnlyOnce", "Only Click Once")
};
Menu.Add(LimiterMenu);
FastEvadeMenu = new Menu("FastEvade", "Fast Evade Menu")
{
new MenuBool("FastMovementBlock", "Fast Movement Block"),
new MenuSlider("FastEvadeActivationTime", "FastEvade Activation Time", 65, 0, 500),
new MenuSlider("SpellActivationTime", "Spell Activation Time", 400, 0, 1000),
new MenuSlider("RejectMinDistance", "Collision Distance Buffer", 10)
};
Menu.Add(FastEvadeMenu);
SpellDetector = new SpellDetector(Menu);
new EvadeSpell(Menu);
Menu.Attach();
new SpellDrawer(Menu);
if (DevModeOn)
{
var evadeTester = new Menu("ezevade: Test", "ezEvadeTest", true);
var o = new EvadeTester(evadeTester);
evadeTester.Attach();
}
Console.WriteLine("ezevade Loaded");
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public static PositionInfo GetBestPosition()
{
var posChecked = 0;
var maxPosToCheck = 50;
var posRadius = 50;
var radiusIndex = 0;
var extraDelayBuffer = ObjectCache.MenuCache.Cache["ExtraPingBuffer"].As <MenuSlider>().Value;
var extraEvadeDistance = ObjectCache.MenuCache.Cache["ExtraEvadeDistance"].As <MenuSlider>().Value;
SpellDetector.UpdateSpells();
CalculateEvadeTime();
if (ObjectCache.MenuCache.Cache["CalculateWindupDelay"].Enabled)
{
var extraWindupDelay = Evade.LastWindupTime - Environment.TickCount;
if (extraWindupDelay > 0)
{
extraDelayBuffer += (int)extraWindupDelay;
}
}
extraDelayBuffer += (int)Evade.AvgCalculationTime;
if (ObjectCache.MenuCache.Cache["HigherPrecision"].Enabled)
{
maxPosToCheck = 150;
posRadius = 25;
}
var heroPoint = ObjectCache.MyHeroCache.ServerPos2D;
var lastMovePos = Game.CursorPos.To2D();
var lowestEvadeTime = SpellDetector.GetLowestEvadeTime(out var lowestEvadeTimeSpell);
var fastestPositions = GetFastestPositions();
var posTable = fastestPositions.Select(pos => InitPositionInfo(pos, extraDelayBuffer, extraEvadeDistance, lastMovePos, lowestEvadeTimeSpell)).ToList();
while (posChecked < maxPosToCheck)
{
radiusIndex++;
var curRadius = radiusIndex * 2 * posRadius;
var curCircleChecks = (int)Math.Ceiling(2 * Math.PI * curRadius / (2 * (double)posRadius));
for (var i = 1; i < curCircleChecks; i++)
{
posChecked++;
var cRadians = 2 * Math.PI / (curCircleChecks - 1) * i; //check decimals
var pos = new Vector2((float)Math.Floor(heroPoint.X + curRadius * Math.Cos(cRadians)), (float)Math.Floor(heroPoint.Y + curRadius * Math.Sin(cRadians)));
posTable.Add(InitPositionInfo(pos, extraDelayBuffer, extraEvadeDistance, lastMovePos, lowestEvadeTimeSpell));
}
}
IOrderedEnumerable <PositionInfo> sortedPosTable;
if (ObjectCache.MenuCache.Cache["EvadeMode"].As <MenuList>().SelectedItem == "Fastest")
{
sortedPosTable = posTable.OrderBy(p => p.IsDangerousPos).ThenByDescending(p => p.IntersectionTime).ThenBy(p => p.PosDangerLevel).ThenBy(p => p.PosDangerCount);
FastEvadeMode = true;
}
else if (FastEvadeMode)
{
sortedPosTable = posTable.OrderBy(p => p.IsDangerousPos).ThenByDescending(p => p.IntersectionTime).ThenBy(p => p.PosDangerLevel).ThenBy(p => p.PosDangerCount);
}
else if (ObjectCache.MenuCache.Cache["FastEvadeActivationTime"].As <MenuSlider>().Value > 0 &&
ObjectCache.MenuCache.Cache["FastEvadeActivationTime"].As <MenuSlider>().Value + ObjectCache.GamePing + extraDelayBuffer > lowestEvadeTime)
{
sortedPosTable = posTable.OrderBy(p => p.IsDangerousPos).ThenByDescending(p => p.IntersectionTime).ThenBy(p => p.PosDangerLevel).ThenBy(p => p.PosDangerCount);
FastEvadeMode = true;
}
else
{
sortedPosTable = posTable.OrderBy(p => p.RejectPosition).ThenBy(p => p.PosDangerLevel).ThenBy(p => p.PosDangerCount).ThenBy(p => p.DistanceToMouse);
if (sortedPosTable.First().PosDangerCount != 0) //if can't dodge smoothly, dodge fast
{
var sortedPosTableFastest = posTable.OrderBy(p => p.IsDangerousPos).ThenByDescending(p => p.IntersectionTime).ThenBy(p => p.PosDangerLevel).ThenBy(p => p.PosDangerCount);
if (sortedPosTableFastest.First().PosDangerCount == 0)
{
sortedPosTable = sortedPosTableFastest;
FastEvadeMode = true;
}
}
}
foreach (var posInfo in sortedPosTable)
{
if (CheckPathCollision(MyHero, posInfo.Position))
{
continue;
}
if (FastEvadeMode)
{
posInfo.Position = GetExtendedSafePosition(ObjectCache.MyHeroCache.ServerPos2D, posInfo.Position, extraEvadeDistance);
return(CanHeroWalkToPos(posInfo.Position, ObjectCache.MyHeroCache.MoveSpeed, ObjectCache.GamePing, 0));
}
if (!PositionInfoStillValid(posInfo))
{
continue;
}
if (posInfo.Position.CheckDangerousPos(extraEvadeDistance)) //extra evade distance, no multiple skillshots
{
posInfo.Position = GetExtendedSafePosition(ObjectCache.MyHeroCache.ServerPos2D, posInfo.Position, extraEvadeDistance);
}
return(posInfo);
}
return(PositionInfo.SetAllUndodgeable());
}
private static void ProcessSpell_JarvanIVDragonStrike(Obj_AI_Base hero,
Obj_AI_BaseMissileClientDataEventArgs args, SpellData spellData, SpecialSpellEventArgs specialSpellArgs)
{
if (spellData.spellName == "JarvanIVDemacianStandard")
{
var end = args.End;
if (args.Start.Distance(end) > spellData.range)
{
end = args.Start + (args.End - args.Start).Normalized() * spellData.range;
}
_eSpots.Add(Game.ClockTime, end);
}
if (spellData.spellName == "JarvanIVDragonStrike")
{
if (SpellDetector.onProcessSpells.TryGetValue("jarvanivdragonstrike2", out spellData))
{
foreach (var entry in _eSpots)
{
var flagPosition = entry.Value;
if (args.End.To2D().Distance(flagPosition) < 300)
{
var dir = (flagPosition.To2D() - args.Start.To2D()).Normalized();
var endPosition = flagPosition.To2D() + dir * 110;
SpellDetector.CreateSpellData(hero, args.Start, endPosition.To3D(), spellData);
specialSpellArgs.noProcess = true;
return;
}
}
foreach (var entry in ObjectTracker.objTracker)
{
var info = entry.Value;
if (info.Name == "Beacon" || info.obj.Name == "Beacon")
{
if (info.usePosition == false && (info.obj == null || !info.obj.IsValid || info.obj.IsDead))
{
DelayAction.Add(1, () => ObjectTracker.objTracker.Remove(info.obj.NetworkId));
continue;
}
var objPosition = info.usePosition ? info.position.To2D() : info.obj.Position.To2D();
if (args.End.To2D().Distance(objPosition) < 300)
{
var dir = (objPosition - args.Start.To2D()).Normalized();
var endPosition = objPosition + dir * 110;
SpellDetector.CreateSpellData(hero, args.Start, endPosition.To3D(), spellData);
specialSpellArgs.noProcess = true;
return;
}
}
}
}
}
}
public static PositionInfo GetBestPositionTargetedDash(EvadeSpellData spell)
{
var extraDelayBuffer = ObjectCache.MenuCache.Cache["ExtraPingBuffer"].As <MenuSlider>().Value;
var extraEvadeDistance = Math.Max(100, ObjectCache.MenuCache.Cache["ExtraEvadeDistance"].As <MenuSlider>().Value);
var extraDist = ObjectCache.MenuCache.Cache["ExtraCPADistance"].As <MenuSlider>().Value;
var heroPoint = ObjectCache.MyHeroCache.ServerPos2DPing;
var posTable = new List <PositionInfo>();
var spellList = SpellDetector.GetSpellList();
var collisionCandidates = new List <Obj_AI_Base>();
if (spell.SpellTargets.Contains(SpellTargets.Targetables))
{
collisionCandidates.AddRange(ObjectManager.Get <Obj_AI_Base>().Where(h => !h.IsMe && h.IsValidTarget(spell.Range)).Where(obj => obj.Type != GameObjectType.obj_AI_Turret));
}
else
{
var heroList = new List <Obj_AI_Hero>(); // Maybe change to IEnumerable
if (spell.SpellTargets.Contains(SpellTargets.EnemyChampions) && spell.SpellTargets.Contains(SpellTargets.AllyChampions))
{
heroList = GameObjects.Heroes.ToList();
}
else if (spell.SpellTargets.Contains(SpellTargets.EnemyChampions))
{
heroList = GameObjects.EnemyHeroes.ToList();
}
else if (spell.SpellTargets.Contains(SpellTargets.AllyChampions))
{
heroList = GameObjects.AllyHeroes.ToList();
}
collisionCandidates.AddRange(heroList.Where(h => !h.IsMe && h.IsValidTarget(spell.Range)).Cast <Obj_AI_Base>());
var minionList = new List <Obj_AI_Minion>();
if (spell.SpellTargets.Contains(SpellTargets.EnemyMinions) && spell.SpellTargets.Contains(SpellTargets.AllyMinions))
{
minionList = GameObjects.Minions.Where(m => m.Distance(MyHero.ServerPosition) <= spell.Range).ToList();
}
else if (spell.SpellTargets.Contains(SpellTargets.EnemyMinions))
{
minionList = GameObjects.EnemyMinions.Where(m => m.Distance(MyHero.ServerPosition) <= spell.Range).ToList();
}
else if (spell.SpellTargets.Contains(SpellTargets.AllyMinions))
{
minionList = GameObjects.AllyMinions.Where(m => m.Distance(MyHero.ServerPosition) <= spell.Range).ToList();
}
collisionCandidates.AddRange(minionList.Where(h => h.IsValidTarget(spell.Range)).Cast <Obj_AI_Base>());
}
foreach (var candidate in collisionCandidates)
{
var pos = candidate.ServerPosition.To2D();
PositionInfo posInfo;
if (spell.SpellName == "YasuoDashWrapper")
{
var hasDashBuff = candidate.Buffs.Any(buff => buff.Name == "YasuoDashWrapper");
if (hasDashBuff)
{
continue;
}
}
if (spell.BehindTarget)
{
var dir = (pos - heroPoint).Normalized();
pos = pos + dir * (candidate.BoundingRadius + ObjectCache.MyHeroCache.BoundingRadius);
}
if (spell.InfrontTarget)
{
var dir = (pos - heroPoint).Normalized();
pos = pos - dir * (candidate.BoundingRadius + ObjectCache.MyHeroCache.BoundingRadius);
}
if (spell.FixedRange)
{
var dir = (pos - heroPoint).Normalized();
pos = heroPoint + dir * spell.Range;
}
if (spell.EvadeType == EvadeType.Dash)
{
posInfo = CanHeroWalkToPos(pos, spell.Speed, extraDelayBuffer + ObjectCache.GamePing, extraDist);
posInfo.IsDangerousPos = pos.CheckDangerousPos(6);
posInfo.DistanceToMouse = pos.GetPositionValue();
posInfo.SpellList = spellList;
}
else
{
var isDangerousPos = pos.CheckDangerousPos(6);
var dist = pos.GetPositionValue();
posInfo = new PositionInfo(pos, isDangerousPos, dist);
}
posInfo.Target = candidate;
posTable.Add(posInfo);
}
if (spell.EvadeType == EvadeType.Dash)
{
var sortedPosTable = posTable.OrderBy(p => p.IsDangerousPos).ThenBy(p => p.PosDangerLevel).ThenBy(p => p.PosDangerCount).ThenBy(p => p.DistanceToMouse);
var first = sortedPosTable.FirstOrDefault();
if (first != null && Evade.LastPosInfo != null && first.IsDangerousPos == false && Evade.LastPosInfo.PosDangerLevel > first.PosDangerLevel)
{
return(first);
}
}
else
{
var sortedPosTable = posTable.OrderBy(p => p.IsDangerousPos).ThenBy(p => p.DistanceToMouse);
var first = sortedPosTable.FirstOrDefault();
return(first);
}
return(null);
}
private static void ProcessSpell_OrianaIzunaCommand(Obj_AI_Base hero,
Obj_AI_BaseMissileClientDataEventArgs args, SpellData spellData,
SpecialSpellEventArgs specialSpellArgs)
{
if (spellData.spellName == "OrianaIzunaCommand")
{
foreach (var entry in ObjectTracker.objTracker)
{
var info = entry.Value;
if (entry.Value.Name == "TheDoomBall")
{
if (info.usePosition)
{
SpellDetector.CreateSpellData(hero, info.position, args.End, spellData, null, 0, false);
SpellDetector.CreateSpellData(hero, info.position, args.End, spellData, null, 150, true,
SpellType.Circular, false, spellData.secondaryRadius);
}
else
{
if (info.obj != null && info.obj.IsValid && !info.obj.IsDead)
{
SpellDetector.CreateSpellData(hero, info.obj.Position, args.End, spellData, null, 0,
false);
SpellDetector.CreateSpellData(hero, info.obj.Position, args.End, spellData, null, 150,
true, SpellType.Circular, false, spellData.secondaryRadius);
}
}
info.position = args.End;
info.usePosition = true;
}
}
specialSpellArgs.noProcess = true;
}
if (spellData.spellName == "OrianaDetonateCommand" || spellData.spellName == "OrianaDissonanceCommand")
{
foreach (var entry in ObjectTracker.objTracker)
{
var info = entry.Value;
if (entry.Value.Name == "TheDoomBall")
{
if (info.usePosition)
{
var endPos2 = info.position;
SpellDetector.CreateSpellData(hero, endPos2, endPos2, spellData, null, 0);
}
else
{
if (info.obj != null && info.obj.IsValid && !info.obj.IsDead)
{
var endPos2 = info.obj.Position;
SpellDetector.CreateSpellData(hero, endPos2, endPos2, spellData, null, 0);
}
}
}
}
specialSpellArgs.noProcess = true;
}
}
