public static bool UseBrokenWings(EvadeSpellData evadeSpell, bool process = false)
{
var posInfo = EvadeHelper.GetBestPositionDash(evadeSpell);
if (posInfo != null)
{
EvadeCommand.MoveTo(posInfo.position);
DelayAction.Add(50, () => EvadeSpell.CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell), process));
return(true);
}
return(false);
}
public static bool UsePounce(EvadeSpellData evadeSpell, bool process = true)
{
if (myHero.UnitSkinName != "Nidalee")
{
var posInfo = EvadeHelper.GetBestPositionDash(evadeSpell);
if (posInfo != null)
{
EvadeSpell.CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell), process);
return(true);
}
}
return(false);
}
public static bool UseEkkoE2(EvadeSpellData evadeSpell, bool process = true)
{
if (myHero.HasBuff("ekkoeattackbuff"))
{
var posInfo = EvadeHelper.GetBestPositionTargetedDash(evadeSpell);
if (posInfo != null && posInfo.target != null)
{
EvadeSpell.CastEvadeSpell(() => EvadeCommand.Attack(evadeSpell, posInfo.target), process);
//DelayAction.Add(50, () => myHero.IssueOrder(OrderType.MoveTo, posInfo.position.To3D()));
return(true);
}
}
return(false);
}
public static bool UseRappel(EvadeSpellData evadeSpell, bool process = true)
{
if (myHero.UnitSkinName != "Elise")
{
EvadeSpell.CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, myHero), process);
return(true);
}
if (myHero.UnitSkinName == "Elise")
{
if (myHero.SpellBook.CanUseSpell(SpellSlot.R))
{
myHero.SpellBook.CastSpell(SpellSlot.R);
}
}
return(false);
}
public static bool UseEkkoR(EvadeSpellData evadeSpell, bool process = true)
{
foreach (var obj in ObjectManager.Get <Obj_AI_Minion>())
{
if (obj != null && obj.IsValid && !obj.IsDead && obj.Name == "Ekko" && obj.IsAlly)
{
var blinkPos = obj.ServerPosition.To2D();
if (!blinkPos.CheckDangerousPos(10))
{
EvadeSpell.CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell), process);
//DelayAction.Add(50, () => myHero.IssueOrder(OrderType.MoveTo, posInfo.position.To3D()));
return(true);
}
}
}
return(false);
}
private void DodgeSkillShots()
{
if (!Situation.ShouldDodge())
{
isDodging = false;
return;
}
/*
* if (isDodging && playerInDanger == false) //serverpos test
* {
* myHero.IssueOrder(OrderType.HoldPosition, myHero, false);
* }*/
if (isDodging)
{
if (lastPosInfo != null)
{
/*foreach (KeyValuePair<int, Spell> entry in SpellDetector.spells)
* {
* Spell spell = entry.Value;
*
* Console.WriteLine("" + (int)(TickCount-spell.startTime));
* }*/
var lastBestPosition = lastPosInfo.position;
if (ObjectCache.menuCache.cache["ClickOnlyOnce"].As <MenuBool>().Value == false ||
!(myHero.Path.Count() > 0 && lastPosInfo.position.Distance(myHero.Path.Last().To2D()) < 5))
//|| lastPosInfo.timestamp > lastEvadeOrderTime)
{
// Console.WriteLine("DodgeSkillshots");
EvadeCommand.MoveTo(lastBestPosition);
lastEvadeOrderTime = EvadeUtils.TickCount;
}
}
}
else //if not dodging
{
//Check if hero will walk into a skillshot
var path = myHero.Path;
//if (path == null)
// return;
if (path.Length > 0)
{
var movePos = path[path.Length - 1].To2D();
if (EvadeHelper.CheckMovePath(movePos))
{
/*if (ObjectCache.menuCache.cache["AllowCrossing"].As<MenuBool>().Enabled)
* {
* var extraDelayBuffer = ObjectCache.menuCache.cache["ExtraPingBuffer"]
* .As<MenuSlider>().Value + 30;
* var extraDist = ObjectCache.menuCache.cache["ExtraCPADistance"]
* .As<MenuSlider>().Value + 10;
*
* var tPosInfo = EvadeHelper.CanHeroWalkToPos(movePos, ObjectCache.myHeroCache.moveSpeed, extraDelayBuffer + ObjectCache.gamePing, extraDist);
*
* if (tPosInfo.posDangerLevel == 0)
* {
* lastPosInfo = tPosInfo;
* return;
* }
* }*/
var posInfo = EvadeHelper.GetBestPositionMovementBlock(movePos);
if (posInfo != null)
{
EvadeCommand.MoveTo(posInfo.position);
}
}
}
}
}
private void Game_OnIssueOrder(Obj_AI_Base hero, Obj_AI_BaseIssueOrderEventArgs args)
{
if (!hero.IsMe)
{
return;
}
if (!Situation.ShouldDodge())
{
return;
}
//if (args.OrderType == OrderType.MoveTo)
//{
// var end = args.Position;
// var path = myHero.Path;
// Console.WriteLine("got path");
//}
if (args.OrderType == OrderType.MoveTo)
{
if (isDodging && SpellDetector.spells.Any())
{
var limitDelay = ObjectCache.menuCache.cache["TickLimiter"].As <MenuSlider>(); //Tick limiter
if (EvadeUtils.TickCount - lastTickCount < limitDelay.Value)
{
lastTickCount = EvadeUtils.TickCount;
args.ProcessEvent = false;
return;
}
CheckHeroInDanger();
lastBlockedUserMoveTo = new EvadeCommand
{
// fix all the args.Target.Position / args.Position
order = EvadeOrderCommand.MoveTo,
targetPosition = args /*.Target*/.Position.To2D(), // NOT SURE IF POSITION OR TARGET.POSITION
timestamp = EvadeUtils.TickCount,
isProcessed = false
};
//args.ProcessEvent = true;
args.ProcessEvent = false;
}
else
{
var movePos = args.Position.To2D();
var extraDelay = ObjectCache.menuCache.cache["ExtraPingBuffer"].As <MenuSlider>().Value;
if (EvadeHelper.CheckMovePath(movePos, ObjectCache.gamePing + extraDelay))
{
/*if (ObjectCache.menuCache.cache["AllowCrossing"].As<MenuBool>().Enabled)
* {
* var extraDelayBuffer = ObjectCache.menuCache.cache["ExtraPingBuffer"]
* .As<MenuSlider>().Value + 30;
* var extraDist = ObjectCache.menuCache.cache["ExtraCPADistance"]
* .As<MenuSlider>().Value + 10;
* var tPosInfo = EvadeHelper.CanHeroWalkToPos(movePos, ObjectCache.myHeroCache.moveSpeed, extraDelayBuffer + ObjectCache.gamePing, extraDist);
* if (tPosInfo.posDangerLevel == 0)
* {
* lastPosInfo = tPosInfo;
* return;
* }
* }*/
lastBlockedUserMoveTo = new EvadeCommand
{
order = EvadeOrderCommand.MoveTo,
targetPosition = args /*.Target*/.Position.To2D(),
timestamp = EvadeUtils.TickCount,
isProcessed = false
};
args.ProcessEvent = false; //Block the command
// args.ProcessEvent = true;
if (EvadeUtils.TickCount - lastMovementBlockTime < 500 &&
lastMovementBlockPos.Distance(args./*Target.*/ Position) < 100)
{
return;
}
lastMovementBlockPos = args./*Target.*/ Position;
lastMovementBlockTime = EvadeUtils.TickCount;
var posInfo = EvadeHelper.GetBestPositionMovementBlock(movePos);
if (posInfo != null)
{
EvadeCommand.MoveTo(posInfo.position);
}
return;
}
lastBlockedUserMoveTo.isProcessed = true;
}
}
else //need more logic
{
if (isDodging)
{
args.ProcessEvent = false; //Block the command
}
else
{
if (args.OrderType == OrderType.AttackUnit)
{
var target = args.Target;
if (target != null && target.IsValid)
{
// fix
var baseTarget = target as Obj_AI_Base;
if (baseTarget != null &&
ObjectCache.myHeroCache.serverPos2D.Distance(baseTarget.ServerPosition.To2D()) >
myHero.AttackRange + ObjectCache.myHeroCache.boundingRadius + baseTarget.BoundingRadius)
{
var movePos = args /*.Target*/.Position.To2D();
var extraDelay = ObjectCache.menuCache.cache["ExtraPingBuffer"].As <MenuSlider>().Value;
if (EvadeHelper.CheckMovePath(movePos, ObjectCache.gamePing + extraDelay))
{
args.ProcessEvent = false; //Block the command
return;
}
}
}
}
}
}
if (args.ProcessEvent)
{
lastIssueOrderGameTime = Game.ClockTime * 1000;
lastIssueOrderTime = EvadeUtils.TickCount;
lastIssueOrderArgs = args;
if (args.OrderType == OrderType.MoveTo)
{
lastMoveToPosition = args /*.Target*/.Position.To2D();
lastMoveToServerPos = myHero.ServerPosition.To2D();
}
if (args.OrderType == OrderType.Stop)
{
lastStopPosition = myHero.ServerPosition.To2D();
}
}
}
private void Game_OnCastSpell(Obj_AI_Base sender, SpellBookCastSpellEventArgs args)
{
if (!sender.IsMe)
{
return;
}
var sData = sender.SpellBook.GetSpell(args.Slot);
string name;
if (SpellDetector.channeledSpells.TryGetValue(sData.Name, out name))
{
lastStopEvadeTime = EvadeUtils.TickCount + ObjectCache.gamePing + 100;
}
//block spell commmands if evade spell just used
if (EvadeSpell.lastSpellEvadeCommand != null &&
EvadeSpell.lastSpellEvadeCommand.timestamp + ObjectCache.gamePing + 150 > EvadeUtils.TickCount)
{
args.Process = false;
}
lastSpellCast = args.Slot;
lastSpellCastTime = EvadeUtils.TickCount;
//moved from processPacket
/*if (args.Slot == SpellSlot.Recall)
* {
* lastStopPosition = myHero.ServerPosition.To2D();
* }*/
// fix : uncomment all
if (Situation.ShouldDodge())
{
if (isDodging && SpellDetector.spells.Any())
{
foreach (var entry in SpellDetector.windupSpells)
{
var spellData = entry.Value;
if (spellData.spellKey == args.Slot) //check if it's a spell that we should block
{
args.Process = false;
return;
}
}
}
}
foreach (var evadeSpell in EvadeSpell.evadeSpells)
{
if (evadeSpell.isItem == false && evadeSpell.spellKey == args.Slot &&
evadeSpell.untargetable == false)
{
if (evadeSpell.evadeType == EvadeType.Blink)
{
var blinkPos = args.Start.To2D();
var posInfo = EvadeHelper.CanHeroWalkToPos(blinkPos, evadeSpell.speed, ObjectCache.gamePing, 0);
if (posInfo != null && posInfo.posDangerLevel == 0)
{
//Console.WriteLine("Evade spell");
EvadeCommand.MoveTo(posInfo.position);
lastStopEvadeTime = EvadeUtils.TickCount + ObjectCache.gamePing + evadeSpell.spellDelay;
}
}
if (evadeSpell.evadeType == EvadeType.Dash)
{
var dashPos = args.Start.To2D();
// fix : uncommont .target
if (args.Target != null)
{
dashPos = args.Target.Position.To2D();
}
if (evadeSpell.fixedRange || dashPos.Distance(myHero.ServerPosition.To2D()) > evadeSpell.range)
{
var dir = (dashPos - myHero.ServerPosition.To2D()).Normalized();
dashPos = myHero.ServerPosition.To2D() + dir * evadeSpell.range;
}
var posInfo = EvadeHelper.CanHeroWalkToPos(dashPos, evadeSpell.speed, ObjectCache.gamePing, 0);
if (posInfo != null && posInfo.posDangerLevel > 0)
{
args.Process = false;
return;
}
if (isDodging || EvadeUtils.TickCount < lastDodgingEndTime + 500)
{
//Console.WriteLine("Evade Spell 2");
EvadeCommand.MoveTo(Game.CursorPos.To2D());
lastStopEvadeTime = EvadeUtils.TickCount + ObjectCache.gamePing + 100;
}
}
return;
}
}
}
public static bool ActivateEvadeSpell(Spell spell, bool checkSpell = false)
{
if (spell.info.spellName.Contains("_trap"))
{
return(false);
}
var sortedEvadeSpells = evadeSpells.OrderBy(s => s.dangerlevel);
var extraDelayBuffer = ObjectCache.menuCache.cache["ExtraPingBuffer"].As <MenuSlider>().Value;
var spellActivationTime = ObjectCache.menuCache.cache["SpellActivationTime"].As <MenuSlider>().Value +
ObjectCache.gamePing + extraDelayBuffer;
if (ObjectCache.menuCache.cache["CalculateWindupDelay"].As <MenuBool>().Enabled)
{
var extraWindupDelay = Evade.lastWindupTime - EvadeUtils.TickCount;
if (extraWindupDelay > 0)
{
return(false);
}
}
foreach (var evadeSpell in sortedEvadeSpells)
{
var processSpell = true;
if (Evade.evadeSpellMenu[evadeSpell.charName + evadeSpell.name + "EvadeSpellSettings"][
evadeSpell.name + "UseEvadeSpell"].As <MenuBool>().Value == false ||
GetSpellDangerLevel(evadeSpell) > spell.GetSpellDangerLevel() ||
!myHero.SpellBook.CanUseSpell(evadeSpell.spellKey) || evadeSpell.checkSpellName &&
myHero.SpellBook.GetSpell(evadeSpell.spellKey).Name != evadeSpell.spellName)
{
continue; //can't use spell right now
}
float evadeTime, spellHitTime;
spell.CanHeroEvade(myHero, out evadeTime, out spellHitTime);
var finalEvadeTime = spellHitTime - evadeTime;
if (checkSpell)
{
var mode =
Evade.evadeSpellMenu[evadeSpell.charName + evadeSpell.name + "EvadeSpellSettings"][
evadeSpell.name + "EvadeSpellMode"]
.As <MenuList>().Value;
if (mode == 0)
{
continue;
}
if (mode == 1)
{
if (spellActivationTime < finalEvadeTime)
{
continue;
}
}
}
else
{
//if (Evade.menu[evadeSpell.name + "LastResort"].As<MenuBool>().Enabled)
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"].As <MenuSlider>().Value)
{
processSpell = false;
if (checkSpell == false)
{
continue;
}
}
if (evadeSpell.isSpecial)
{
if (evadeSpell.useSpellFunc != null)
{
if (evadeSpell.useSpellFunc(evadeSpell, processSpell))
{
return(true);
}
}
}
else if (evadeSpell.evadeType == EvadeType.Blink)
{
if (evadeSpell.castType == CastType.Position)
{
var posInfo = EvadeHelper.GetBestPositionBlink();
if (posInfo != null)
{
if (processSpell)
{
myHero.SpellBook.CastSpell(evadeSpell.spellKey, posInfo.position.To3D());
}
//CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, posInfo.position), processSpell);
//DelayAction.Add(50, () => myHero.IssueOrder(OrderType.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)
{
if (processSpell)
{
myHero.SpellBook.CastSpell(evadeSpell.spellKey, posInfo.target);
}
//CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, posInfo.target), processSpell);
//DelayAction.Add(50, () => myHero.IssueOrder(OrderType.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;
}
if (processSpell)
{
myHero.SpellBook.CastSpell(evadeSpell.spellKey, posInfo.position.To3D());
}
//DelayAction.Add(50, () => myHero.IssueOrder(OrderType.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)
{
if (processSpell)
{
myHero.SpellBook.CastSpell(evadeSpell.spellKey, posInfo.target);
}
//CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, posInfo.target), processSpell);
//DelayAction.Add(50, () => myHero.IssueOrder(OrderType.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;
if (processSpell)
{
myHero.SpellBook.CastSpell(evadeSpell.spellKey, pos.To3D());
}
//CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, pos), processSpell);
return(true);
}
}
else if (evadeSpell.evadeType == EvadeType.SpellShield)
{
if (evadeSpell.isItem)
{
if (processSpell)
{
myHero.SpellBook.CastSpell(evadeSpell.spellKey);
}
//CastEvadeSpell(() => myHero.SpellBook.CastSpell(evadeSpell.spellKey), processSpell);
return(true);
}
if (evadeSpell.castType == CastType.Target)
{
if (processSpell)
{
myHero.SpellBook.CastSpell(evadeSpell.spellKey, myHero);
}
// CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, myHero), processSpell);
return(true);
}
if (evadeSpell.castType == CastType.Self)
{
if (processSpell)
{
myHero.SpellBook.CastSpell(evadeSpell.spellKey);
}
//CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell), processSpell);
return(true);
}
}
else if (evadeSpell.evadeType == EvadeType.MovementSpeedBuff)
{
if (evadeSpell.isItem)
{
var posInfo = EvadeHelper.GetBestPosition();
if (posInfo != null)
{
if (processSpell)
{
myHero.SpellBook.CastSpell(evadeSpell.spellKey);
}
//CastEvadeSpell(() => myHero.SpellBook.CastSpell(evadeSpell.spellKey), processSpell);
DelayAction.Add(5, () => EvadeCommand.MoveTo(posInfo.position));
return(true);
}
}
else
{
if (evadeSpell.castType == CastType.Self)
{
var posInfo = EvadeHelper.GetBestPosition();
if (posInfo != null)
{
if (processSpell)
{
myHero.SpellBook.CastSpell(evadeSpell.spellKey);
}
//CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell), processSpell);
DelayAction.Add(5, () => EvadeCommand.MoveTo(posInfo.position));
return(true);
}
}
else if (evadeSpell.castType == CastType.Position)
{
var posInfo = EvadeHelper.GetBestPosition();
if (posInfo != null)
{
if (processSpell)
{
myHero.SpellBook.CastSpell(evadeSpell.spellKey, posInfo.position.To3D());
}
//CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, posInfo.position), processSpell);
DelayAction.Add(5, () => EvadeCommand.MoveTo(posInfo.position));
return(true);
}
}
}
}
}
return(false);
}