private void IssueTestMove(int recursionCount)
{
var movePos = ObjectCache.myHeroCache.serverPos2D;
Random rand = new Random();
lastRandomMoveCoeff = !lastRandomMoveCoeff;
if (lastRandomMoveCoeff)
{
movePos.X += 65 + rand.Next(0, 20);
}
else
{
movePos.X -= 65 + rand.Next(0, 20);
}
lastTestMoveToCommand = new EvadeCommand
{
order = EvadeOrderCommand.MoveTo,
targetPosition = movePos,
timestamp = EvadeUtils.TickCount,
isProcessed = false
};
Player.IssueOrder(GameObjectOrder.MoveTo, movePos.To3D(), true);
if (recursionCount > 1)
{
DelayAction.Add(500, () => IssueTestMove(recursionCount - 1));
}
}
private void ContinueLastBlockedCommand()
{
if (ObjectCache.menuCache.cache["ContinueMovement"].GetValue <bool>() &&
Situation.ShouldDodge())
{
var movePos = lastBlockedUserMoveTo.targetPosition;
var extraDelay = ObjectCache.menuCache.cache["ExtraPingBuffer"].GetValue <Slider>().Value;
if (isDodging == false && lastBlockedUserMoveTo.isProcessed == false &&
EvadeUtils.TickCount - lastEvadeCommand.timestamp > ObjectCache.gamePing + extraDelay &&
EvadeUtils.TickCount - lastBlockedUserMoveTo.timestamp < 1500)
{
movePos = movePos + (movePos - ObjectCache.myHeroCache.serverPos2D).Normalized()
* EvadeUtils.random.NextFloat(1, 65);
if (!EvadeHelper.CheckMovePath(movePos, ObjectCache.gamePing + extraDelay))
{
//Console.WriteLine("Continue Movement");
//myHero.IssueOrder(GameObjectOrder.MoveTo, movePos.To3D());
EvadeCommand.MoveTo(movePos);
lastBlockedUserMoveTo.isProcessed = true;
}
}
}
}
private void IssueTestMove(int recursionCount)
{
var movePos = ObjectCache.myHeroCache.serverPos2D;
Random rand = new Random();
lastRandomMoveCoeff = !lastRandomMoveCoeff;
if (lastRandomMoveCoeff)
{
movePos.X += 65 + rand.Next(0, 20);
}
else
{
movePos.X -= 65 + rand.Next(0, 20);
}
lastTestMoveToCommand = new EvadeCommand
{
order = EvadeOrderCommand.MoveTo,
targetPosition = movePos,
timestamp = EvadeUtils.TickCount,
isProcessed = false
};
myHero.IssueOrder(GameObjectOrder.MoveTo, movePos.To3D(), true);
if (recursionCount > 1)
{
DelayAction.Add(500, () => IssueTestMove(recursionCount - 1));
}
}
private void Game_OnCastSpell(Spellbook spellbook, SpellbookCastSpellEventArgs args)
{
if (!spellbook.Owner.IsMe)
{
return;
}
var sData = spellbook.GetSpell(args.Slot);
string name;
if (SpellDetector.channeledSpells.TryGetValue(sData.Name, out name))
{
//Evade.isChanneling = true;
//Evade.channelPosition = ObjectCache.myHeroCache.serverPos2D;
lastStopEvadeTime = EvadeUtils.TickCount + ObjectCache.gamePing + 100;
}
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 (Situation.ShouldDodge())
{
if (isDodging && SpellDetector.spells.Count() > 0)
{
foreach (KeyValuePair <String, SpellData> entry in SpellDetector.windupSpells)
{
SpellData 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)
{
lastPosInfo = PositionInfo.SetAllUndodgeable();
if (evadeSpell.evadeType == EvadeType.Blink ||
evadeSpell.evadeType == EvadeType.Dash)
{
DelayAction.Add(1, () => EvadeCommand.MoveTo(Game.CursorPos.To2D()));
}
return;
}
}
}
}
}
public static bool UseEkkoR(EvadeSpellData evadeSpell, bool process = true)
{
if ((from obj in ObjectManager.Get <Obj_AI_Minion>() where obj != null && obj.IsValid && !obj.IsDead && obj.Name == "Ekko" && obj.IsAlly select obj.ServerPosition.To2D()).Any(blinkPos => !blinkPos.CheckDangerousPos(10)))
{
EvadeSpell.CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell), process);
//DelayAction.Add(50, () => myHero.IssueOrder(GameObjectOrder.MoveTo, posInfo.position.To3D()));
return(true);
}
return(false);
}
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.CharData.BaseSkinName != "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(GameObjectOrder.MoveTo, posInfo.position.To3D()));
return(true);
}
}
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)
{
Vector2 blinkPos = obj.ServerPosition.To2D();
if (!blinkPos.CheckDangerousPos(10))
{
EvadeSpell.CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell), process);
//DelayAction.Add(50, () => EloBuddy.Player.IssueOrder(GameObjectOrder.MoveTo, posInfo.position.To3D()));
return(true);
}
}
}
return(false);
}
public static bool UseRappel(EvadeSpellData evadeSpell, bool process = true)
{
if (myHero.CharData.BaseSkinName != "Elise")
{
EvadeSpell.CastEvadeSpell(() => EvadeCommand.CastSpell(evadeSpell, myHero), process);
return(true);
}
if (myHero.CharData.BaseSkinName == "Elise")
{
if (myHero.Spellbook.CanUseSpell(SpellSlot.R) == SpellState.Ready)
{
myHero.Spellbook.CastSpell(SpellSlot.R);
}
}
return(false);
}
private void ContinueLastBlockedCommand()
{
if (ConfigValue.ContinueMovement.GetBool() && Situation.ShouldDodge())
{
var movePos = LastBlockedUserMoveTo.TargetPosition;
var extraDelay = Config.Properties.GetInt(ConfigValue.ExtraPingBuffer);
if (IsDodging == false && LastBlockedUserMoveTo.IsProcessed == false && EvadeUtils.TickCount - LastEvadeCommand.Timestamp > Game.Ping + extraDelay && EvadeUtils.TickCount - LastBlockedUserMoveTo.Timestamp < 1500)
{
movePos = movePos + (movePos - GameData.HeroInfo.ServerPos2D).Normalized() * EvadeUtils.Random.NextFloat(1, 65);
if (!EvadeHelper.CheckMovePath(movePos, Game.Ping + extraDelay))
{
//ConsoleDebug.WriteLine("Continue Movement");
//GameData.MyHero.IssueOrder(GameObjectOrder.MoveTo, movePos.To3D());
ConsoleDebug.WriteLineColor("Continuing Last Blocked Command", ConsoleColor.Yellow);
EvadeCommand.MoveTo(movePos);
LastBlockedUserMoveTo.IsProcessed = true;
}
}
}
}
private void Game_OnIssueOrder(Obj_AI_Base hero, GameObjectIssueOrderEventArgs args)
{
if (!hero.IsMe)
{
return;
}
if (!Situation.ShouldDodge())
{
return;
}
if (args.Order == GameObjectOrder.MoveTo)
{
//movement block code goes in here
if (isDodging && SpellDetector.spells.Count() > 0)
{
CheckHeroInDanger();
lastBlockedUserMoveTo = new EvadeCommand
{
order = EvadeOrderCommand.MoveTo,
targetPosition = args.TargetPosition.To2D(),
timestamp = GetTickCount(),
isProcessed = false,
};
args.Process = false; //Block the command
}
else
{
var movePos = args.TargetPosition.To2D();
var extraDelay = Evade.menu.SubMenu("MiscSettings").SubMenu("ExtraBuffers").Item("ExtraPingBuffer").GetValue <Slider>().Value;
if (EvadeHelper.CheckMovePath(movePos, Game.Ping + extraDelay))
{
args.Process = false; //Block the command
if (GetTickCount() - lastMovementBlockTime < 250 && lastMovementBlockPos.Distance(args.TargetPosition) < 100)
{
return;
}
lastMovementBlockPos = args.TargetPosition;
lastMovementBlockTime = GetTickCount();
var posInfo = EvadeHelper.GetBestPositionMovementBlock(movePos);
if (posInfo != null)
{
EvadeCommand.MoveTo(posInfo.position);
}
return;
}
}
}
else //need more logic
{
if (isDodging)
{
args.Process = false; //Block the command
}
}
}
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);
}
public static void UseEvadeSpell()
{
if (!Evade.menu.SubMenu("Main").Item("UseEvadeSpells").GetValue <bool>())
{
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 (!Evade.lastPosInfo.undodgeableSpells.Contains(spell.spellID))
{
continue;
}
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) > EvadeHelper.GetSpellDangerLevel(spell) ||
!(myHero.Spellbook.CanUseSpell(evadeSpell.spellKey) == SpellState.Ready))
{
continue; //can't use spell right now
}
if (evadeSpell.evadeType == EvadeType.Blink)
{
var posInfo = EvadeHelper.GetBestPositionBlink();
if (posInfo != null)
{
EvadeCommand.CastSpell(evadeSpell, posInfo.position);
}
}
else if (evadeSpell.evadeType == EvadeType.Dash)
{
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);
}
}
else if (evadeSpell.evadeType == EvadeType.SpellShield)
{
EvadeCommand.CastSpell(evadeSpell);
}
return;
}
}
}
private void DodgeSkillShots()
{
if (!Situation.ShouldDodge())
{
isDodging = false;
return;
}
/*
* if (isDodging && playerInDanger == false) //serverpos test
* {
* myHero.IssueOrder(GameObjectOrder.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));
* }*/
Vector2 lastBestPosition = lastPosInfo.position;
if (ObjectCache.menuCache.cache["ClickOnlyOnce"].GetValue <bool>() == false ||
!(myHero.Path.Count() > 0 && lastPosInfo.position.Distance(myHero.Path.Last().To2D()) < 5))
//|| lastPosInfo.timestamp > lastEvadeOrderTime)
{
EvadeCommand.MoveTo(lastBestPosition);
lastEvadeOrderTime = EvadeUtils.TickCount;
}
}
}
else //if not dodging
{
//Check if hero will walk into a skillshot
var path = myHero.Path;
if (path.Length > 0)
{
var movePos = path[path.Length - 1].To2D();
if (EvadeHelper.CheckMovePath(movePos))
{
/*if (ObjectCache.menuCache.cache["AllowCrossing"].GetValue<bool>())
* {
* var extraDelayBuffer = ObjectCache.menuCache.cache["ExtraPingBuffer"]
* .GetValue<Slider>().Value + 30;
* var extraDist = ObjectCache.menuCache.cache["ExtraCPADistance"]
* .GetValue<Slider>().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);
}
return;
}
}
}
}
private void Game_OnIssueOrder(Obj_AI_Base hero, PlayerIssueOrderEventArgs args)
{
if (!hero.IsMe)
{
return;
}
if (!Situation.ShouldDodge())
{
return;
}
if (args.Order == GameObjectOrder.MoveTo)
{
if (isDodging && SpellDetector.spells.Any())
{
CheckHeroInDanger();
lastBlockedUserMoveTo = new EvadeCommand
{
order = EvadeOrderCommand.MoveTo,
targetPosition = args.TargetPosition.To2D(),
timestamp = EvadeUtils.TickCount,
isProcessed = false,
};
args.Process = false;
}
else
{
var movePos = args.TargetPosition.To2D();
var extraDelay = ObjectCache.menuCache.cache["ExtraPingBuffer"].GetValue <Slider>().Value;
if (EvadeHelper.CheckMovePath(movePos, ObjectCache.gamePing + extraDelay))
{
/*if (ObjectCache.menuCache.cache["AllowCrossing"].GetValue<bool>())
* {
* var extraDelayBuffer = ObjectCache.menuCache.cache["ExtraPingBuffer"]
* .GetValue<Slider>().Value + 30;
* var extraDist = ObjectCache.menuCache.cache["ExtraCPADistance"]
* .GetValue<Slider>().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.TargetPosition.To2D(),
timestamp = EvadeUtils.TickCount,
isProcessed = false,
};
args.Process = false; //Block the command
if (EvadeUtils.TickCount - lastMovementBlockTime < 500 && lastMovementBlockPos.Distance(args.TargetPosition) < 100)
{
return;
}
lastMovementBlockPos = args.TargetPosition;
lastMovementBlockTime = EvadeUtils.TickCount;
var posInfo = EvadeHelper.GetBestPositionMovementBlock(movePos);
if (posInfo != null)
{
EvadeCommand.MoveTo(posInfo.position);
}
return;
}
else
{
lastBlockedUserMoveTo.isProcessed = true;
}
}
}
else //need more logic
{
if (isDodging)
{
args.Process = false; //Block the command
}
else
{
if (args.Order == GameObjectOrder.AttackUnit)
{
var target = args.Target;
if (target != null && target.IsValid <Obj_AI_Base>())
{
var baseTarget = target as Obj_AI_Base;
if (ObjectCache.myHeroCache.serverPos2D.Distance(baseTarget.ServerPosition.To2D()) >
myHero.AttackRange + ObjectCache.myHeroCache.boundingRadius + baseTarget.BoundingRadius)
{
var movePos = args.TargetPosition.To2D();
var extraDelay = ObjectCache.menuCache.cache["ExtraPingBuffer"].GetValue <Slider>().Value;
if (EvadeHelper.CheckMovePath(movePos, ObjectCache.gamePing + extraDelay))
{
args.Process = false; //Block the command
return;
}
}
}
}
}
}
if (args.Process == true)
{
lastIssueOrderGameTime = Game.Time * 1000;
lastIssueOrderTime = EvadeUtils.TickCount;
lastIssueOrderArgs = args;
if (args.Order == GameObjectOrder.MoveTo)
{
lastMoveToPosition = args.TargetPosition.To2D();
lastMoveToServerPos = myHero.ServerPosition.To2D();
}
if (args.Order == GameObjectOrder.Stop)
{
lastStopPosition = myHero.ServerPosition.To2D();
}
}
}
private void Game_OnCastSpell(Spellbook spellbook, SpellbookCastSpellEventArgs args) /////LOI DOAN NAY
{
if (!spellbook.Owner.IsMe)
{
return;
}
var sData = spellbook.GetSpell(args.Slot);
string name;
if (SpellDetector.channeledSpells.TryGetValue(sData.Name, out name))
{
//Evade.isChanneling = true;
//Evade.channelPosition = ObjectCache.myHeroCache.serverPos2D;
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();
* }*/
if (Situation.ShouldDodge())
{
if (isDodging && SpellDetector.spells.Any())
{
foreach (KeyValuePair <String, SpellData> entry in SpellDetector.windupSpells)
{
SpellData 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 dir = (args.StartPosition.To2D() - myHero.ServerPosition.To2D()).Normalized();
var end = myHero.ServerPosition.To2D() + dir * myHero.ServerPosition.To2D().Distance(Game.CursorPos.To2D());
if (evadeSpell.fixedRange || end.Distance(myHero.ServerPosition.To2D()) > evadeSpell.range)
{
end = myHero.ServerPosition.To2D() + dir * evadeSpell.range;
}
var posInfo = EvadeHelper.CanHeroWalkToPos(end, evadeSpell.speed, ObjectCache.gamePing, 0);
if (posInfo.posDangerCount < 1)
{
if (lastPosInfo != null)
{
lastPosInfo = posInfo;
}
if (lastPosInfo == null)
{
lastPosInfo = posInfo;
}
if (isDodging || EvadeUtils.TickCount < lastDodgingEndTime + 250)
{
EvadeCommand.MoveTo(Game.CursorPos.To2D());
lastStopEvadeTime = EvadeUtils.TickCount + ObjectCache.gamePing + 100;
}
return;
}
}
if (evadeSpell.evadeType == EvadeType.Dash)
{
var dashPos = args.StartPosition.To2D();
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.posDangerLevel > 0)
{
args.Process = false;
}
else
{
if (isDodging || EvadeUtils.TickCount < lastDodgingEndTime + 500)
{
EvadeCommand.MoveTo(Game.CursorPos.To2D());
lastStopEvadeTime = EvadeUtils.TickCount + ObjectCache.gamePing + 100;
}
return;
}
}
lastPosInfo = PositionInfo.SetAllUndodgeable();
return;
}
}
}
private void DodgeSkillShots()
{
if (!Situation.ShouldDodge())
{
isDodging = false;
return;
}
/*
* if (isDodging && playerInDanger == false) //serverpos test
* {
* myHero.IssueOrder(GameObjectOrder.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));
* }*/
Vector2 lastBestPosition = lastPosInfo.position;
if (ObjectCache.menuCache.cache["RecalculatePosition"].GetValue <bool>())//recheck path
{
var dodgeInterval = ObjectCache.menuCache.cache["DodgeInterval"].GetValue <Slider>().Value;
if (lastPosInfo != null && !lastPosInfo.recalculatedPath &&
dodgeInterval <= EvadeUtils.TickCount - lastPosInfo.timestamp)
{
var path = myHero.Path;
if (path.Length > 0)
{
var movePos = path[path.Length - 1].To2D();
if (movePos.Distance(lastPosInfo.position) < 5) //more strict checking
{
var posInfo = EvadeHelper.CanHeroWalkToPos(movePos, ObjectCache.myHeroCache.moveSpeed, 0, 0, false);
if (posInfo.isSamePosInfo(lastPosInfo) &&
posInfo.posDangerCount > lastPosInfo.posDangerCount)
{
var newPosInfo = EvadeHelper.GetBestPosition();
if (newPosInfo.posDangerCount < posInfo.posDangerCount)
{
lastPosInfo = newPosInfo;
CheckHeroInDanger();
}
else if (EvadeSpell.PreferEvadeSpell())
{
lastPosInfo = PositionInfo.SetAllUndodgeable();
}
else
{
lastPosInfo.recalculatedPath = true;
}
}
}
}
}
}
EvadeCommand.MoveTo(lastBestPosition);
if (Game.Time * 1000 - lastIssueOrderTime < 1)
{
DelayAction.Add(0, () => EvadeCommand.MoveTo(lastBestPosition));
}
}
}
else //if not dodging
{
//return;
//Check if hero will walk into a skillshot
var path = myHero.Path;
if (path.Length > 0)
{
var movePos = path[path.Length - 1].To2D();
if (EvadeHelper.CheckMovePath(movePos))
{
var posInfo = EvadeHelper.GetBestPositionMovementBlock(movePos);
if (posInfo != null)
{
EvadeCommand.MoveTo(posInfo.position);
if (Game.Time * 1000 - lastIssueOrderTime < 1)
{
DelayAction.Add(0, () => EvadeCommand.MoveTo(posInfo.position));
}
}
return;
}
}
}
}
private void Game_OnIssueOrder(Obj_AI_Base hero, GameObjectIssueOrderEventArgs args)
{
if (!hero.IsMe)
return;
if (!Situation.ShouldDodge())
return;
if (args.Order == GameObjectOrder.MoveTo)
{
//movement block code goes in here
if (isDodging && SpellDetector.spells.Count() > 0)
{
CheckHeroInDanger();
lastBlockedUserMoveTo = new EvadeCommand
{
order = EvadeOrderCommand.MoveTo,
targetPosition = args.TargetPosition.To2D(),
timestamp = EvadeUtils.TickCount,
isProcessed = false,
};
args.Process = false; //Block the command
}
else
{
var movePos = args.TargetPosition.To2D();
var extraDelay = ObjectCache.menuCache.cache["ExtraPingBuffer"].GetValue<Slider>().Value;
if (EvadeHelper.CheckMovePath(movePos, ObjectCache.gamePing + extraDelay))
{
lastBlockedUserMoveTo = new EvadeCommand
{
order = EvadeOrderCommand.MoveTo,
targetPosition = args.TargetPosition.To2D(),
timestamp = EvadeUtils.TickCount,
isProcessed = false,
};
args.Process = false; //Block the command
if (EvadeUtils.TickCount - lastMovementBlockTime < 500 && lastMovementBlockPos.Distance(args.TargetPosition) < 100)
{
return;
}
lastMovementBlockPos = args.TargetPosition;
lastMovementBlockTime = EvadeUtils.TickCount;
var posInfo = EvadeHelper.GetBestPositionMovementBlock(movePos);
if (posInfo != null)
{
EvadeCommand.MoveTo(posInfo.position);
}
return;
}
else
{
lastBlockedUserMoveTo.isProcessed = true;
}
}
}
else //need more logic
{
if (isDodging)
{
args.Process = false; //Block the command
}
else
{
if (args.Order == GameObjectOrder.AttackUnit)
{
var target = args.Target;
if (target != null && target.IsValid<Obj_AI_Base>())
{
var baseTarget = target as Obj_AI_Base;
if (ObjectCache.myHeroCache.serverPos2D.Distance(baseTarget.ServerPosition.To2D()) >
myHero.AttackRange + ObjectCache.myHeroCache.boundingRadius + baseTarget.BoundingRadius)
{
var movePos = args.TargetPosition.To2D();
var extraDelay = ObjectCache.menuCache.cache["ExtraPingBuffer"].GetValue<Slider>().Value;
if (EvadeHelper.CheckMovePath(movePos, ObjectCache.gamePing + extraDelay))
{
args.Process = false; //Block the command
return;
}
}
}
}
}
}
if (args.Process == true)
{
if (args.Order == GameObjectOrder.MoveTo)
{
lastIssueOrderTime = Game.Time * 1000;
lastIssueOrderArgs = args;
}
}
}
private void Game_OnCastSpell(Spellbook spellbook, SpellbookCastSpellEventArgs args)
{
if (!spellbook.Owner.IsMe)
{
return;
}
var sData = 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;
if (Situation.ShouldDodge())
{
if (isDodging && SpellDetector.spells.Count() > 0)
{
foreach (KeyValuePair <String, SpellData> entry in SpellDetector.windupSpells)
{
SpellData 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.Dash)
{
if (evadeSpell.evadeType == EvadeType.Dash)
{
var dashPos = args.StartPosition.LSTo2D(); //real pos?
if (args.Target != null)
{
dashPos = args.Target.Position.LSTo2D();
}
if (evadeSpell.fixedRange || dashPos.LSDistance(myHero.ServerPosition.LSTo2D()) > evadeSpell.range)
{
var dir = (dashPos - myHero.ServerPosition.LSTo2D()).LSNormalized();
dashPos = myHero.ServerPosition.LSTo2D() + dir * evadeSpell.range;
}
var posInfo = EvadeHelper.CanHeroWalkToPos(dashPos, evadeSpell.speed, ObjectCache.gamePing, 0);
if (posInfo.posDangerLevel > 0)
{
args.Process = false;
return;
}
}
lastPosInfo = PositionInfo.SetAllUndodgeable();
if (isDodging || EvadeUtils.TickCount < lastDodgingEndTime + 500)
{
EvadeCommand.MoveTo(Game.CursorPos.LSTo2D());
lastStopEvadeTime = EvadeUtils.TickCount + ObjectCache.gamePing + 100;
}
}
return;
}
}
}
private void DodgeSkillShots()
{
if (!Situation.ShouldDodge())
{
IsDodging = false;
return;
}
/*
* if (isDodging && playerInDanger == false) //serverpos test
* {
* GameData.MyHero.IssueOrder(GameObjectOrder.HoldPosition, myHero, false);
* }*/
if (IsDodging)
{
ConsoleDebug.WriteLineColor("Dodging Skill Shots by Ka", ConsoleColor.Green);
if (LastPosInfo != null)
{
/*foreach (KeyValuePair<int, Spell> entry in SpellDetector.spells)
* {
* Spell spell = entry.Value;
*
* ConsoleDebug.WriteLine("" + (int)(TickCount-spell.startTime));
* }*/
Vector2 lastBestPosition = LastPosInfo.Position;
if (!ConfigValue.ClickOnlyOnce.GetBool() || !(GameData.MyHero.Path.Length > 0 && LastPosInfo.Position.Distance(GameData.MyHero.Path.Last().To2D()) < 5))
//|| lastPosInfo.timestamp > lastEvadeOrderTime)
{
EvadeCommand.MoveTo(lastBestPosition);
LastEvadeOrderTime = EvadeUtils.TickCount;
}
}
}
else //if not dodging
{
//Check if hero will walk into a skillshot
var path = GameData.MyHero.Path;
if (path.Length > 0)
{
var movePos = path[path.Length - 1].To2D();
if (EvadeHelper.CheckMovePath(movePos))
{
/*if (() Properties.Properties.Data["AllowCrossing"].Cast<CheckBox>().CurrentValue)
* {
* var extraDelayBuffer = () Properties.Properties.Data["ExtraPingBuffer"]
+ 30;
+ var extraDist = () Properties.Properties.Data["ExtraCPADistance"]
+ 10;
+
+ var tPosInfo = EvadeHelper.CanHeroWalkToPos(movePos, GameData.HeroInfo.moveSpeed, extraDelayBuffer + Game.Ping, extraDist);
+
+ if (tPosInfo.posDangerLevel == 0)
+ {
+ lastPosInfo = tPosInfo;
+ return;
+ }
+ }*/
var posInfo = EvadeHelper.GetBestPositionMovementBlock(movePos);
if (posInfo != null)
{
EvadeCommand.MoveTo(posInfo.Position);
}
return;
}
}
}
}
private void Game_OnIssueOrder(Obj_AI_Base hero, PlayerIssueOrderEventArgs args)
{
if (!hero.IsMe)
{
return;
}
if (!Situation.ShouldDodge())
{
return;
}
//DebugIssueOrders(args);
if (args.Order == GameObjectOrder.MoveTo)
{
//movement block code goes in here
if (IsDodging && SpellDetector.Spells.Count > 0)
{
ConsoleDebug.WriteLineColor("Issue Order detected while spells exist", ConsoleColor.Yellow);
CheckHeroInDanger();
LastBlockedUserMoveTo = new EvadeCommand
{
Order = EvadeOrderCommand.MoveTo,
TargetPosition = args.TargetPosition.To2D(),
Timestamp = EvadeUtils.TickCount,
IsProcessed = false,
};
args.Process = false; //Block the command
ConsoleDebug.WriteLineColor(" Blocked Movement Command", ConsoleColor.Red);
}
else
{
var movePos = args.TargetPosition.To2D();
var extraDelay = Config.Properties.GetInt(ConfigValue.ExtraPingBuffer);
if (EvadeHelper.CheckMovePath(movePos, Game.Ping + extraDelay))
{
ConsoleDebug.WriteLineColor("Move Path is colliding with spell", ConsoleColor.Yellow);
/*if (() Properties.Properties.Data["AllowCrossing"].Cast<CheckBox>().CurrentValue)
* {
* var extraDelayBuffer = () Properties.Properties.Data["ExtraPingBuffer"]
+ 30;
+ var extraDist = () Properties.Properties.Data["ExtraCPADistance"]
+ 10;
+
+ var tPosInfo = EvadeHelper.CanHeroWalkToPos(movePos, GameData.HeroInfo.moveSpeed, extraDelayBuffer + Game.Ping, extraDist);
+
+ if (tPosInfo.posDangerLevel == 0)
+ {
+ lastPosInfo = tPosInfo;
+ return;
+ }
+ }*/
LastBlockedUserMoveTo = new EvadeCommand
{
Order = EvadeOrderCommand.MoveTo,
TargetPosition = args.TargetPosition.To2D(),
Timestamp = EvadeUtils.TickCount,
IsProcessed = false,
};
args.Process = false; //Block the command
ConsoleDebug.WriteLineColor(" Blocked Movement Command", ConsoleColor.Red);
if (EvadeUtils.TickCount - LastMovementBlockTime < 500 && LastMovementBlockPos.Distance(args.TargetPosition) < 100)
{
return;
}
LastMovementBlockPos = args.TargetPosition;
LastMovementBlockTime = EvadeUtils.TickCount;
var posInfo = EvadeHelper.GetBestPositionMovementBlock(movePos);
if (posInfo != null)
{
EvadeCommand.MoveTo(posInfo.Position);
}
return;
}
else
{
LastBlockedUserMoveTo.IsProcessed = true;
}
}
}
else //need more logic
{
if (IsDodging)
{
args.Process = false; //Block the command
ConsoleDebug.WriteLineColor(" Blocked IssueOrder(" + args.Order + ") Command", ConsoleColor.Red);
}
else
{
if (args.Order == GameObjectOrder.AttackUnit)
{
var target = args.Target;
if (target != null && target.GetType() == typeof(Obj_AI_Base))
{
var baseTarget = (Obj_AI_Base)target;
if (baseTarget.IsValid())
{
if (GameData.HeroInfo.ServerPos2D.Distance(baseTarget.ServerPosition.To2D()) > GameData.MyHero.AttackRange + GameData.HeroInfo.BoundingRadius + baseTarget.BoundingRadius)
{
var movePos = args.TargetPosition.To2D();
var extraDelay = Config.Properties.GetInt(ConfigValue.ExtraPingBuffer);
if (EvadeHelper.CheckMovePath(movePos, Game.Ping + extraDelay))
{
args.Process = false; //Block the command
ConsoleDebug.WriteLineColor(" Blocked Attack Unit Command", ConsoleColor.Red);
return;
}
}
}
}
}
}
}
if (args.Process == true)
{
LastIssueOrderGameTime = Game.Time * 1000;
LastIssueOrderTime = EvadeUtils.TickCount;
LastIssueOrderArgs = args;
if (args.Order == GameObjectOrder.MoveTo)
{
LastMoveToPosition = args.TargetPosition.To2D();
LastMoveToServerPos = GameData.MyHero.ServerPosition.To2D();
}
if (args.Order == GameObjectOrder.Stop)
{
LastStopPosition = GameData.MyHero.ServerPosition.To2D();
}
}
}
private void DodgeSkillShots()
{
if (!Situation.ShouldDodge())
{
isDodging = false;
return;
}
/*
* if (isDodging && playerInDanger == false) //serverpos test
* {
* myHero.IssueOrder(GameObjectOrder.HoldPosition, myHero, false);
* }*/
if (isDodging)
{
if (lastPosInfo != null)
{
/*foreach (KeyValuePair<int, Spell> entry in SpellDetector.spells)
* {
* Spell spell = entry.Value;
*
* Game.PrintChat("" + (int)(GetTickCount()-spell.startTime));
* }*/
Vector2 lastBestPosition = lastPosInfo.position;
if (menu.SubMenu("MiscSettings").Item("RecalculatePosition").GetValue <bool>())//recheck path
{
var path = myHero.Path;
if (path.Length > 0)
{
var movePos = path[path.Length - 1].To2D();
if (movePos.Distance(lastPosInfo.position) < 5) //more strict checking
{
var posInfo = EvadeHelper.CanHeroWalkToPos(movePos, myHero.MoveSpeed, 0, 0, false);
if (EvadeHelper.isSamePosInfo(posInfo, lastPosInfo) && posInfo.posDangerCount > lastPosInfo.posDangerCount)
{
var newPosInfo = EvadeHelper.GetBestPosition();
if (newPosInfo.posDangerCount < posInfo.posDangerCount)
{
lastPosInfo = newPosInfo;
CheckHeroInDanger();
}
else if (EvadeSpell.PreferEvadeSpell())
{
lastPosInfo = EvadeHelper.SetAllUndodgeable();
EvadeSpell.UseEvadeSpell(); //using spells)
}
}
}
}
}
EvadeCommand.MoveTo(lastBestPosition);
}
}
else //if not dodging
{
//Check if hero will walk into a skillshot
var path = myHero.Path;
if (path.Length > 0)
{
var movePos = path[path.Length - 1].To2D();
if (EvadeHelper.CheckMovePath(movePos))
{
var posInfo = EvadeHelper.GetBestPositionMovementBlock(movePos);
if (posInfo != null)
{
EvadeCommand.MoveTo(posInfo.position);
}
return;
}
}
}
}
private void Game_OnCastSpell(Spellbook spellbook, SpellbookCastSpellEventArgs args)
{
if (!spellbook.Owner.IsMe)
{
return;
}
var sData = spellbook.GetSpell(args.Slot);
string name;
if (SpellDetector.channeledSpells.TryGetValue(sData.Name, out name))
{
//Evade.isChanneling = true;
//Evade.channelPosition = ObjectCache.myHeroCache.serverPos2D;
lastStopEvadeTime = EvadeUtils.TickCount + ObjectCache.gamePing + 100;
}
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();
* }*/
if (Situation.ShouldDodge())
{
if (isDodging && SpellDetector.spells.Count() > 0)
{
foreach (KeyValuePair <String, SpellData> entry in SpellDetector.windupSpells)
{
SpellData 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)
{
if (evadeSpell.evadeType == EvadeType.Blink ||
evadeSpell.evadeType == EvadeType.Dash)
{
//Block spell cast if flashing/blinking into spells
if (args.EndPosition.To2D().CheckDangerousPos(6, true)) //for blink + dash
{
args.Process = false;
return;
}
if (evadeSpell.evadeType == EvadeType.Dash)
{
var extraDelayBuffer =
ObjectCache.menuCache.cache["ExtraPingBuffer"].Cast <Slider>().CurrentValue;
var extraDist = ObjectCache.menuCache.cache["ExtraCPADistance"].Cast <Slider>().CurrentValue;
var dashPos = Game.CursorPos.To2D(); //real pos?
if (evadeSpell.fixedRange)
{
var dir = (dashPos - myHero.ServerPosition.To2D()).Normalized();
dashPos = myHero.ServerPosition.To2D() + dir * evadeSpell.range;
}
//Draw.RenderObjects.Add(new Draw.RenderPosition(dashPos, 1000));
var posInfo = EvadeHelper.CanHeroWalkToPos(dashPos, evadeSpell.speed,
extraDelayBuffer + ObjectCache.gamePing, extraDist);
if (posInfo.posDangerLevel > 0)
{
args.Process = false;
return;
}
}
lastPosInfo = PositionInfo.SetAllUndodgeable(); //really?
if (isDodging || EvadeUtils.TickCount < lastDodgingEndTime + 500)
{
EvadeCommand.MoveTo(Game.CursorPos.To2D()); //block moveto
lastStopEvadeTime = EvadeUtils.TickCount + ObjectCache.gamePing + 100;
}
}
return;
}
}
}
private void Game_OnIssueOrder(Obj_AI_Base hero, GameObjectIssueOrderEventArgs args)
{
if (!hero.IsMe)
{
return;
}
if (!Situation.ShouldDodge())
{
return;
}
if (args.Order == GameObjectOrder.MoveTo)
{
//movement block code goes in here
if (isDodging && SpellDetector.spells.Count() > 0)
{
CheckHeroInDanger();
lastBlockedUserMoveTo = new EvadeCommand
{
order = EvadeOrderCommand.MoveTo,
targetPosition = args.TargetPosition.To2D(),
timestamp = EvadeUtils.TickCount,
isProcessed = false,
};
args.Process = false; //Block the command
}
else
{
var movePos = args.TargetPosition.To2D();
var extraDelay = ObjectCache.menuCache.cache["ExtraPingBuffer"].GetValue <Slider>().Value;
if (EvadeHelper.CheckMovePath(movePos, ObjectCache.gamePing + extraDelay))
{
lastBlockedUserMoveTo = new EvadeCommand
{
order = EvadeOrderCommand.MoveTo,
targetPosition = args.TargetPosition.To2D(),
timestamp = EvadeUtils.TickCount,
isProcessed = false,
};
args.Process = false; //Block the command
if (EvadeUtils.TickCount - lastMovementBlockTime < 500 && lastMovementBlockPos.Distance(args.TargetPosition) < 100)
{
return;
}
lastMovementBlockPos = args.TargetPosition;
lastMovementBlockTime = EvadeUtils.TickCount;
var posInfo = EvadeHelper.GetBestPositionMovementBlock(movePos);
if (posInfo != null)
{
EvadeCommand.MoveTo(posInfo.position);
}
return;
}
else
{
lastBlockedUserMoveTo.isProcessed = true;
}
}
}
else //need more logic
{
if (isDodging)
{
args.Process = false; //Block the command
}
else
{
if (args.Order == GameObjectOrder.AttackUnit)
{
var target = args.Target;
if (target != null && target.IsValid <Obj_AI_Base>())
{
var baseTarget = target as Obj_AI_Base;
if (ObjectCache.myHeroCache.serverPos2D.Distance(baseTarget.ServerPosition.To2D()) >
myHero.AttackRange + ObjectCache.myHeroCache.boundingRadius + baseTarget.BoundingRadius)
{
var movePos = args.TargetPosition.To2D();
var extraDelay = ObjectCache.menuCache.cache["ExtraPingBuffer"].GetValue <Slider>().Value;
if (EvadeHelper.CheckMovePath(movePos, ObjectCache.gamePing + extraDelay))
{
args.Process = false; //Block the command
return;
}
}
}
}
}
}
if (args.Process == true)
{
lastIssueOrderTime = Game.Time * 1000;
}
}
private void Game_OnIssueOrder(Obj_AI_Base hero, PlayerIssueOrderEventArgs args)
{
if (!hero.IsMe)
return;
if (!Situation.ShouldDodge())
return;
if (args.Order == GameObjectOrder.MoveTo)
{
//movement block code goes in here
if (isDodging && SpellDetector.spells.Count() > 0)
{
CheckHeroInDanger();
lastBlockedUserMoveTo = new EvadeCommand
{
order = EvadeOrderCommand.MoveTo,
targetPosition = args.TargetPosition.To2D(),
timestamp = EvadeUtils.TickCount,
isProcessed = false,
};
args.Process = false; //Block the command
}
else
{
var movePos = args.TargetPosition.To2D();
var extraDelay = ObjectCache.menuCache.cache["ExtraPingBuffer"].Cast<Slider>().CurrentValue;
if (EvadeHelper.CheckMovePath(movePos, ObjectCache.gamePing + extraDelay))
{
/*if (ObjectCache.menuCache.cache["AllowCrossing"].Cast<CheckBox>().CurrentValue)
{
var extraDelayBuffer = ObjectCache.menuCache.cache["ExtraPingBuffer"]
.Cast<Slider>().CurrentValue + 30;
var extraDist = ObjectCache.menuCache.cache["ExtraCPADistance"]
.Cast<Slider>().CurrentValue + 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.TargetPosition.To2D(),
timestamp = EvadeUtils.TickCount,
isProcessed = false,
};
args.Process = false; //Block the command
if (EvadeUtils.TickCount - lastMovementBlockTime < 500 &&
lastMovementBlockPos.Distance(args.TargetPosition) < 100)
{
return;
}
lastMovementBlockPos = args.TargetPosition;
lastMovementBlockTime = EvadeUtils.TickCount;
var posInfo = EvadeHelper.GetBestPositionMovementBlock(movePos);
if (posInfo != null)
{
EvadeCommand.MoveTo(posInfo.position);
}
return;
}
else
{
lastBlockedUserMoveTo.isProcessed = true;
}
}
}
else //need more logic
{
if (isDodging)
{
args.Process = false; //Block the command
}
else
{
if (args.Order == GameObjectOrder.AttackUnit)
{
var target = args.Target;
if (target != null && target.GetType() == typeof(Obj_AI_Base) && ((Obj_AI_Base) target).IsValid())
{
var baseTarget = target as Obj_AI_Base;
if (ObjectCache.myHeroCache.serverPos2D.Distance(baseTarget.ServerPosition.To2D()) >
myHero.AttackRange + ObjectCache.myHeroCache.boundingRadius + baseTarget.BoundingRadius)
{
var movePos = args.TargetPosition.To2D();
var extraDelay = ObjectCache.menuCache.cache["ExtraPingBuffer"].Cast<Slider>().CurrentValue;
if (EvadeHelper.CheckMovePath(movePos, ObjectCache.gamePing + extraDelay))
{
args.Process = false; //Block the command
return;
}
}
}
}
}
}
if (args.Process == true)
{
lastIssueOrderGameTime = Game.Time*1000;
lastIssueOrderTime = EvadeUtils.TickCount;
lastIssueOrderArgs = args;
if (args.Order == GameObjectOrder.MoveTo)
{
lastMoveToPosition = args.TargetPosition.To2D();
lastMoveToServerPos = myHero.ServerPosition.To2D();
}
if (args.Order == GameObjectOrder.Stop)
{
lastStopPosition = myHero.ServerPosition.To2D();
}
}
}
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;
}
}
}
}
