public static bool InSkillShot(this Vector2 position, Spell spell, float radius, bool predictCollision = true)
{
if (spell.spellType == SpellType.Line)
{
Vector2 spellPos = spell.currentSpellPosition;
Vector2 spellEndPos = predictCollision ? spell.GetSpellEndPosition() : spell.endPos;
//spellPos = spellPos - spell.direction * radius; //leave some space at back of spell
//spellEndPos = spellEndPos + spell.direction * radius; //leave some space at the front of spell
/*if (spell.info.projectileSpeed == float.MaxValue
&& Evade.GetTickCount - spell.startTime > spell.info.spellDelay)
{
return false;
}*/
var projection = position.ProjectOn(spellPos, spellEndPos);
/*if (projection.SegmentPoint.Distance(spellEndPos) < 100) //Check Skillshot endpoints
{
//unfinished
}*/
return projection.IsOnSegment && projection.SegmentPoint.Distance(position) <= spell.radius + radius;
}
else if (spell.spellType == SpellType.Circular)
{
if (spell.info.spellName == "VeigarEventHorizon")
{
return position.Distance(spell.endPos) <= spell.radius + radius - ObjectCache.myHeroCache.boundingRadius
&& position.Distance(spell.endPos) >= spell.radius + radius - ObjectCache.myHeroCache.boundingRadius - 125;
}
return position.Distance(spell.endPos) <= spell.radius + radius - ObjectCache.myHeroCache.boundingRadius;
}
else if (spell.spellType == SpellType.Arc)
{
if (position.isLeftOfLineSegment(spell.startPos, spell.endPos))
{
return false;
}
var spellRange = spell.startPos.Distance(spell.endPos);
var midPoint = spell.startPos + spell.direction * (spellRange/2);
return position.Distance(midPoint) <= spell.radius + radius - ObjectCache.myHeroCache.boundingRadius;
}
else if (spell.spellType == SpellType.Cone)
{
}
return false;
}
public static PositionInfo InitPositionInfo(Vector2 pos, float extraDelayBuffer, float extraEvadeDistance, Vector2 lastMovePos, Spell lowestEvadeTimeSpell) //clean this shit up
{
if (!ObjectCache.myHeroCache.isMoving &&
ObjectCache.myHeroCache.serverPos2D.Distance(pos) <= 75)
{
pos = ObjectCache.myHeroCache.serverPos2D;
}
var extraDist = ObjectCache.menuCache.cache["ExtraCPADistance"].Cast<Slider>().CurrentValue;
var posInfo = CanHeroWalkToPos(pos, ObjectCache.myHeroCache.moveSpeed, extraDelayBuffer + ObjectCache.gamePing, extraDist);
posInfo.isDangerousPos = pos.CheckDangerousPos(6);
posInfo.hasExtraDistance = extraEvadeDistance > 0 ? pos.CheckDangerousPos(extraEvadeDistance) : false;// ? 1 : 0;
posInfo.closestDistance = posInfo.distanceToMouse; //GetMovementBlockPositionValue(pos, lastMovePos);
posInfo.intersectionTime = GetMinCPADistance(pos);
//GetIntersectDistance(lowestEvadeTimeSpell, ObjectCache.myHeroCache.serverPos2D, pos);
//GetClosestDistanceApproach(lowestEvadeTimeSpell, pos, ObjectCache.myHeroCache.moveSpeed, ObjectCache.gamePing, ObjectCache.myHeroCache.serverPos2D, 0);
posInfo.distanceToMouse = pos.GetPositionValue();
posInfo.posDistToChamps = pos.GetDistanceToChampions();
posInfo.speed = ObjectCache.myHeroCache.moveSpeed;
if (ObjectCache.menuCache.cache["RejectMinDistance"].Cast<Slider>().CurrentValue > 0
&& ObjectCache.menuCache.cache["RejectMinDistance"].Cast<Slider>().CurrentValue >
posInfo.closestDistance) //reject closestdistance
{
posInfo.rejectPosition = true;
}
if (ObjectCache.menuCache.cache["MinComfortZone"].Cast<Slider>().CurrentValue >
posInfo.posDistToChamps)
{
posInfo.hasComfortZone = false;
}
return posInfo;
}
public static bool PlayerInSkillShot(Spell spell)
{
return ObjectCache.myHeroCache.serverPos2D.InSkillShot(spell, ObjectCache.myHeroCache.boundingRadius);
}
public static Vector2 GetFastestPosition(Spell spell)
{
var heroPos = ObjectCache.myHeroCache.serverPos2D;
if (spell.spellType == SpellType.Line)
{
var projection = heroPos.ProjectOn(spell.startPos, spell.endPos).SegmentPoint;
return projection.Extend(heroPos, spell.radius + ObjectCache.myHeroCache.boundingRadius + 10);
}
else if (spell.spellType == SpellType.Circular)
{
return spell.endPos.Extend(heroPos, spell.radius + 10);
}
return Vector2.Zero;
}
private static bool ShouldActivateEvadeSpell(Spell spell)
{
if (Evade.lastPosInfo == null)
return false;
if (ObjectCache.menuCache.cache["DodgeSkillShots"].Cast<KeyBind>().CurrentValue)
{
if (Evade.lastPosInfo.undodgeableSpells.Contains(spell.spellID)
&& ObjectCache.myHeroCache.serverPos2D.InSkillShot(spell, ObjectCache.myHeroCache.boundingRadius))
{
return true;
}
}
else
{
if (ObjectCache.myHeroCache.serverPos2D.InSkillShot(spell, ObjectCache.myHeroCache.boundingRadius))
{
return true;
}
}
/*float activationTime = Evade.menu.SubMenu("MiscSettings").SubMenu("EvadeSpellMisc").Item("EvadeSpellActivationTime")
.Cast<Slider>().CurrentValue + ObjectCache.gamePing;
if (spell.spellHitTime != float.MinValue && activationTime > spell.spellHitTime - spell.evadeTime)
{
return true;
}*/
return false;
}
public static float GetLowestEvadeTime(out Spell lowestSpell)
{
float lowest = float.MaxValue;
lowestSpell = null;
foreach (KeyValuePair<int, Spell> entry in SpellDetector.spells)
{
Spell spell = entry.Value;
if (spell.spellHitTime != float.MinValue)
{
//Console.WriteLine("spellhittime: " + spell.spellHitTime);
lowest = Math.Min(lowest, (spell.spellHitTime - spell.evadeTime));
lowestSpell = spell;
}
}
return lowest;
}
public static bool CanHeroWalkIntoSpell(Spell spell)
{
if (ObjectCache.menuCache.cache["AdvancedSpellDetection"].Cast<CheckBox>().CurrentValue)
{
Vector2 heroPos = myHero.Position.To2D();
var extraDist = myHero.Distance(ObjectCache.myHeroCache.serverPos2D);
if (spell.spellType == SpellType.Line)
{
var walkRadius = ObjectCache.myHeroCache.moveSpeed * (spell.endTime - EvadeUtils.TickCount) / 1000 + ObjectCache.myHeroCache.boundingRadius + spell.info.radius + extraDist + 10;
var spellPos = spell.currentSpellPosition;
var spellEndPos = spell.GetSpellEndPosition();
var projection = heroPos.ProjectOn(spellPos, spellEndPos);
return projection.SegmentPoint.Distance(heroPos) <= walkRadius;
}
else if (spell.spellType == SpellType.Circular)
{
var walkRadius = ObjectCache.myHeroCache.moveSpeed * (spell.endTime - EvadeUtils.TickCount) / 1000 + ObjectCache.myHeroCache.boundingRadius + spell.info.radius + extraDist + 10;
if (heroPos.Distance(spell.endPos) < walkRadius)
{
return true;
}
}
else if (spell.spellType == SpellType.Arc)
{
var spellRange = spell.startPos.Distance(spell.endPos);
var midPoint = spell.startPos + spell.direction * (spellRange / 2);
var arcRadius = spell.info.radius * (1 + spellRange / 100);
var walkRadius = ObjectCache.myHeroCache.moveSpeed * (spell.endTime - EvadeUtils.TickCount) / 1000 + ObjectCache.myHeroCache.boundingRadius + arcRadius + extraDist + 10;
if (heroPos.Distance(midPoint) < walkRadius)
{
return true;
}
}
return false;
}
return true;
}
private void CompareSpellLocation(Spell spell, Vector2 pos, float time)
{
var pos2 = spell.currentSpellPosition;
if (spell.spellObject != null)
{
ConsolePrinter.Print("Compare: " + (pos2.Distance(pos)) / (EvadeUtils.TickCount - time));
}
}
private void SpellMissile_OnCreate(GameObject obj, EventArgs args)
{
if (!obj.IsValid <MissileClient>())
{
return;
}
MissileClient missile = (MissileClient)obj;
// todo: keepo
//if (missile.SpellCaster.IsMe)
// Console.WriteLine("Missile: " + missile.SData.Name);
SpellData spellData;
if (missile.SpellCaster != null && missile.SpellCaster.Team != myHero.Team &&
missile.SData.Name != null && onMissileSpells.TryGetValue(missile.SData.Name, out spellData) &&
missile.StartPosition != null && missile.EndPosition != null)
{
if (missile.StartPosition.Distance(myHero.Position) < spellData.range + 1000)
{
var hero = missile.SpellCaster;
if (hero.IsVisible)
{
if (spellData.usePackets)
{
CreateSpellData(hero, missile.StartPosition, missile.EndPosition, spellData, obj);
return;
}
var objectAssigned = false;
foreach (KeyValuePair <int, Spell> entry in detectedSpells)
{
Spell spell = entry.Value;
var dir = (missile.EndPosition.To2D() - missile.StartPosition.To2D()).Normalized();
if (spell.info.missileName.Equals(missile.SData.Name, StringComparison.InvariantCultureIgnoreCase) ||
(spell.info.missileName + "_urf").Equals(missile.SData.Name, StringComparison.InvariantCultureIgnoreCase) &&
spell.heroID == missile.SpellCaster.NetworkId &&
dir.AngleBetween(spell.direction) < 10)
{
if (spell.info.isThreeWay == false &&
spell.info.isSpecial == false)
{
spell.spellObject = obj;
objectAssigned = true;
break;
/*if(spell.spellType == SpellType.Line)
* {
* if (missile.SData.LineWidth != spell.info.radius)
* {
* Console.WriteLine("Wrong radius " + spell.info.spellName + ": "
+ spell.info.radius + " vs " + missile.SData.LineWidth);
+ }
+
+ if (missile.SData.MissileSpeed != spell.info.projectileSpeed)
+ {
+ Console.WriteLine("Wrong speed " + spell.info.spellName + ": "
+ spell.info.projectileSpeed + " vs " + missile.SData.MissileSpeed);
+ }
+
+ }*/
//var acquisitionTime = EvadeUtils.TickCount - spell.startTime;
//Console.WriteLine("AcquiredTime: " + acquisitionTime);
}
}
}
if (objectAssigned == false)
{
CreateSpellData(hero, missile.StartPosition, missile.EndPosition, spellData, obj);
}
}
else
{
if (ObjectCache.menuCache.cache["DodgeFOWSpells"].GetValue <bool>())
{
CreateSpellData(hero, missile.StartPosition, missile.EndPosition, spellData, obj);
}
}
}
}
}
private void Drawing_OnDraw(EventArgs args)
{
if (ObjectCache.menuCache.cache["DrawEvadePosition"].GetValue <bool>())
{
//Render.Circle.DrawCircle(myHero.Position.ExtendDir(dir, 500), 65, Color.Red, 10);
/*foreach (var point in myHero.Path)
* {
* Render.Circle.DrawCircle(point, 65, Color.Red, 10);
* }*/
if (Evade.lastPosInfo != null)
{
var pos = Evade.lastPosInfo.position; //Evade.lastEvadeCommand.targetPosition;
Render.Circle.DrawCircle(new Vector3(pos.X, pos.Y, myHero.Position.Z), 65, Color.Red, 10);
}
}
DrawEvadeStatus();
if (ObjectCache.menuCache.cache["DrawSkillShots"].GetValue <bool>() == false)
{
return;
}
foreach (KeyValuePair <int, Spell> entry in SpellDetector.drawSpells)
{
Spell spell = entry.Value;
var dangerStr = spell.GetSpellDangerString();
var spellDrawingConfig = ObjectCache.menuCache.cache[dangerStr + "Color"].GetValue <Circle>();
var spellDrawingWidth = ObjectCache.menuCache.cache[dangerStr + "Width"].GetValue <Slider>().Value;
var avoidRadius = ObjectCache.menuCache.cache["ExtraAvoidDistance"].GetValue <Slider>().Value;
if (ObjectCache.menuCache.cache[spell.info.spellName + "DrawSpell"].GetValue <bool>() &&
spellDrawingConfig.Active)
{
bool canEvade = !(Evade.lastPosInfo != null && Evade.lastPosInfo.undodgeableSpells.Contains(spell.spellID)) || !Evade.devModeOn;
if (spell.spellType == SpellType.Line)
{
Vector2 spellPos = spell.currentSpellPosition;
Vector2 spellEndPos = spell.GetSpellEndPosition();
DrawLineRectangle(spellPos, spellEndPos, (int)spell.radius,
spellDrawingWidth, !canEvade ? Color.Yellow : spellDrawingConfig.Color);
if (Evade.devModeOn)
{
DrawLineRectangle(spellPos, spellEndPos, (int)spell.radius + avoidRadius,
Math.Max(spellDrawingWidth - 1, 1), !canEvade ? Color.Yellow : spellDrawingConfig.Color);
}
if (ObjectCache.menuCache.cache["DrawSpellPos"].GetValue <bool>())// && spell.spellObject != null)
{
Render.Circle.DrawCircle(new Vector3(spellPos.X, spellPos.Y, spell.height), (int)spell.radius, !canEvade ? Color.Yellow : spellDrawingConfig.Color, spellDrawingWidth);
}
}
else if (spell.spellType == SpellType.Circular)
{
Render.Circle.DrawCircle(new Vector3(spell.endPos.X, spell.endPos.Y, spell.height), (int)spell.radius, !canEvade ? Color.Yellow : spellDrawingConfig.Color, spellDrawingWidth);
Render.Circle.DrawCircle(new Vector3(spell.endPos.X, spell.endPos.Y, spell.height), (int)spell.radius + avoidRadius, !canEvade ? Color.Yellow : spellDrawingConfig.Color, Math.Max(spellDrawingWidth - 1, 1));
if (spell.info.spellName == "VeigarEventHorizon")
{
Render.Circle.DrawCircle(new Vector3(spell.endPos.X, spell.endPos.Y, spell.height), (int)spell.radius - 125, !canEvade ? Color.Yellow : spellDrawingConfig.Color, spellDrawingWidth);
}
else if (spell.info.spellName == "DariusCleave")
{
Render.Circle.DrawCircle(new Vector3(spell.endPos.X, spell.endPos.Y, spell.height), (int)spell.radius - 220, !canEvade ? Color.Yellow : spellDrawingConfig.Color, spellDrawingWidth);
}
}
else if (spell.spellType == SpellType.Arc)
{
/*var spellRange = spell.startPos.Distance(spell.endPos);
* var midPoint = spell.startPos + spell.direction * (spellRange / 2);
*
* Render.Circle.DrawCircle(new Vector3(midPoint.X, midPoint.Y, myHero.Position.Z), (int)spell.radius, spellDrawingConfig.Color, spellDrawingWidth);
*
* Drawing.DrawLine(Drawing.WorldToScreen(spell.startPos.To3D()),
* Drawing.WorldToScreen(spell.endPos.To3D()),
* spellDrawingWidth, spellDrawingConfig.Color);*/
}
else if (spell.spellType == SpellType.Cone)
{
DrawLineTriangle(spell.startPos, spell.endPos, (int)spell.radius, spellDrawingWidth, spellDrawingConfig.Color);
}
}
}
}
private void Drawing_OnDraw(EventArgs args)
{
//PrintTimers();
//EvadeHelper.CheckMovePath(Game.CursorPos.To2D());
//TestUnderTurret();
/*if (EvadeHelper.CheckPathCollision(myHero, Game.CursorPos.To2D()))
* {
* var paths = myHero.GetPath(ObjectCache.myHeroCache.serverPos2DExtra.To3D(), Game.CursorPos);
* foreach (var path in paths)
* {
* Render.Circle.DrawCircle(path, ObjectCache.myHeroCache.boundingRadius, Color.Red, 3);
* }
* }
* else
* {
* Render.Circle.DrawCircle(Game.CursorPos, ObjectCache.myHeroCache.boundingRadius, Color.White, 3);
* }*/
foreach (KeyValuePair <int, Spell> entry in SpellDetector.drawSpells)
{
Spell spell = entry.Value;
if (spell.spellType == SpellType.Line)
{
Vector2 spellPos = spell.currentSpellPosition;
Render.Circle.DrawCircle(new Vector3(spellPos.X, spellPos.Y, myHero.Position.Z), spell.info.radius, Color.White, 3);
/*spellPos = spellPos + spell.direction * spell.info.projectileSpeed * (60 / 1000); //move the spellPos by 50 miliseconds forwards
* spellPos = spellPos + spell.direction * 200; //move the spellPos by 50 units forwards
*
* Render.Circle.DrawCircle(new Vector3(spellPos.X, spellPos.Y, myHero.Position.Z), spell.info.radius, Color.White, 3);*/
}
}
if (testMenu.Item("TestHeroPos").GetValue <bool>())
{
var path = myHero.Path;
if (path.Length > 0)
{
var heroPos2 = EvadeHelper.GetRealHeroPos(ObjectCache.gamePing + 50);// path[path.Length - 1].To2D();
var heroPos1 = ObjectCache.myHeroCache.serverPos2D;
Render.Circle.DrawCircle(new Vector3(heroPos2.X, heroPos2.Y, myHero.ServerPosition.Z), ObjectCache.myHeroCache.boundingRadius, Color.Red, 3);
Render.Circle.DrawCircle(new Vector3(myHero.ServerPosition.X, myHero.ServerPosition.Y, myHero.ServerPosition.Z), ObjectCache.myHeroCache.boundingRadius, Color.White, 3);
var heroPos = Drawing.WorldToScreen(ObjectManager.Player.Position);
var dimension = Drawing.GetTextEntent("Evade: ON", 0);
Drawing.DrawText(heroPos.X - dimension.Width / 2, heroPos.Y, Color.Red, "" + (int)(heroPos2.Distance(heroPos1)));
Render.Circle.DrawCircle(new Vector3(circleRenderPos.X, circleRenderPos.Y, myHero.ServerPosition.Z), 10, Color.Red, 3);
}
}
if (testMenu.Item("DrawHeroPos").GetValue <bool>())
{
Render.Circle.DrawCircle(new Vector3(myHero.ServerPosition.X, myHero.ServerPosition.Y, myHero.ServerPosition.Z), ObjectCache.myHeroCache.boundingRadius, Color.White, 3);
}
if (testMenu.Item("TestMoveTo").GetValue <KeyBind>().Active)
{
var keyBind = testMenu.Item("TestMoveTo").GetValue <KeyBind>();
testMenu.Item("TestMoveTo").SetValue(new KeyBind(keyBind.Key, KeyBindType.Toggle, false));
/*lastRightMouseClickTime = EvadeUtils.TickCount;
* myHero.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos,false);*/
Player.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
var dir = (Game.CursorPos - myHero.Position).Normalized();
//var pos2 = myHero.Position - dir * Game.CursorPos.Distance(myHero.Position);
//var pos2 = myHero.Position.To2D() - dir.To2D() * 75;
var pos2 = Game.CursorPos.To2D() - dir.To2D() * 75;
//Console.WriteLine(myHero.BBox.Maximum.Distance(myHero.Position));
DelayAction.Add(20, () => Player.IssueOrder(GameObjectOrder.MoveTo, pos2.To3D(), false));
//myHero.IssueOrder(GameObjectOrder.MoveTo, pos2, false);
}
if (testMenu.Item("TestPath").GetValue <bool>())
{
var tPath = myHero.GetPath(Game.CursorPos);
Vector2 lastPoint = Vector2.Zero;
foreach (Vector3 point in tPath)
{
var point2D = point.To2D();
Render.Circle.DrawCircle(new Vector3(point.X, point.Y, point.Z), ObjectCache.myHeroCache.boundingRadius, Color.Violet, 3);
lastPoint = point2D;
}
}
if (testMenu.Item("TestPath").GetValue <bool>())
{
var tPath = myHero.GetPath(Game.CursorPos);
Vector2 lastPoint = Vector2.Zero;
foreach (Vector3 point in tPath)
{
var point2D = point.To2D();
//Render.Circle.DrawCircle(new Vector3(point.X, point.Y, point.Z), ObjectCache.myHeroCache.boundingRadius, Color.Violet, 3);
lastPoint = point2D;
}
foreach (KeyValuePair <int, Spell> entry in SpellDetector.spells)
{
Spell spell = entry.Value;
Vector2 to = Game.CursorPos.To2D();
var dir = (to - myHero.Position.To2D()).Normalized();
Vector2 cPos1, cPos2;
var cpa = MathUtilsCPA.CPAPointsEx(myHero.Position.To2D(), dir * ObjectCache.myHeroCache.moveSpeed, spell.endPos, spell.direction * spell.info.projectileSpeed, to, spell.endPos);
var cpaTime = MathUtilsCPA.CPATime(myHero.Position.To2D(), dir * ObjectCache.myHeroCache.moveSpeed, spell.endPos, spell.direction * spell.info.projectileSpeed);
//ConsolePrinter.Print("" + cpaTime);
//Render.Circle.DrawCircle(cPos1.To3D(), ObjectCache.myHeroCache.boundingRadius, Color.Red, 3);
if (cpa < ObjectCache.myHeroCache.boundingRadius + spell.radius)
{
}
}
}
if (testMenu.Item("ShowBuffs").GetValue <bool>())
{
var target = myHero;
foreach (var hero in HeroManager.Enemies)
{
target = hero;
}
var buffs = target.Buffs;
//ConsolePrinter.Print(myHero.ChampionName);
//if(myHero.IsDead)
// ConsolePrinter.Print("dead");
if (!target.IsTargetable)
{
ConsolePrinter.Print("invul" + EvadeUtils.TickCount);
}
int height = 20;
foreach (var buff in buffs)
{
if (buff.IsValidBuff())
{
Drawing.DrawText(10, height, Color.White, buff.Name);
height += 20;
ConsolePrinter.Print(buff.Name);
}
}
}
if (testMenu.Item("TestTracker").GetValue <bool>())
{
foreach (KeyValuePair <int, ObjectTrackerInfo> entry in ObjectTracker.objTracker)
{
var info = entry.Value;
Vector3 endPos2;
if (info.usePosition == false)
{
endPos2 = info.obj.Position;
}
else
{
endPos2 = info.position;
}
Render.Circle.DrawCircle(new Vector3(endPos2.X, endPos2.Y, myHero.Position.Z), 50, Color.Green, 3);
}
/*foreach (var obj in ObjectManager.Get<Obj_AI_Minion>())
* {
* ConsolePrinter.Print("minion: " + obj.Name);
* if (obj.Name == "Ekko")
* {
* var pos = obj.Position;
* Render.Circle.DrawCircle(pos, 100, Color.Green, 3);
* }
* }*/
}
if (testMenu.Item("ShowMissileInfo").GetValue <bool>())
{
if (testMissile != null)
{
//Render.Circle.DrawCircle(testMissile.Position, testMissile.BoundingRadius, Color.White, 3);
}
}
if (testMenu.Item("TestWall").GetValue <bool>())
{
/*foreach (var posInfo in sortedBestPos)
* {
* var posOnScreen = Drawing.WorldToScreen(posInfo.position.To3D());
* //Drawing.DrawText(posOnScreen.X, posOnScreen.Y, Color.Aqua, "" + (int)posInfo.closestDistance);
*
*
* if (!posInfo.rejectPosition)
* {
* Drawing.DrawText(posOnScreen.X, posOnScreen.Y, Color.Aqua, "" + (int)posInfo.closestDistance);
* }
*
* Drawing.DrawText(posOnScreen.X, posOnScreen.Y, Color.Aqua, "" + (int)posInfo.closestDistance);
*
* if (posInfo.posDangerCount <= 0)
* {
* var pos = posInfo.position;
* Render.Circle.DrawCircle(new Vector3(pos.X, pos.Y, myHero.Position.Z), (float)25, Color.White, 3);
* }
* }*/
int posChecked = 0;
int maxPosToCheck = 50;
int posRadius = 50;
int radiusIndex = 0;
Vector2 heroPoint = ObjectCache.myHeroCache.serverPos2D;
List <PositionInfo> posTable = new List <PositionInfo>();
while (posChecked < maxPosToCheck)
{
radiusIndex++;
int curRadius = radiusIndex * (2 * posRadius);
int curCircleChecks = (int)Math.Ceiling((2 * Math.PI * (double)curRadius) / (2 * (double)posRadius));
for (int 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)));
if (!EvadeHelper.CheckPathCollision(myHero, pos))
{
Render.Circle.DrawCircle(new Vector3(pos.X, pos.Y, myHero.Position.Z), (float)25, Color.White, 3);
}
}
}
}
}
private void Game_OnIssueOrder(Obj_AI_Base hero, PlayerIssueOrderEventArgs args)
{
if (!hero.IsMe)
{
return;
}
if (args.Order == GameObjectOrder.HoldPosition)
{
var path = myHero.Path;
var heroPoint = ObjectCache.myHeroCache.serverPos2D;
if (path.Length > 0)
{
var movePos = path[path.Length - 1].To2D();
var walkDir = (movePos - heroPoint).Normalized();
//circleRenderPos = EvadeHelper.GetRealHeroPos();
//heroPoint;// +walkDir * ObjectCache.myHeroCache.moveSpeed * (((float)ObjectCache.gamePing) / 1000);
}
}
if (testMenu.Item("TestPath").GetValue <bool>())
{
var tPath = myHero.GetPath(args.TargetPosition);
Vector2 lastPoint = Vector2.Zero;
foreach (Vector3 point in tPath)
{
var point2D = point.To2D();
Draw.RenderObjects.Add(new Draw.RenderCircle(point2D, 500));
//Render.Circle.DrawCircle(new Vector3(point.X, point.Y, point.Z), ObjectCache.myHeroCache.boundingRadius, Color.Violet, 3);
}
}
/*
* if (args.Order == GameObjectOrder.MoveTo)
* {
* if (testingCollision)
* {
* if (args.TargetPosition.To2D().Distance(testCollisionPos) < 3)
* {
* //var path = myHero.GetPath();
* //circleRenderPos
*
* args.Process = false;
* }
* }
* }*/
if (args.Order == GameObjectOrder.MoveTo)
{
if (testMenu.Item("EvadeTesterPing").GetValue <bool>())
{
ConsolePrinter.Print("Sending Path ClickTime: " + (EvadeUtils.TickCount - lastRightMouseClickTime));
}
Vector2 heroPos = ObjectCache.myHeroCache.serverPos2D;
Vector2 pos = args.TargetPosition.To2D();
float speed = ObjectCache.myHeroCache.moveSpeed;
startWalkPos = heroPos;
startWalkTime = EvadeUtils.TickCount;
foreach (KeyValuePair <int, Spell> entry in SpellDetector.spells)
{
Spell spell = entry.Value;
var spellPos = spell.currentSpellPosition;
var walkDir = (pos - heroPos).Normalized();
float spellTime = (EvadeUtils.TickCount - spell.startTime) - spell.info.spellDelay;
spellPos = spell.startPos + spell.direction * spell.info.projectileSpeed * (spellTime / 1000);
//ConsolePrinter.Print("aaaa" + spellTime);
bool isCollision = false;
float movingCollisionTime = MathUtils.GetCollisionTime(heroPos, spellPos, walkDir * (speed - 25), spell.direction * (spell.info.projectileSpeed - 200), ObjectCache.myHeroCache.boundingRadius, spell.radius, out isCollision);
if (isCollision)
{
//ConsolePrinter.Print("aaaa" + spellPos.Distance(spell.endPos) / spell.info.projectileSpeed);
if (true)//spellPos.Distance(spell.endPos) / spell.info.projectileSpeed > movingCollisionTime)
{
ConsolePrinter.Print("movingCollisionTime: " + movingCollisionTime);
//circleRenderPos = heroPos + walkDir * speed * movingCollisionTime;
}
}
}
}
}
private void Game_ProcessSpell(Obj_AI_Base hero, GameObjectProcessSpellCastEventArgs args)
{
if (hero.IsMinion)
{
return;
}
if (testMenu.Item("ShowProcessSpell").GetValue <bool>())
{
ConsolePrinter.Print(args.SData.Name + " CastTime: " + (hero.Spellbook.CastTime - Game.Time));
ConsolePrinter.Print("CastRadius: " + args.SData.CastRadius);
/*foreach (PropertyDescriptor descriptor in TypeDescriptor.GetProperties(args.SData))
* {
* string name = descriptor.Name;
* object value = descriptor.GetValue(args.SData);
* ConsolePrinter.Print("{0}={1}", name, value);
* }*/
}
if (args.SData.Name == "YasuoQW")
{
Draw.RenderObjects.Add(
new Draw.RenderCircle(args.Start.To2D(), 500));
Draw.RenderObjects.Add(
new Draw.RenderCircle(args.End.To2D(), 500));
}
//ConsolePrinter.Print(EvadeUtils.TickCount - lastProcessPacketTime);
//circleRenderPos = args.SData.ParticleStartOffset.To2D();
/*Draw.RenderObjects.Add(
* new Draw.RenderPosition(args.Start.To2D(), Evade.GetTickCount + 500));
* Draw.RenderObjects.Add(
* new Draw.RenderPosition(args.End.To2D(), Evade.GetTickCount + 500));*/
/*float testTime;
*
*
* testTime = Evade.GetTickCount;
* for (int i = 0; i < 100000; i++)
* {
* var testVar = ObjectCache.myHeroCache.boundingRadius;
* }
* ConsolePrinter.Print("Test time1: " + (Evade.GetTickCount - testTime));
*
* testTime = Evade.GetTickCount;
* var cacheVar = ObjectCache.myHeroCache.boundingRadius;
* for (int i = 0; i < 100000; i++)
* {
* var testVar = cacheVar;
* }
* ConsolePrinter.Print("Test time1: " + (Evade.GetTickCount - testTime));*/
//ConsolePrinter.Print("NetworkID: " + args.MissileNetworkId);
lastHeroSpellCastTime = EvadeUtils.TickCount;
foreach (KeyValuePair <int, Spell> entry in SpellDetector.spells)
{
Spell spell = entry.Value;
if (spell.info.spellName == args.SData.Name &&
spell.heroID == hero.NetworkId)
{
if (spell.info.isThreeWay == false && spell.info.isSpecial == false)
{
ConsolePrinter.Print("Time diff: " + (EvadeUtils.TickCount - spell.startTime));
}
}
}
if (hero.IsMe)
{
lastSpellCastTime = EvadeUtils.TickCount;
}
}
public static float CompareFastestPosition(Spell spell, Vector2 start, Vector2 movePos)
{
var fastestPos = GetFastestPosition(spell);
var moveDir = (movePos - start).Normalized();
var fastestDir = (GetFastestPosition(spell) - start).Normalized();
return moveDir.AngleBetween(fastestDir); // * (180 / ((float)Math.PI));
}
public static Vector2 GetSpellEndPosition(this Spell spell)
{
return(spell.predictedEndPos == Vector2.Zero ? spell.endPos : spell.predictedEndPos);
}
private void SpellMissile_OnCreate(GameObject obj, EventArgs args)
{
/*if (sender.Name.ToLower().Contains("minion")
|| sender.Name.ToLower().Contains("turret")
|| sender.Type == GameObjectType.obj_GeneralParticleEmitter)
|| {
|| return;
|| }
||
|| if (sender.IsValid<MissileClient>())
|| {
|| var tMissile = sender as MissileClient;
|| if (tMissile.SpellCaster.Type != GameObjectType.AIHeroClient)
|| {
|| return;
|| }
|| }
||
|| ConsolePrinter.Print(sender.Type + " : " + sender.Name);*/
var minion = obj as Obj_AI_Minion;
if (minion != null)
{
ConsolePrinter.Print(minion.CharData.BaseSkinName);
}
if (obj.IsValid <MissileClient>())
{
MissileClient autoattack = (MissileClient)obj;
/*if (!autoattack.SpellCaster.IsMinion)
* {
* ConsolePrinter.Print("Missile Name " + autoattack.SData.Name);
* ConsolePrinter.Print("Missile Speed " + autoattack.SData.MissileSpeed);
* ConsolePrinter.Print("LineWidth " + autoattack.SData.LineWidth);
* ConsolePrinter.Print("Range " + autoattack.SData.CastRange);
* ConsolePrinter.Print("Accel " + autoattack.SData.MissileAccel);
* }*/
}
//ConsolePrinter.Print(obj.Name + ": " + obj.Type);
if (!obj.IsValid <MissileClient>())
{
return;
}
if (testMenu.Item("ShowMissileInfo").GetValue <bool>() == false)
{
return;
}
MissileClient missile = (MissileClient)obj;
if (!missile.SpellCaster.IsValid <AIHeroClient>())
{
//return;
}
var testMissileSpeedStartTime = EvadeUtils.TickCount;
var testMissileSpeedStartPos = missile.Position.To2D();
DelayAction.Add(250, () =>
{
if (missile != null && missile.IsValid && !missile.IsDead)
{
testMissileSpeedStartTime = EvadeUtils.TickCount;
testMissileSpeedStartPos = missile.Position.To2D();
}
});
testMissile = missile;
testMissileStartTime = EvadeUtils.TickCount;
ConsolePrinter.Print("Est.CastTime: " + (EvadeUtils.TickCount - lastHeroSpellCastTime));
ConsolePrinter.Print("Missile Name " + missile.SData.Name);
ConsolePrinter.Print("Missile Speed " + missile.SData.MissileSpeed);
ConsolePrinter.Print("Max Speed " + missile.SData.MissileMaxSpeed);
ConsolePrinter.Print("LineWidth " + missile.SData.LineWidth);
ConsolePrinter.Print("Range " + missile.SData.CastRange);
//ConsolePrinter.Print("Angle " + missile.SData.CastConeAngle);
/*ConsolePrinter.Print("Offset: " + missile.SData.ParticleStartOffset);
* ConsolePrinter.Print("Missile Speed " + missile.SData.MissileSpeed);
* ConsolePrinter.Print("LineWidth " + missile.SData.LineWidth);
* circleRenderPos = missile.SData.ParticleStartOffset.To2D();*/
//ConsolePrinter.Print("Acquired: " + (EvadeUtils.TickCount - lastSpellCastTime));
Draw.RenderObjects.Add(
new Draw.RenderCircle(missile.StartPosition.To2D(), 500));
Draw.RenderObjects.Add(
new Draw.RenderCircle(missile.EndPosition.To2D(), 500));
DelayAction.Add(750, () =>
{
if (missile != null && missile.IsValid && !missile.IsDead)
{
var dist = missile.Position.To2D().Distance(testMissileSpeedStartPos);
ConsolePrinter.Print("Est.Missile speed: " + dist / (EvadeUtils.TickCount - testMissileSpeedStartTime));
}
});
SpellData spellData;
if (missile.SpellCaster != null && missile.SpellCaster.Team != myHero.Team &&
missile.SData.Name != null && SpellDetector.onMissileSpells.TryGetValue(missile.SData.Name, out spellData) &&
missile.StartPosition != null && missile.EndPosition != null)
{
if (missile.StartPosition.Distance(myHero.Position) < spellData.range + 1000)
{
var hero = missile.SpellCaster;
if (hero.IsVisible)
{
foreach (KeyValuePair <int, Spell> entry in SpellDetector.spells)
{
Spell spell = entry.Value;
if (spell.info.missileName == missile.SData.Name &&
spell.heroID == missile.SpellCaster.NetworkId)
{
if (spell.info.isThreeWay == false && spell.info.isSpecial == false)
{
//spell.spellObject = obj;
ConsolePrinter.Print("Acquired: " + (EvadeUtils.TickCount - spell.startTime));
}
}
}
}
}
}
}
public static bool hasProjectile(this Spell spell)
{
return(spell.info.projectileSpeed > 0 && spell.info.projectileSpeed != float.MaxValue);
}
public static bool ActivateEvadeSpell(Spell spell, bool checkSpell = false)
{
var sortedEvadeSpells = evadeSpells.OrderBy(s => s.dangerlevel);
var extraDelayBuffer = ObjectCache.menuCache.cache["ExtraPingBuffer"].Cast <Slider>().CurrentValue;
float spellActivationTime = ObjectCache.menuCache.cache["SpellActivationTime"].Cast <Slider>().CurrentValue + ObjectCache.gamePing + extraDelayBuffer;
if (ObjectCache.menuCache.cache["CalculateWindupDelay"].Cast <CheckBox>().CurrentValue)
{
var extraWindupDelay = Evade.lastWindupTime - EvadeUtils.TickCount;
if (extraWindupDelay > 0)
{
return(false);
}
}
foreach (var evadeSpell in sortedEvadeSpells)
{
var processSpell = true;
if (ObjectCache.menuCache.cache[evadeSpell.name + "UseEvadeSpell"].Cast <CheckBox>().CurrentValue == false ||
GetSpellDangerLevel(evadeSpell) > spell.GetSpellDangerLevel() ||
(evadeSpell.isItem == false && !(myHero.Spellbook.CanUseSpell(evadeSpell.spellKey) == SpellState.Ready)) ||
(evadeSpell.isItem == true && !(LeagueSharp.Common.Items.CanUseItem((int)evadeSpell.itemID))) ||
(evadeSpell.checkSpellName == true && myHero.Spellbook.GetSpell(evadeSpell.spellKey).Name != evadeSpell.spellName))
{
continue; //can't use spell right now
}
float evadeTime, spellHitTime = 0;
spell.CanHeroEvade(myHero, out evadeTime, out spellHitTime);
float finalEvadeTime = (spellHitTime - evadeTime);
if (checkSpell)
{
var mode = ObjectCache.menuCache.cache[evadeSpell.name + "EvadeSpellMode"]
.Cast <Slider>().CurrentValue;
if (mode == 0)
{
continue;
}
else if (mode == 1)
{
if (spellActivationTime < finalEvadeTime)
{
continue;
}
}
}
else
{
//if (ObjectCache.menuCache.cache[evadeSpell.name + "LastResort"].Cast<CheckBox>().CurrentValue)
if (evadeSpell.spellDelay <= 50 && evadeSpell.evadeType != EvadeType.Dash)
{
var path = myHero.Path;
if (path.Length > 0)
{
var movePos = path[path.Length - 1].LSTo2D();
var posInfo = EvadeHelper.CanHeroWalkToPos(movePos, ObjectCache.myHeroCache.moveSpeed, 0, 0);
if (GetSpellDangerLevel(evadeSpell) > posInfo.posDangerLevel)
{
continue;
}
}
}
}
if (evadeSpell.evadeType != EvadeType.Dash && spellHitTime > evadeSpell.spellDelay + 100 + Game.Ping +
ObjectCache.menuCache.cache["ExtraPingBuffer"].Cast <Slider>().CurrentValue)
{
processSpell = false;
if (checkSpell == false)
{
continue;
}
}
if (evadeSpell.isSpecial == true)
{
if (evadeSpell.useSpellFunc != null)
{
if (evadeSpell.useSpellFunc(evadeSpell, processSpell))
{
return(true);
}
}
continue;
}
else if (evadeSpell.evadeType == EvadeType.Blink)
{
if (evadeSpell.castType == CastType.Position)
{
var posInfo = EvadeHelper.GetBestPositionBlink();
if (posInfo != null)
{
CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, posInfo.position), processSpell);
//DelayAction.Add(50, () => myHero.IssueOrder(GameObjectOrder.MoveTo, posInfo.position.To3D()));
return(true);
}
}
else if (evadeSpell.castType == CastType.Target)
{
var posInfo = EvadeHelper.GetBestPositionTargetedDash(evadeSpell);
if (posInfo != null && posInfo.target != null && posInfo.posDangerLevel == 0)
{
CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, posInfo.target), processSpell);
//DelayAction.Add(50, () => myHero.IssueOrder(GameObjectOrder.MoveTo, posInfo.position.To3D()));
return(true);
}
}
}
else if (evadeSpell.evadeType == EvadeType.Dash)
{
if (evadeSpell.castType == CastType.Position)
{
var posInfo = EvadeHelper.GetBestPositionDash(evadeSpell);
if (posInfo != null && CompareEvadeOption(posInfo, checkSpell))
{
if (evadeSpell.isReversed)
{
var dir = (posInfo.position - ObjectCache.myHeroCache.serverPos2D).LSNormalized();
var range = ObjectCache.myHeroCache.serverPos2D.LSDistance(posInfo.position);
var pos = ObjectCache.myHeroCache.serverPos2D - dir * range;
posInfo.position = pos;
}
CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, posInfo.position), processSpell);
//DelayAction.Add(50, () => myHero.IssueOrder(GameObjectOrder.MoveTo, posInfo.position.To3D()));
return(true);
}
}
else if (evadeSpell.castType == CastType.Target)
{
var posInfo = EvadeHelper.GetBestPositionTargetedDash(evadeSpell);
if (posInfo != null && posInfo.target != null && posInfo.posDangerLevel == 0)
{
CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, posInfo.target), processSpell);
//DelayAction.Add(50, () => myHero.IssueOrder(GameObjectOrder.MoveTo, posInfo.position.To3D()));
return(true);
}
}
}
else if (evadeSpell.evadeType == EvadeType.WindWall)
{
if (spell.hasProjectile() || evadeSpell.spellName == "FioraW") //temp fix, don't have fiora :'(
{
var dir = (spell.startPos - ObjectCache.myHeroCache.serverPos2D).LSNormalized();
var pos = ObjectCache.myHeroCache.serverPos2D + dir * 100;
CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, pos), processSpell);
return(true);
}
}
else if (evadeSpell.evadeType == EvadeType.SpellShield)
{
if (evadeSpell.isItem)
{
CastEvadeSpell(() => LeagueSharp.Common.Items.UseItem((int)evadeSpell.itemID), processSpell);
return(true);
}
else
{
if (evadeSpell.castType == CastType.Target)
{
CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, myHero), processSpell);
return(true);
}
else if (evadeSpell.castType == CastType.Self)
{
CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell), processSpell);
return(true);
}
}
}
else if (evadeSpell.evadeType == EvadeType.MovementSpeedBuff)
{
}
}
return(false);
}
public static bool CheckMoveToDirection(Vector2 from, Vector2 movePos, float extraDelay = 0)
{
var dir = (movePos - from).Normalized();
//movePos = movePos.ExtendDir(dir, ObjectCache.myHeroCache.boundingRadius);
foreach (KeyValuePair <int, Spell> entry in SpellDetector.spells)
{
Spell spell = entry.Value;
if (!from.InSkillShot(spell, ObjectCache.myHeroCache.boundingRadius))
{
Vector2 spellPos = spell.currentSpellPosition;
if (spell.spellType == SpellType.Line)
{
if (spell.LineIntersectLinearSpell(from, movePos))
{
return(true);
}
}
else if (spell.spellType == SpellType.Circular)
{
if (spell.info.spellName == "VeigarEventHorizon")
{
var cpa2 = MathUtilsCPA.CPAPointsEx(from, dir * ObjectCache.myHeroCache.moveSpeed, spell.endPos, new Vector2(0, 0), movePos, spell.endPos);
if (from.Distance(spell.endPos) < spell.radius &&
!(from.Distance(spell.endPos) < spell.radius - 135 &&
movePos.Distance(spell.endPos) < spell.radius - 135))
{
return(true);
}
else if (from.Distance(spell.endPos) > spell.radius && cpa2 < spell.radius + 10)
{
return(true);
}
}
else
{
Vector2 cHeroPos;
Vector2 cSpellPos;
var cpa2 = MathUtils.GetCollisionDistanceEx(
from, dir * ObjectCache.myHeroCache.moveSpeed, 1,
spell.endPos, new Vector2(0, 0), spell.radius,
out cHeroPos, out cSpellPos);
var cHeroPosProjection = cHeroPos.ProjectOn(from, movePos);
if (cHeroPosProjection.IsOnSegment && cpa2 != float.MaxValue)
{
return(true);
}
/*var cpa = MathUtilsCPA.CPAPointsEx(from, dir * ObjectCache.myHeroCache.moveSpeed, spell.endPos, new Vector2(0, 0), movePos, spell.endPos);
*
* if (cpa < spell.radius + 10)
* {
* return true;
* }*/
}
}
else if (spell.spellType == SpellType.Arc)
{
if (from.isLeftOfLineSegment(spell.startPos, spell.endPos))
{
return(MathUtils.CheckLineIntersection(from, movePos, spell.startPos, spell.endPos));
}
var spellRange = spell.startPos.Distance(spell.endPos);
var midPoint = spell.startPos + spell.direction * (spellRange / 2);
var cpa = MathUtilsCPA.CPAPointsEx(from, dir * ObjectCache.myHeroCache.moveSpeed, midPoint, new Vector2(0, 0), movePos, midPoint);
if (cpa < spell.radius + 10)
{
return(true);
}
}
else if (spell.spellType == SpellType.Cone)
{
}
}
}
return(false);
}
private void CompareSpellLocation2(Spell spell)
{
var pos1 = spell.currentSpellPosition;
var timeNow = EvadeUtils.TickCount;
if (spell.spellObject != null)
{
ConsolePrinter.Print("start distance: " + (spell.startPos.Distance(pos1)));
}
DelayAction.Add(250, () => CompareSpellLocation(spell, pos1, timeNow));
}
public static bool PlayerInSkillShot(Spell spell)
{
return(ObjectCache.myHeroCache.serverPos2D.InSkillShot(spell, ObjectCache.myHeroCache.boundingRadius));
}
public static void CreateSpellData(Obj_AI_Base hero, Vector3 spellStartPos, Vector3 spellEndPos,
SpellData spellData, GameObject obj = null, float extraEndTick = 0.0f, bool processSpell = true,
SpellType spellType = SpellType.None, bool checkEndExplosion = true, float spellRadius = 0)
{
if (checkEndExplosion && spellData.hasEndExplosion)
{
CreateSpellData(hero, spellStartPos, spellEndPos,
spellData, obj, extraEndTick, false,
spellData.spellType, false);
CreateSpellData(hero, spellStartPos, spellEndPos,
spellData, obj, extraEndTick, true,
SpellType.Circular, false);
return;
}
if (spellStartPos.Distance(myHero.Position) < spellData.range + 1000)
{
Vector2 startPosition = spellStartPos.To2D();
Vector2 endPosition = spellEndPos.To2D();
Vector2 direction = (endPosition - startPosition).Normalized();
float endTick = 0;
if (spellType == SpellType.None)
{
spellType = spellData.spellType;
}
if (spellData.fixedRange) //for diana q
{
if (endPosition.Distance(startPosition) > spellData.range)
{
//var heroCastPos = hero.ServerPosition.To2D();
//direction = (endPosition - heroCastPos).Normalized();
endPosition = startPosition + direction * spellData.range;
}
}
if (spellType == SpellType.Line)
{
endTick = spellData.spellDelay + (spellData.range / spellData.projectileSpeed) * 1000;
endPosition = startPosition + direction * spellData.range;
if (spellData.useEndPosition)
{
var range = spellEndPos.To2D().Distance(spellStartPos.To2D());
endTick = spellData.spellDelay + (range / spellData.projectileSpeed) * 1000;
endPosition = spellEndPos.To2D();
}
if (obj != null)
endTick -= spellData.spellDelay;
}
else if (spellType == SpellType.Circular)
{
endTick = spellData.spellDelay;
if (spellData.projectileSpeed == 0)
{
endPosition = hero.ServerPosition.To2D();
}
else if (spellData.projectileSpeed > 0)
{
if (spellData.spellType == SpellType.Line &&
spellData.hasEndExplosion &&
spellData.useEndPosition == false)
{
endPosition = startPosition + direction * spellData.range;
}
endTick = endTick + 1000 * startPosition.Distance(endPosition) / spellData.projectileSpeed;
}
}
else if (spellType == SpellType.Arc)
{
endTick = endTick + 1000 * startPosition.Distance(endPosition) / spellData.projectileSpeed;
if (obj != null)
endTick -= spellData.spellDelay;
}
else if (spellType == SpellType.Cone)
{
return;
}
else
{
return;
}
endTick += extraEndTick;
Spell newSpell = new Spell();
newSpell.startTime = EvadeUtils.TickCount;
newSpell.endTime = EvadeUtils.TickCount + endTick;
newSpell.startPos = startPosition;
newSpell.endPos = endPosition;
newSpell.height = spellEndPos.Z + spellData.extraDrawHeight;
newSpell.direction = direction;
newSpell.heroID = hero.NetworkId;
newSpell.info = spellData;
newSpell.spellType = spellType;
newSpell.radius = spellRadius > 0 ? spellRadius : newSpell.GetSpellRadius();
if (obj != null)
{
newSpell.spellObject = obj;
newSpell.projectileID = obj.NetworkId;
}
int spellID = CreateSpell(newSpell, processSpell);
DelayAction.Add((int)(endTick + spellData.extraEndTime), () => DeleteSpell(spellID));
}
}
public static PositionInfo InitPositionInfo(Vector2 pos, float extraDelayBuffer, float extraEvadeDistance, Vector2 lastMovePos, Spell lowestEvadeTimeSpell)
{
if (!ObjectCache.myHeroCache.isMoving && ObjectCache.myHeroCache.serverPos2D.Distance(pos) <= 75)
{
pos = ObjectCache.myHeroCache.serverPos2D;
}
var extraDist = ObjectCache.menuCache.cache["ExtraCPADistance"].GetValue <Slider>().Value;
PositionInfo posInfo;
posInfo = CanHeroWalkToPos(pos, ObjectCache.myHeroCache.moveSpeed, extraDelayBuffer + ObjectCache.gamePing, extraDist);
posInfo.isDangerousPos = pos.CheckDangerousPos(6);
posInfo.hasExtraDistance = extraEvadeDistance > 0 && pos.CheckDangerousPos(extraEvadeDistance);
posInfo.closestDistance = posInfo.distanceToMouse;
posInfo.distanceToMouse = pos.GetPositionValue();
posInfo.posDistToChamps = pos.GetDistanceToChampions();
posInfo.speed = ObjectCache.myHeroCache.moveSpeed;
if (ObjectCache.menuCache.cache["RejectMinDistance"].GetValue <Slider>().Value > 0 &&
ObjectCache.menuCache.cache["RejectMinDistance"].GetValue <Slider>().Value > posInfo.closestDistance) //reject closestdistance
{
posInfo.rejectPosition = true;
}
if (ObjectCache.menuCache.cache["MinComfortZone"].GetValue <Slider>().Value > posInfo.posDistToChamps)
{
posInfo.hasComfortZone = false;
}
return(posInfo);
}
private static int CreateSpell(Spell newSpell, bool processSpell = true)
{
int spellID = spellIDCount++;
newSpell.spellID = spellID;
newSpell.UpdateSpellInfo();
detectedSpells.Add(spellID, newSpell);
if (processSpell)
{
CheckSpellCollision();
AddDetectedSpells();
}
return spellID;
}
public static float GetClosestDistanceApproach(Spell spell, Vector2 pos, float speed, float delay, Vector2 heroPos, float extraDist)
{
var walkDir = (pos - heroPos).Normalized();
if (spell.spellType == SpellType.Line && spell.info.projectileSpeed != float.MaxValue)
{
var spellPos = spell.GetCurrentSpellPosition(true, delay);
var spellStartPos = spell.currentSpellPosition;
var spellEndPos = spell.GetSpellEndPosition();
var extendedPos = pos.ExtendDir(walkDir, ObjectCache.myHeroCache.boundingRadius + speed * delay / 1000);
Vector2 cHeroPos;
Vector2 cSpellPos;
var cpa2 = MathUtils.GetCollisionDistanceEx(
heroPos, walkDir * speed, ObjectCache.myHeroCache.boundingRadius,
spellPos, spell.direction * spell.info.projectileSpeed, spell.radius + extraDist,
out cHeroPos, out cSpellPos);
var cHeroPosProjection = cHeroPos.ProjectOn(heroPos, extendedPos);
var cSpellPosProjection = cSpellPos.ProjectOn(spellPos, spellEndPos);
if (cSpellPosProjection.IsOnSegment && cHeroPosProjection.IsOnSegment && cpa2 != float.MaxValue)
{
return(0);
}
var cpa = MathUtilsCPA.CPAPointsEx(heroPos, walkDir * speed, spellPos, spell.direction * spell.info.projectileSpeed, pos, spellEndPos, out cHeroPos, out cSpellPos);
cHeroPosProjection = cHeroPos.ProjectOn(heroPos, extendedPos);
cSpellPosProjection = cSpellPos.ProjectOn(spellPos, spellEndPos);
var checkDist = ObjectCache.myHeroCache.boundingRadius + spell.radius + extraDist;
if (cSpellPosProjection.IsOnSegment && cHeroPosProjection.IsOnSegment)
{
return(Math.Max(0, cpa - checkDist));
}
else
{
return(checkDist);
}
//return MathUtils.ClosestTimeOfApproach(heroPos, walkDir * speed, spellPos, spell.direction * spell.info.projectileSpeed);
}
else if (spell.spellType == SpellType.Line && spell.info.projectileSpeed == float.MaxValue)
{
var spellHitTime = Math.Max(0, spell.endTime - EvadeUtils.TickCount - delay); //extraDelay
var walkRange = heroPos.Distance(pos);
var predictedRange = speed * (spellHitTime / 1000);
var tHeroPos = heroPos + walkDir * Math.Min(predictedRange, walkRange); //Hero predicted pos
var projection = tHeroPos.ProjectOn(spell.startPos, spell.endPos);
return(Math.Max(0, tHeroPos.Distance(projection.SegmentPoint)
- (spell.radius + ObjectCache.myHeroCache.boundingRadius + extraDist))); //+ dodgeBuffer
}
else if (spell.spellType == SpellType.Circular)
{
var spellHitTime = Math.Max(0, spell.endTime - EvadeUtils.TickCount - delay); //extraDelay
var walkRange = heroPos.Distance(pos);
var predictedRange = speed * (spellHitTime / 1000);
var tHeroPos = heroPos + walkDir * Math.Min(predictedRange, walkRange); //Hero predicted pos
if (spell.info.spellName == "VeigarEventHorizon")
{
var wallRadius = 65;
var midRadius = spell.radius - wallRadius;
if (spellHitTime == 0)
{
return(0);
}
if (tHeroPos.Distance(spell.endPos) >= spell.radius)
{
return(Math.Max(0, tHeroPos.Distance(spell.endPos) - midRadius - wallRadius));
}
else
{
return(Math.Max(0, midRadius - tHeroPos.Distance(spell.endPos) - wallRadius));
}
}
var closestDist = Math.Max(0, tHeroPos.Distance(spell.endPos) - (spell.radius + extraDist));
if (spell.info.extraEndTime > 0 && closestDist != 0)
{
var remainingTime = Math.Max(0, spell.endTime + spell.info.extraEndTime - EvadeUtils.TickCount - delay);
var predictedRange2 = speed * (remainingTime / 1000);
var tHeroPos2 = heroPos + walkDir * Math.Min(predictedRange2, walkRange);
if (CheckMoveToDirection(tHeroPos, tHeroPos2))
{
return(0);
}
}
else
{
return(closestDist);
}
}
else if (spell.spellType == SpellType.Arc)
{
var spellPos = spell.GetCurrentSpellPosition(true, delay);
var spellEndPos = spell.GetSpellEndPosition();
var pDir = spell.direction.Perpendicular();
spellPos = spellPos - pDir * spell.radius / 2;
spellEndPos = spellEndPos - pDir * spell.radius / 2;
var extendedPos = pos.ExtendDir(walkDir, ObjectCache.myHeroCache.boundingRadius);
Vector2 cHeroPos;
Vector2 cSpellPos;
var cpa = MathUtilsCPA.CPAPointsEx(heroPos, walkDir * speed, spellPos, spell.direction * spell.info.projectileSpeed, pos, spellEndPos, out cHeroPos, out cSpellPos);
var cHeroPosProjection = cHeroPos.ProjectOn(heroPos, extendedPos);
var cSpellPosProjection = cSpellPos.ProjectOn(spellPos, spellEndPos);
var checkDist = spell.radius + extraDist;
if (cHeroPos.InSkillShot(spell, ObjectCache.myHeroCache.boundingRadius))
{
if (cSpellPosProjection.IsOnSegment && cHeroPosProjection.IsOnSegment)
{
return(Math.Max(0, cpa - checkDist));
}
else
{
return(checkDist);
}
}
}
return(1);
}
public static bool ActivateEvadeSpell(Spell spell, bool checkSpell = false)
{
var sortedEvadeSpells = evadeSpells.OrderBy(s => s.dangerlevel);
var extraDelayBuffer = ObjectCache.menuCache.cache["ExtraPingBuffer"].Cast<Slider>().CurrentValue;
float spellActivationTime = ObjectCache.menuCache.cache["SpellActivationTime"].Cast<Slider>().CurrentValue + ObjectCache.gamePing + extraDelayBuffer;
if (ObjectCache.menuCache.cache["CalculateWindupDelay"].Cast<CheckBox>().CurrentValue)
{
var extraWindupDelay = Evade.lastWindupTime - EvadeUtils.TickCount;
if (extraWindupDelay > 0)
{
return false;
}
}
foreach (var evadeSpell in sortedEvadeSpells)
{
var processSpell = true;
if (ObjectCache.menuCache.cache[evadeSpell.name + "UseEvadeSpell"].Cast<CheckBox>().CurrentValue == false
|| GetSpellDangerLevel(evadeSpell) > spell.GetSpellDangerLevel()
|| (evadeSpell.isItem == false && !(myHero.Spellbook.CanUseSpell(evadeSpell.spellKey) == SpellState.Ready))
|| (evadeSpell.isItem == true && !(Items.CanUseItem((int)evadeSpell.itemID)))
|| (evadeSpell.checkSpellName == true && myHero.Spellbook.GetSpell(evadeSpell.spellKey).Name != evadeSpell.spellName))
{
continue; //can't use spell right now
}
float evadeTime, spellHitTime = 0;
spell.CanHeroEvade(myHero, out evadeTime, out spellHitTime);
float finalEvadeTime = (spellHitTime - evadeTime);
if (checkSpell)
{
var mode = ObjectCache.menuCache.cache[evadeSpell.name + "EvadeSpellMode"]
.Cast<Slider>().CurrentValue;
if (mode == 0)
{
continue;
}
else if (mode == 1)
{
if (spellActivationTime < finalEvadeTime)
{
continue;
}
}
}
else
{
//if (ObjectCache.menuCache.cache[evadeSpell.name + "LastResort"].Cast<CheckBox>().CurrentValue)
if (evadeSpell.spellDelay <= 50 && evadeSpell.evadeType != EvadeType.Dash)
{
var path = myHero.Path;
if (path.Length > 0)
{
var movePos = path[path.Length - 1].To2D();
var posInfo = EvadeHelper.CanHeroWalkToPos(movePos, ObjectCache.myHeroCache.moveSpeed, 0, 0);
if (GetSpellDangerLevel(evadeSpell) > posInfo.posDangerLevel)
{
continue;
}
}
}
}
if (evadeSpell.evadeType != EvadeType.Dash && spellHitTime > evadeSpell.spellDelay + 100 + Game.Ping +
ObjectCache.menuCache.cache["ExtraPingBuffer"].Cast<Slider>().CurrentValue)
{
processSpell = false;
if (checkSpell == false)
{
continue;
}
}
if (evadeSpell.isSpecial == true)
{
if (evadeSpell.useSpellFunc != null)
{
if (evadeSpell.useSpellFunc(evadeSpell, processSpell))
{
return true;
}
}
continue;
}
else if (evadeSpell.evadeType == EvadeType.Blink)
{
if (evadeSpell.castType == CastType.Position)
{
var posInfo = EvadeHelper.GetBestPositionBlink();
if (posInfo != null)
{
CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, posInfo.position), processSpell);
//DelayAction.Add(50, () => myHero.IssueOrder(GameObjectOrder.MoveTo, posInfo.position.To3D()));
return true;
}
}
else if (evadeSpell.castType == CastType.Target)
{
var posInfo = EvadeHelper.GetBestPositionTargetedDash(evadeSpell);
if (posInfo != null && posInfo.target != null && posInfo.posDangerLevel == 0)
{
CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, posInfo.target), processSpell);
//DelayAction.Add(50, () => myHero.IssueOrder(GameObjectOrder.MoveTo, posInfo.position.To3D()));
return true;
}
}
}
else if (evadeSpell.evadeType == EvadeType.Dash)
{
if (evadeSpell.castType == CastType.Position)
{
var posInfo = EvadeHelper.GetBestPositionDash(evadeSpell);
if (posInfo != null && CompareEvadeOption(posInfo, checkSpell))
{
if (evadeSpell.isReversed)
{
var dir = (posInfo.position - ObjectCache.myHeroCache.serverPos2D).Normalized();
var range = ObjectCache.myHeroCache.serverPos2D.Distance(posInfo.position);
var pos = ObjectCache.myHeroCache.serverPos2D - dir * range;
posInfo.position = pos;
}
CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, posInfo.position), processSpell);
//DelayAction.Add(50, () => myHero.IssueOrder(GameObjectOrder.MoveTo, posInfo.position.To3D()));
return true;
}
}
else if (evadeSpell.castType == CastType.Target)
{
var posInfo = EvadeHelper.GetBestPositionTargetedDash(evadeSpell);
if (posInfo != null && posInfo.target != null && posInfo.posDangerLevel == 0)
{
CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, posInfo.target), processSpell);
//DelayAction.Add(50, () => myHero.IssueOrder(GameObjectOrder.MoveTo, posInfo.position.To3D()));
return true;
}
}
}
else if (evadeSpell.evadeType == EvadeType.WindWall)
{
if (spell.hasProjectile() || evadeSpell.spellName == "FioraW") //temp fix, don't have fiora :'(
{
var dir = (spell.startPos - ObjectCache.myHeroCache.serverPos2D).Normalized();
var pos = ObjectCache.myHeroCache.serverPos2D + dir * 100;
CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, pos), processSpell);
return true;
}
}
else if (evadeSpell.evadeType == EvadeType.SpellShield)
{
if (evadeSpell.isItem)
{
CastEvadeSpell(() => Items.UseItem((int)evadeSpell.itemID), processSpell);
return true;
}
else
{
if (evadeSpell.castType == CastType.Target)
{
CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, myHero), processSpell);
return true;
}
else if (evadeSpell.castType == CastType.Self)
{
CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell), processSpell);
return true;
}
}
}
else if (evadeSpell.evadeType == EvadeType.MovementSpeedBuff)
{
}
}
return false;
}
private void Game_ProcessSpell(Obj_AI_Base hero, GameObjectProcessSpellCastEventArgs args)
{
try
{
/*var castTime2 = (hero.Spellbook.CastTime - Game.Time) * 1000;
* if (castTime2 > 0)
* {
* Console.WriteLine(args.SData.Name + ": " + castTime2);
* }*/
// todo: keepo
//if (hero.IsMe)
// Console.WriteLine("Spell: " + args.SData.Name);
SpellData spellData;
if (hero.Team != myHero.Team && onProcessSpells.TryGetValue(args.SData.Name, out spellData))
{
if (spellData.usePackets == false)
{
var specialSpellArgs = new SpecialSpellEventArgs();
if (OnProcessSpecialSpell != null)
{
OnProcessSpecialSpell(hero, args, spellData, specialSpellArgs);
}
if (specialSpellArgs.noProcess == false && spellData.noProcess == false)
{
bool foundMissile = false;
if (spellData.isThreeWay == false && spellData.isSpecial == false)
{
foreach (KeyValuePair <int, Spell> entry in detectedSpells)
{
Spell spell = entry.Value;
var dir = (args.End.To2D() - args.Start.To2D()).Normalized();
if (spell.spellObject != null &&
(spell.info.spellName.Equals(args.SData.Name, StringComparison.InvariantCultureIgnoreCase) ||
(spell.info.spellName.ToLower() + "_urf").Equals(args.SData.Name, StringComparison.InvariantCultureIgnoreCase)) &&
spell.heroID == hero.NetworkId &&
dir.AngleBetween(spell.direction) < 10)
{
foundMissile = true;
break;
}
}
}
if (foundMissile == false)
{
CreateSpellData(hero, hero.ServerPosition, args.End, spellData, null);
}
/*if (spellData.spellType == SpellType.Line)
* {
* var castTime = (hero.Spellbook.CastTime - Game.Time) * 1000;
*
* if (Math.Abs(castTime - spellData.spellDelay) > 5)
* {
* Console.WriteLine("Wrong delay " + spellData.spellName + ": "
+ spellData.spellDelay + " vs " + castTime);
+ }
+ }*/
}
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public static float GetIntersectDistance(Spell spell, Vector2 start, Vector2 end)
{
if (spell == null)
return float.MaxValue;
Vector3 start3D = new Vector3(start.X, start.Y, 0);
Vector2 walkDir = (end - start);
Vector3 walkDir3D = new Vector3(walkDir.X, walkDir.Y, 0);
Ray heroPath = new Ray(start3D, walkDir3D);
if (spell.spellType == SpellType.Line)
{
Vector2 intersection;
bool hasIntersection = spell.LineIntersectLinearSpellEx(start, end, out intersection);
if (hasIntersection)
{
return start.Distance(intersection);
}
}
else if (spell.spellType == SpellType.Circular)
{
if (end.InSkillShot(spell, ObjectCache.myHeroCache.boundingRadius) == false)
{
Vector2 intersection1, intersection2;
MathUtils.FindLineCircleIntersections(spell.endPos, spell.radius, start, end, out intersection1, out intersection2);
if (intersection1.X != float.NaN && MathUtils.isPointOnLineSegment(intersection1, start, end))
{
return start.Distance(intersection1);
}
else if (intersection2.X != float.NaN && MathUtils.isPointOnLineSegment(intersection2, start, end))
{
return start.Distance(intersection2);
}
}
}
return float.MaxValue;
}
public static void CreateSpellData(Obj_AI_Base hero, Vector3 spellStartPos, Vector3 spellEndPos,
SpellData spellData, GameObject obj = null, float extraEndTick = 0.0f, bool processSpell = true,
SpellType spellType = SpellType.None, bool checkEndExplosion = true, float spellRadius = 0)
{
if (checkEndExplosion && spellData.hasEndExplosion)
{
CreateSpellData(hero, spellStartPos, spellEndPos,
spellData, obj, extraEndTick, false,
spellData.spellType, false);
CreateSpellData(hero, spellStartPos, spellEndPos,
spellData, obj, extraEndTick, true,
SpellType.Circular, false);
return;
}
if (spellStartPos.Distance(myHero.Position) < spellData.range + 1000)
{
Vector2 startPosition = spellStartPos.To2D();
Vector2 endPosition = spellEndPos.To2D();
Vector2 direction = (endPosition - startPosition).Normalized();
float endTick = 0;
if (spellType == SpellType.None)
{
spellType = spellData.spellType;
}
if (spellData.fixedRange) //for diana q
{
if (endPosition.Distance(startPosition) > spellData.range)
{
//var heroCastPos = hero.ServerPosition.To2D();
//direction = (endPosition - heroCastPos).Normalized();
endPosition = startPosition + direction * spellData.range;
}
}
if (spellType == SpellType.Line)
{
endTick = spellData.spellDelay + (spellData.range / spellData.projectileSpeed) * 1000;
endPosition = startPosition + direction * spellData.range;
if (spellData.useEndPosition)
{
var range = spellEndPos.To2D().Distance(spellStartPos.To2D());
endTick = spellData.spellDelay + (range / spellData.projectileSpeed) * 1000;
endPosition = spellEndPos.To2D();
}
if (obj != null)
{
endTick -= spellData.spellDelay;
}
}
else if (spellType == SpellType.Circular)
{
endTick = spellData.spellDelay;
if (spellData.projectileSpeed == 0)
{
endPosition = hero.ServerPosition.To2D();
}
else if (spellData.projectileSpeed > 0)
{
if (spellData.spellType == SpellType.Line &&
spellData.hasEndExplosion &&
spellData.useEndPosition == false)
{
endPosition = startPosition + direction * spellData.range;
}
endTick = endTick + 1000 * startPosition.Distance(endPosition) / spellData.projectileSpeed;
}
}
else if (spellType == SpellType.Arc)
{
endTick = endTick + 1000 * startPosition.Distance(endPosition) / spellData.projectileSpeed;
if (obj != null)
{
endTick -= spellData.spellDelay;
}
}
else if (spellType == SpellType.Cone)
{
return;
}
else
{
return;
}
if (spellData.invert)
{
var dir = (startPosition - endPosition).Normalized();
endPosition = startPosition + dir * startPosition.Distance(endPosition);
}
endTick += extraEndTick;
Spell newSpell = new Spell();
newSpell.startTime = EvadeUtils.TickCount;
newSpell.endTime = EvadeUtils.TickCount + endTick;
newSpell.startPos = startPosition;
newSpell.endPos = endPosition;
newSpell.height = spellEndPos.Z + spellData.extraDrawHeight;
newSpell.direction = direction;
newSpell.heroID = hero.NetworkId;
newSpell.info = spellData;
newSpell.spellType = spellType;
newSpell.radius = spellRadius > 0 ? spellRadius : newSpell.GetSpellRadius();
if (obj != null)
{
newSpell.spellObject = obj;
newSpell.projectileID = obj.NetworkId;
}
int spellID = CreateSpell(newSpell, processSpell);
DelayAction.Add((int)(endTick + spellData.extraEndTime), () => DeleteSpell(spellID));
}
}
public static bool PredictSpellCollision(Spell spell, Vector2 pos, float speed, float delay, Vector2 heroPos, float extraDist, bool useServerPosition = true)
{
extraDist = extraDist + 10;
if (useServerPosition == false)
{
return GetClosestDistanceApproach(spell, pos, speed, 0,
ObjectCache.myHeroCache.serverPos2D, 0) == 0;
}
return
GetClosestDistanceApproach(spell, pos, speed, delay, //Game.Ping + Extra Buffer
ObjectCache.myHeroCache.serverPos2DPing, extraDist) == 0
|| GetClosestDistanceApproach(spell, pos, speed, ObjectCache.gamePing, //Game.Ping
ObjectCache.myHeroCache.serverPos2DPing, extraDist) == 0;
}
private static void AddDetectedSpells()
{
bool spellAdded = false;
foreach (KeyValuePair <int, Spell> entry in detectedSpells)
{
Spell spell = entry.Value;
EvadeHelper.fastEvadeMode = ObjectCache.menuCache.cache[spell.info.spellName + "FastEvade"].GetValue <bool>();
float evadeTime, spellHitTime;
spell.CanHeroEvade(myHero, out evadeTime, out spellHitTime);
spell.spellHitTime = spellHitTime;
spell.evadeTime = evadeTime;
var extraDelay = ObjectCache.gamePing + ObjectCache.menuCache.cache["ExtraPingBuffer"].GetValue <Slider>().Value;
if (spell.spellHitTime - extraDelay < 1500 && CanHeroWalkIntoSpell(spell))
//if(true)
{
Spell newSpell = spell;
int spellID = spell.spellID;
if (!drawSpells.ContainsKey(spell.spellID))
{
drawSpells.Add(spellID, newSpell);
}
//var spellFlyTime = Evade.GetTickCount - spell.startTime;
if (spellHitTime < ObjectCache.menuCache.cache["SpellDetectionTime"].GetValue <Slider>().Value &&
!ObjectCache.menuCache.cache[spell.info.spellName + "FastEvade"].GetValue <bool>())
{
continue;
}
if (EvadeUtils.TickCount - spell.startTime < ObjectCache.menuCache.cache["ReactionTime"].GetValue <Slider>().Value &&
!ObjectCache.menuCache.cache[spell.info.spellName + "FastEvade"].GetValue <bool>())
{
continue;
}
var dodgeInterval = ObjectCache.menuCache.cache["DodgeInterval"].GetValue <Slider>().Value;
if (Evade.lastPosInfo != null && dodgeInterval > 0)
{
var timeElapsed = EvadeUtils.TickCount - Evade.lastPosInfo.timestamp;
if (dodgeInterval > timeElapsed && !ObjectCache.menuCache.cache[spell.info.spellName + "FastEvade"].GetValue <bool>())
{
//var delay = dodgeInterval - timeElapsed;
//DelayAction.Add((int)delay, () => SpellDetector_OnProcessDetectedSpells());
continue;
}
}
if (!spells.ContainsKey(spell.spellID))
{
if (!(Evade.isDodgeDangerousEnabled() && newSpell.GetSpellDangerLevel() < 3) &&
ObjectCache.menuCache.cache[newSpell.info.spellName + "DodgeSpell"].GetValue <bool>())
{
if (newSpell.spellType == SpellType.Circular &&
ObjectCache.menuCache.cache["DodgeCircularSpells"].GetValue <bool>() == false)
{
//return spellID;
continue;
}
if (myHero.HealthPercent <=
ObjectCache.menuCache.cache[spell.info.spellName + "DodgeIgnoreHP"].GetValue <Slider>()
.Value || !ObjectCache.menuCache.cache["DodgeCheckHP"].GetValue <bool>())
{
spells.Add(spellID, newSpell);
spellAdded = true;
}
}
}
if (ObjectCache.menuCache.cache["CheckSpellCollision"].GetValue <bool>() &&
spell.predictedEndPos != Vector2.Zero)
{
spellAdded = false;
}
}
}
if (spellAdded && OnProcessDetectedSpells != null)
{
OnProcessDetectedSpells();
}
}
public static float GetClosestDistanceApproach(Spell spell, Vector2 pos, float speed, float delay, Vector2 heroPos, float extraDist)
{
var walkDir = (pos - heroPos).Normalized();
if (spell.spellType == SpellType.Line && spell.info.projectileSpeed != float.MaxValue)
{
var spellPos = spell.GetCurrentSpellPosition(true, delay);
var spellStartPos = spell.currentSpellPosition;
var spellEndPos = spell.GetSpellEndPosition();
var extendedPos = pos.ExtendDir(walkDir, ObjectCache.myHeroCache.boundingRadius + speed * delay / 1000);
Vector2 cHeroPos;
Vector2 cSpellPos;
var cpa2 = MathUtils.GetCollisionDistanceEx(
heroPos, walkDir * speed, ObjectCache.myHeroCache.boundingRadius,
spellPos, spell.direction * spell.info.projectileSpeed, spell.radius + extraDist,
out cHeroPos, out cSpellPos);
var cHeroPosProjection = cHeroPos.ProjectOn(heroPos, extendedPos);
var cSpellPosProjection = cSpellPos.ProjectOn(spellPos, spellEndPos);
if (cSpellPosProjection.IsOnSegment && cHeroPosProjection.IsOnSegment && cpa2 != float.MaxValue)
{
return 0;
}
var cpa = MathUtilsCPA.CPAPointsEx(heroPos, walkDir * speed, spellPos, spell.direction * spell.info.projectileSpeed, pos, spellEndPos, out cHeroPos, out cSpellPos);
cHeroPosProjection = cHeroPos.ProjectOn(heroPos, extendedPos);
cSpellPosProjection = cSpellPos.ProjectOn(spellPos, spellEndPos);
var checkDist = ObjectCache.myHeroCache.boundingRadius + spell.radius + extraDist;
if (cSpellPosProjection.IsOnSegment && cHeroPosProjection.IsOnSegment)
{
return Math.Max(0, cpa - checkDist);
}
else
{
return checkDist;
}
//return MathUtils.ClosestTimeOfApproach(heroPos, walkDir * speed, spellPos, spell.direction * spell.info.projectileSpeed);
}
else if (spell.spellType == SpellType.Line && spell.info.projectileSpeed == float.MaxValue)
{
var spellHitTime = Math.Max(0, spell.endTime - EvadeUtils.TickCount - delay); //extraDelay
var walkRange = heroPos.Distance(pos);
var predictedRange = speed * (spellHitTime / 1000);
var tHeroPos = heroPos + walkDir * Math.Min(predictedRange, walkRange); //Hero predicted pos
var projection = tHeroPos.ProjectOn(spell.startPos, spell.endPos);
return Math.Max(0, tHeroPos.Distance(projection.SegmentPoint)
- (spell.radius + ObjectCache.myHeroCache.boundingRadius + extraDist)); //+ dodgeBuffer
}
else if (spell.spellType == SpellType.Circular)
{
var spellHitTime = Math.Max(0, spell.endTime - EvadeUtils.TickCount - delay); //extraDelay
var walkRange = heroPos.Distance(pos);
var predictedRange = speed * (spellHitTime / 1000);
var tHeroPos = heroPos + walkDir * Math.Min(predictedRange, walkRange); //Hero predicted pos
if (spell.info.spellName == "VeigarEventHorizon")
{
var wallRadius = 65;
var midRadius = spell.radius - wallRadius;
if (spellHitTime == 0)
{
return 0;
}
if (tHeroPos.Distance(spell.endPos) >= spell.radius)
{
return Math.Max(0, tHeroPos.Distance(spell.endPos) - midRadius - wallRadius);
}
else
{
return Math.Max(0, midRadius - tHeroPos.Distance(spell.endPos) - wallRadius);
}
}
var closestDist = Math.Max(0, tHeroPos.Distance(spell.endPos) - (spell.radius + extraDist));
if (spell.info.extraEndTime > 0 && closestDist != 0)
{
var remainingTime = Math.Max(0, spell.endTime + spell.info.extraEndTime - EvadeUtils.TickCount - delay);
var predictedRange2 = speed * (remainingTime / 1000);
var tHeroPos2 = heroPos + walkDir * Math.Min(predictedRange2, walkRange);
if (CheckMoveToDirection(tHeroPos, tHeroPos2))
{
return 0;
}
}
else
{
return closestDist;
}
}
else if (spell.spellType == SpellType.Arc)
{
var spellPos = spell.GetCurrentSpellPosition(true, delay);
var spellEndPos = spell.GetSpellEndPosition();
var pDir = spell.direction.Perpendicular();
spellPos = spellPos - pDir * spell.radius / 2;
spellEndPos = spellEndPos - pDir * spell.radius / 2;
var extendedPos = pos.ExtendDir(walkDir, ObjectCache.myHeroCache.boundingRadius);
Vector2 cHeroPos;
Vector2 cSpellPos;
var cpa = MathUtilsCPA.CPAPointsEx(heroPos, walkDir * speed, spellPos, spell.direction * spell.info.projectileSpeed, pos, spellEndPos, out cHeroPos, out cSpellPos);
var cHeroPosProjection = cHeroPos.ProjectOn(heroPos, extendedPos);
var cSpellPosProjection = cSpellPos.ProjectOn(spellPos, spellEndPos);
var checkDist = spell.radius + extraDist;
if (cHeroPos.InSkillShot(spell, ObjectCache.myHeroCache.boundingRadius))
{
if (cSpellPosProjection.IsOnSegment && cHeroPosProjection.IsOnSegment)
{
return Math.Max(0, cpa - checkDist);
}
else
{
return checkDist;
}
}
}
return 1;
}
public static void UseEvadeSpell()
{
if (!Situation.ShouldUseEvadeSpell())
{
return;
}
//int posDangerlevel = EvadeHelper.CheckPosDangerLevel(myHero.ServerPosition.To2D(), 0);
if (Evade.GetTickCount() - lastSpellEvadeCommand.timestamp < 1000)
{
return;
}
foreach (KeyValuePair <int, Spell> entry in SpellDetector.spells)
{
Spell spell = entry.Value;
if (ShouldActivateEvadeSpell(spell))
{
foreach (var evadeSpell in evadeSpells)
{
if (Evade.menu.SubMenu("EvadeSpells").SubMenu(evadeSpell.charName + evadeSpell.name + "EvadeSpellSettings")
.Item(evadeSpell.name + "UseEvadeSpell").GetValue <bool>() == false ||
GetSpellDangerLevel(evadeSpell) > spell.GetSpellDangerLevel() ||
(evadeSpell.isItem == false && !(myHero.Spellbook.CanUseSpell(evadeSpell.spellKey) == SpellState.Ready)) ||
(evadeSpell.isItem == true && !(Items.CanUseItem((int)evadeSpell.itemID))) ||
(evadeSpell.checkSpellName == true && myHero.Spellbook.GetSpell(evadeSpell.spellKey).Name != evadeSpell.spellName))
{
continue; //can't use spell right now
}
if (evadeSpell.evadeType == EvadeType.Blink)
{
if (evadeSpell.castType == CastType.Position)
{
var posInfo = EvadeHelper.GetBestPositionBlink();
if (posInfo != null)
{
EvadeCommand.CastSpell(evadeSpell, posInfo.position);
//Utility.DelayAction.Add(50, () => myHero.IssueOrder(GameObjectOrder.MoveTo, posInfo.position.To3D()));
}
}
else if (evadeSpell.castType == CastType.Target)
{
var posInfo = EvadeHelper.GetBestPositionTargetedDash(evadeSpell);
if (posInfo != null)
{
EvadeCommand.CastSpell(evadeSpell, posInfo.position);
//Utility.DelayAction.Add(50, () => myHero.IssueOrder(GameObjectOrder.MoveTo, posInfo.position.To3D()));
}
}
}
else if (evadeSpell.evadeType == EvadeType.Dash)
{
if (evadeSpell.castType == CastType.Position)
{
var posInfo = EvadeHelper.GetBestPositionDash(evadeSpell);
if (posInfo != null)
{
if (evadeSpell.isReversed)
{
var dir = (posInfo.position - myHero.ServerPosition.To2D()).Normalized();
var range = myHero.ServerPosition.To2D().Distance(posInfo.position);
var pos = myHero.ServerPosition.To2D() - dir * range;
posInfo.position = pos;
}
EvadeCommand.CastSpell(evadeSpell, posInfo.position);
//Utility.DelayAction.Add(50, () => myHero.IssueOrder(GameObjectOrder.MoveTo, posInfo.position.To3D()));
}
}
else if (evadeSpell.castType == CastType.Target)
{
var posInfo = EvadeHelper.GetBestPositionTargetedDash(evadeSpell);
if (posInfo != null)
{
EvadeCommand.CastSpell(evadeSpell, posInfo.position);
//Utility.DelayAction.Add(50, () => myHero.IssueOrder(GameObjectOrder.MoveTo, posInfo.position.To3D()));
}
}
}
else if (evadeSpell.evadeType == EvadeType.SpellShield)
{
if (evadeSpell.isItem)
{
Items.UseItem((int)evadeSpell.itemID);
}
else
{
EvadeCommand.CastSpell(evadeSpell);
}
}
return;
}
}
}
}