public static void UpdateSpellInfo(this Spell spell)
{
spell.currentSpellPosition = spell.GetCurrentSpellPosition();
spell.currentNegativePosition = spell.GetCurrentSpellPosition(true, 0);
spell.dangerlevel = spell.GetSpellDangerLevel();
if (spell.info.name == "TaricE")
{
var taric = HeroManager.Enemies.FirstOrDefault(x => x.ChampionName == "Taric");
if (taric != null)
{
spell.currentSpellPosition = taric.ServerPosition.To2D();
spell.endPos = taric.ServerPosition.To2D() + spell.direction * spell.info.range;
}
}
if (spell.info.name == "TaricE2")
{
var partner = HeroManager.Enemies.FirstOrDefault(x => x.HasBuff("taricwleashactive") && x.ChampionName != "Taric");
if (partner != null)
{
spell.currentSpellPosition = partner.ServerPosition.To2D();
spell.endPos = partner.ServerPosition.To2D() + spell.direction * spell.info.range;
}
}
}
public static void UpdateSpellInfo(this Spell spell)
{
spell.currentSpellPosition = spell.GetCurrentSpellPosition();
spell.currentNegativePosition = spell.GetCurrentSpellPosition(true, 0);
spell.dangerlevel = spell.GetSpellDangerLevel();
//spell.radius = spell.GetSpellRadius();
}
private static void AddDetectedSpells()
{
bool spellAdded = false;
foreach (KeyValuePair <int, Spell> entry in detectedSpells)
{
Spell spell = entry.Value;
float evadeTime, spellHitTime;
spell.CanHeroEvade(myHero, out evadeTime, out spellHitTime);
spell.spellHitTime = spellHitTime;
spell.evadeTime = evadeTime;
if (spell.spellHitTime - spell.evadeTime < 1500 && CanHeroWalkIntoSpell(spell))
{
Spell newSpell = spell;
int spellID = spell.spellID;
if (!drawSpells.ContainsKey(spell.spellID))
{
drawSpells.Add(spellID, newSpell);
}
if (!spells.ContainsKey(spell.spellID))
{
if (!(Evade.isDodgeDangerousEnabled() && newSpell.GetSpellDangerLevel() < 3) &&
Evade.menu.SubMenu("Spells").SubMenu(newSpell.info.charName + newSpell.info.spellName + "Settings")
.Item(newSpell.info.spellName + "DodgeSpell").GetValue <bool>())
{
if (newSpell.info.spellType == SpellType.Circular &&
Evade.menu.SubMenu("Main").Item("DodgeCircularSpells").GetValue <bool>() == false)
{
//return spellID;
continue;
}
spells.Add(spellID, newSpell);
spellAdded = true;
}
}
}
}
if (spellAdded && OnProcessDetectedSpells != null)
{
OnProcessDetectedSpells();
}
}
public static string GetSpellDangerString(this Spell spell)
{
switch (spell.GetSpellDangerLevel())
{
case 1:
return("Low");
case 3:
return("High");
case 4:
return("Extreme");
default:
return("Normal");
}
}
public static string GetSpellDangerString(this Spell spell)
{
switch (spell.GetSpellDangerLevel())
{
case 1:
return("\u4f4e");
case 3:
return("\u9ad8");
case 4:
return("\u975e\u5e38\u9ad8");
default:
return("\u6b63\u5e38");
}
}
public static bool PreferEvadeSpell()
{
if (!Situation.ShouldUseEvadeSpell())
{
return(false);
}
var extraDelayBuffer = Evade.menu.Item("ExtraPingBuffer").GetValue <Slider>().Value;
float fastEvadeTime = Evade.menu.Item("SpellActivationTime").GetValue <Slider>().Value + Game.Ping + extraDelayBuffer;
foreach (KeyValuePair <int, Spell> entry in SpellDetector.spells)
{
Spell spell = entry.Value;
if (!EvadeHelper.InSkillShot(spell, myHero.ServerPosition.To2D(), myHero.BoundingRadius))
{
continue;
}
float rEvadeTime, rSpellHitTime = 0;
spell.CanHeroEvade(myHero, out rEvadeTime, out rSpellHitTime);
float finalEvadeTime = (rSpellHitTime - rEvadeTime);
if (finalEvadeTime < fastEvadeTime)
{
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
}
return(true);
}
}
}
return(false);
}
public static bool ShouldUseMovementBuff(Spell spell)
{
var sortedEvadeSpells = evadeSpells.Where(s => s.evadeType == EvadeType.MovementSpeedBuff).OrderBy(s => s.dangerlevel);
foreach (var evadeSpell in sortedEvadeSpells)
{
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 && !Items.CanUseItem((int)evadeSpell.itemID)) ||
(evadeSpell.checkSpellName && myHero.Spellbook.GetSpell(evadeSpell.spellKey).Name != evadeSpell.spellName))
{
return(false);
}
}
return(true);
}
private static void AddDetectedSpells()
{
bool spellAdded = false;
foreach (KeyValuePair <int, Spell> entry in detectedSpells)
{
Spell spell = entry.Value;
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)
{
continue;
}
if (EvadeUtils.TickCount - spell.startTime <
ObjectCache.menuCache.cache["ReactionTime"].GetValue <Slider>().Value)
{
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)
{
//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;
}
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 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 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 (!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;
}
}
}
}