private static bool ShouldActivateEvadeSpell(Spell spell)
{
if (ezEvade.LastPosInfo == null)
{
return(false);
}
if (ConfigValue.DodgeSkillShots.GetBool())
{
if (ezEvade.LastPosInfo.UndodgeableSpells.Contains(spell.SpellId) &&
GameData.HeroInfo.ServerPos2D.InSkillShot(spell, GameData.HeroInfo.BoundingRadius))
{
return(true);
}
}
else
{
if (GameData.HeroInfo.ServerPos2D.InSkillShot(spell, GameData.HeroInfo.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 void UseEvadeSpell()
{
if (!Situation.ShouldUseEvadeSpell())
{
return;
}
//int posDangerlevel = EvadeHelper.CheckPosDangerLevel(ObjectCache.myHeroCache.serverPos2D, 0);
if (EvadeUtils.TickCount - LastSpellEvadeCommand.Timestamp < 1000)
{
return;
}
//ConsoleDebug.WriteLineColor("Dodging Skill Shots by Evade Spell", ConsoleColor.Green);
foreach (KeyValuePair <int, Spell> entry in SpellDetector.Spells)
{
Spell spell = entry.Value;
if (ShouldActivateEvadeSpell(spell))
{
if (ActivateEvadeSpell(spell))
{
ezEvade.SetAllUndodgeable();
return;
}
}
}
}
private static void CheckSpellCollision()
{
if (!ConfigValue.CheckSpellCollision.GetBool())
{
return;
}
foreach (KeyValuePair <int, Spell> entry in DetectedSpells)
{
Spell spell = entry.Value;
var collisionObject = spell.CheckSpellCollision();
if (collisionObject != null)
{
spell.PredictedEndPos = spell.GetSpellProjection(collisionObject.ServerPosition.To2D());
if (spell.CurrentSpellPosition.Distance(collisionObject.ServerPosition)
< collisionObject.BoundingRadius + spell.Radius)
{
Core.DelayAction(() => DeleteSpell(entry.Key), 1);
}
}
}
}
public static List <int> GetSpellList()
{
List <int> spellList = new List <int>();
foreach (KeyValuePair <int, Spell> entry in Spells)
{
Spell spell = entry.Value;
spellList.Add(spell.SpellId);
}
return(spellList);
}
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 - GameData.HeroInfo.BoundingRadius &&
position.Distance(spell.EndPos) >= spell.Radius + radius - GameData.HeroInfo.BoundingRadius - 125);
}
return(position.Distance(spell.EndPos) <= spell.Radius + radius - GameData.HeroInfo.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 - GameData.HeroInfo.BoundingRadius);
}
else if (spell.SpellType == SpellType.Cone)
{
}
return(false);
}
public static bool CanHeroWalkIntoSpell(Spell spell)
{
if (ConfigValue.AdvancedSpellDetection.GetBool())
{
Vector2 heroPos = MyHero.Position.To2D();
var extraDist = MyHero.Distance(GameData.HeroInfo.ServerPos2D);
if (spell.SpellType == SpellType.Line)
{
var walkRadius = GameData.HeroInfo.MoveSpeed * (spell.EndTime - EvadeUtils.TickCount) / 1000 +
GameData.HeroInfo.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 = GameData.HeroInfo.MoveSpeed * (spell.EndTime - EvadeUtils.TickCount) / 1000 +
GameData.HeroInfo.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 = GameData.HeroInfo.MoveSpeed * (spell.EndTime - EvadeUtils.TickCount) / 1000 +
GameData.HeroInfo.BoundingRadius + arcRadius + extraDist + 10;
if (heroPos.Distance(midPoint) < walkRadius)
{
return(true);
}
}
return(false);
}
return(true);
}
private void SpellMissile_OnCreate(GameObject obj, EventArgs args)
{
MissileClient missile;
if (obj.IsMissileClient(out missile))
{
return;
}
SpellData spellData;
if (missile.IsValidEvadeSpell(out spellData))
{
if (missile.IsInRange(spellData))
{
var hero = missile.SpellCaster;
if (!hero.IsVisible && ConfigValue.DodgeFowSpells.GetBool())
{
CreateSpellData(hero, missile.StartPosition, missile.EndPosition, spellData, obj);
return;
}
if (spellData.UsePackets)
{
CreateSpellData(hero, missile.StartPosition, missile.EndPosition, spellData, obj);
return;
}
foreach (KeyValuePair <int, Spell> entry in Spells)
{
Spell spell = entry.Value;
var dir = (missile.EndPosition.To2D() - missile.StartPosition.To2D()).Normalized();
if (spell.Info.MissileName == missile.SData.Name &&
spell.HeroId == missile.SpellCaster.NetworkId &&
dir.AngleBetween(spell.Direction) < 10)
{
if (spell.Info.IsThreeWay == false &&
spell.Info.IsSpecial == false)
{
spell.SpellObject = obj;
}
}
}
}
}
}
public static int CheckPosDangerLevel(this Vector2 pos, float extraBuffer)
{
var dangerlevel = 0;
foreach (KeyValuePair <int, Spell> entry in SpellDetector.Spells)
{
Spell spell = entry.Value;
if (pos.InSkillShot(spell, GameData.HeroInfo.BoundingRadius + extraBuffer))
{
dangerlevel += (int)spell.Dangerlevel;
}
}
return(dangerlevel);
}
public static bool HasExtraAvoidDistance(this Vector2 pos, float extraBuffer)
{
foreach (KeyValuePair <int, Spell> entry in SpellDetector.Spells)
{
Spell spell = entry.Value;
if (spell.SpellType == SpellType.Line)
{
if (pos.InSkillShot(spell, GameData.HeroInfo.BoundingRadius + extraBuffer))
{
return(true);
}
}
}
return(false);
}
public static bool CheckDangerousPos(this Vector2 pos, float extraBuffer, bool checkOnlyDangerous = false)
{
foreach (KeyValuePair <int, Spell> entry in SpellDetector.Spells)
{
Spell spell = entry.Value;
if (checkOnlyDangerous && (int)spell.Dangerlevel < (int)SpellDangerLevel.High)
{
continue;
}
if (pos.InSkillShot(spell, GameData.HeroInfo.BoundingRadius + extraBuffer))
{
return(true);
}
}
return(false);
}
public static float GetLowestEvadeTime(out Spell lowestSpell)
{
float lowest = float.MaxValue;
lowestSpell = null;
foreach (KeyValuePair <int, Spell> entry in Spells)
{
Spell spell = entry.Value;
if (spell.SpellHitTime != float.MinValue)
{
//ConsoleDebug.WriteLine("spellhittime: " + spell.spellHitTime);
lowest = Math.Min(lowest, (spell.SpellHitTime - spell.EvadeTime));
lowestSpell = spell;
}
}
return(lowest);
}
//public static int CreateTestSpell(SpellPoint spell, SpellData data)
//{
// if (spell.StartPosition.Distance(MyHero.Position) < data.Range + ConfigValue.ExtraDetectionRange.GetInt())
// {
// Vector2 startPosition = spell.StartPosition.To2D();
// Vector2 endPosition = spell.EndPosition.To2D();
// Vector2 direction = (endPosition - startPosition).Normalized();
// float endTick = 0;
// if (data.FixedRange) //for diana q
// {
// if (endPosition.Distance(startPosition) > data.Range)
// {
// endPosition = startPosition + direction*data.Range;
// }
// }
// if (data.SpellType == SpellType.Line)
// {
// endTick = data.SpellDelay + (data.Range/data.ProjectileSpeed)*1000;
// endPosition = startPosition + direction*data.Range;
// if (data.UseEndPosition)
// {
// var range = endPosition.Distance(startPosition);
// endTick = data.SpellDelay + (range/data.ProjectileSpeed)*1000;
// }
// }
// else if (data.SpellType == SpellType.Circular)
// {
// endTick = data.SpellDelay;
// if (data.ProjectileSpeed == 0)
// {
// endPosition = startPosition;
// }
// else if (data.ProjectileSpeed > 0)
// {
// if (data.SpellType == SpellType.Line &&
// data.HasEndExplosion &&
// data.UseEndPosition == false)
// {
// endPosition = startPosition + direction*data.Range;
// }
// endTick = endTick + 1000*startPosition.Distance(endPosition)/data.ProjectileSpeed;
// }
// }
// else if (data.SpellType == SpellType.Arc)
// {
// endTick = endTick + 1000*startPosition.Distance(endPosition)/data.ProjectileSpeed;
// }
// else if (data.SpellType == SpellType.Cone)
// {
// return 0;
// }
// else
// {
// return 0;
// }
// Spell newSpell = new Spell();
// newSpell.StartTime = EvadeUtils.TickCount;
// newSpell.EndTime = EvadeUtils.TickCount + endTick;
// newSpell.StartPos = startPosition;
// newSpell.EndPos = endPosition;
// newSpell.Height = spell.EndPosition.Z + data.ExtraDrawHeight;
// newSpell.Direction = direction;
// newSpell.HeroId = 0;
// newSpell.Info = data;
// newSpell.SpellType = data.SpellType;
// newSpell.Radius = data.Radius > 0 ? data.Radius : newSpell.GetSpellRadius();
// int spellId = CreateSpell(newSpell);
// Core.DelayAction(() => DeleteSpell(spellId), (int) (endTick + data.ExtraEndTime));
// return spellId;
// }
// return 0;
//}
private static int CreateSpell(Spell newSpell, bool processSpell = true)
{
//Debug.DrawTopLeft(newSpell);
int spellId = _spellIdCount++;
newSpell.SpellId = spellId;
newSpell.UpdateSpellInfo();
DetectedSpells.Add(spellId, newSpell);
if (processSpell)
{
CheckSpellCollision();
AddDetectedSpells();
}
if (OnCreateSpell != null)
{
OnCreateSpell.Invoke(newSpell);
}
return(spellId);
}
public static Spell GetMostDangerousSpell(bool hasProjectile = false)
{
int maxDanger = 0;
Spell maxDangerSpell = null;
foreach (Spell spell in Spells.Values)
{
if (!hasProjectile || (spell.Info.ProjectileSpeed > 0 && spell.Info.ProjectileSpeed != float.MaxValue))
{
var dangerlevel = spell.Dangerlevel;
if ((int)dangerlevel > maxDanger)
{
maxDanger = (int)dangerlevel;
maxDangerSpell = spell;
}
}
}
return(maxDangerSpell);
}
public static bool PreferEvadeSpell()
{
if (!Situation.ShouldUseEvadeSpell())
{
return(false);
}
foreach (KeyValuePair <int, Spell> entry in SpellDetector.Spells)
{
Spell spell = entry.Value;
if (!GameData.HeroInfo.ServerPos2D.InSkillShot(spell, GameData.HeroInfo.BoundingRadius))
{
continue;
}
if (ActivateEvadeSpell(spell, true))
{
return(true);
}
}
return(false);
}
private void CheckSpellEndTime()
{
foreach (KeyValuePair <int, Spell> entry in DetectedSpells)
{
Spell spell = entry.Value;
foreach (var hero in EntityManager.Heroes.Enemies)
{
if (hero.IsDead && spell.HeroId == hero.NetworkId)
{
if (spell.SpellObject == null)
{
Core.DelayAction(() => DeleteSpell(entry.Key), 1);
}
}
}
if (spell.EndTime + spell.Info.ExtraEndTime < EvadeUtils.TickCount ||
CanHeroWalkIntoSpell(spell) == false)
{
Core.DelayAction(() => DeleteSpell(entry.Key), 1);
}
}
}
public static bool ActivateEvadeSpell(Spell spell, bool checkSpell = false)
{
var sortedEvadeSpells = EvadeSpells.OrderBy(s => s.Dangerlevel);
var extraDelayBuffer = Config.Properties.GetInt(ConfigValue.ExtraPingBuffer);
float spellActivationTime = ConfigValue.SpellActivationTime.GetInt() + Game.Ping + extraDelayBuffer;
if (ConfigValue.CalculateWindupDelay.GetBool())
{
var extraWindupDelay = ezEvade.LastWindupTime - EvadeUtils.TickCount;
if (extraWindupDelay > 0)
{
return(false);
}
}
foreach (var evadeSpell in sortedEvadeSpells)
{
var processSpell = true;
if (!Config.Properties.GetEvadeSpell(evadeSpell.Name).Use ||
((int)GetSpellDangerLevel(evadeSpell) > (int)spell.GetSpellDangerLevel()) ||
(!evadeSpell.IsItem && MyHero.Spellbook.CanUseSpell(evadeSpell.SpellKey) != SpellState.Ready) ||
(evadeSpell.IsItem && !(Items.CanUseItem((int)evadeSpell.ItemId))) ||
(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);
float finalEvadeTime = (spellHitTime - evadeTime);
if (checkSpell)
{
var mode = Config.Properties.GetEvadeSpell(evadeSpell.Name).SpellMode;
switch (mode)
{
case SpellModes.Undodgeable:
continue;
case SpellModes.ActivationTime:
if (spellActivationTime < finalEvadeTime)
{
continue;
}
break;
}
}
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, GameData.HeroInfo.MoveSpeed, 0, 0);
if ((int)GetSpellDangerLevel(evadeSpell) > (int)posInfo.PosDangerLevel)
{
continue;
}
}
}
}
if (evadeSpell.EvadeType != EvadeType.Dash && spellHitTime > evadeSpell.SpellDelay + 100 + Game.Ping +
Config.Properties.GetInt(ConfigValue.ExtraPingBuffer))
{
processSpell = false;
if (checkSpell == false)
{
continue;
}
}
if (evadeSpell.IsSpecial)
{
if (evadeSpell.UseSpellFunc != null)
{
if (evadeSpell.UseSpellFunc(evadeSpell, processSpell))
{
return(true);
}
}
continue;
}
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 - GameData.HeroInfo.ServerPos2D).Normalized();
var range = GameData.HeroInfo.ServerPos2D.Distance(posInfo.Position);
var pos = GameData.HeroInfo.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") //TODO: temp fix, don't have fiora :'(
{
var dir = (spell.StartPos - GameData.HeroInfo.ServerPos2D).Normalized();
var pos = GameData.HeroInfo.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 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 = Game.Ping + Config.Properties.GetInt(ConfigValue.ExtraPingBuffer);
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 < ConfigValue.SpellDetectionTime.GetInt())
{
continue;
}
if (EvadeUtils.TickCount - spell.StartTime < ConfigValue.ReactionTime.GetInt())
{
continue;
}
var dodgeInterval = ConfigValue.DodgeInterval.GetInt();
if (ezEvade.LastPosInfo != null && dodgeInterval > 0)
{
var timeElapsed = EvadeUtils.TickCount - ezEvade.LastPosInfo.Timestamp;
if (dodgeInterval > timeElapsed)
{
//var delay = dodgeInterval - timeElapsed;
//DelayAction.Add((int)delay, () => SpellDetector_OnProcessDetectedSpells());
continue;
}
}
if (!Spells.ContainsKey(spell.SpellId))
{
if (Config.Properties.GetSpell(newSpell.Info.SpellName).Dodge&& !(ezEvade.IsDodgeDangerousEnabled() && (int)newSpell.Dangerlevel < (int)SpellDangerLevel.High))
{
if (newSpell.SpellType == SpellType.Circular &&
!ConfigValue.DodgeCircularSpells.GetBool())
{
//return spellID;
continue;
}
Spells.Add(spellId, newSpell);
spellAdded = true;
}
}
if (ConfigValue.CheckSpellCollision.GetBool() && spell.PredictedEndPos != Vector2.Zero)
{
spellAdded = false;
}
}
}
if (spellAdded && OnProcessDetectedSpells != null)
{
OnProcessDetectedSpells();
}
}
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 + ConfigValue.ExtraDetectionRange.GetInt())
{
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)
{
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);
Core.DelayAction(() => DeleteSpell(spellId), (int)(endTick + spellData.ExtraEndTime));
}
}
private void Drawing_OnDraw(EventArgs args)
{
if (ConfigValue.DrawEvadePosition.GetBool())
{
//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 (ezEvade.LastPosInfo != null)
{
var pos = ezEvade.LastPosInfo.Position; //Evade.lastEvadeCommand.targetPosition;
Render.Circle.DrawCircle(new Vector3(pos.X, pos.Y, MyHero.Position.Z), 65, Color.Red, 10);
}
}
//DrawPlayerPath();
DrawEvadeStatus();
if (!ConfigValue.DrawSkillShots.GetBool())
{
return;
}
foreach (KeyValuePair <int, Spell> entry in SpellDetector.DrawSpells)
{
Spell spell = entry.Value;
var width = 0;
switch (spell.Dangerlevel)
{
case SpellDangerLevel.Low:
width = ConfigValue.LowDangerDrawWidth.GetInt();
break;
case SpellDangerLevel.Normal:
width = ConfigValue.NormalDangerDrawWidth.GetInt();
break;
case SpellDangerLevel.High:
width = ConfigValue.HighDangerDrawWidth.GetInt();
break;
case SpellDangerLevel.Extreme:
width = ConfigValue.ExtremeDangerDrawWidth.GetInt();
break;
}
if (Config.Properties.GetSpell(spell.Info.SpellName).Draw)
{
if (spell.SpellType == SpellType.Line)
{
Vector2 spellPos = spell.CurrentSpellPosition;
Vector2 spellEndPos = spell.GetSpellEndPosition();
DrawLineRectangle(spellPos, spellEndPos, (int)spell.Radius, width, GetSpellColor(spell.Dangerlevel));
/*foreach (var hero in ObjectManager.Get<AIHeroClient>())
* {
* Render.Circle.DrawCircle(new Vector3(hero.ServerPosition.X, hero.ServerPosition.Y, myHero.Position.Z), (int)spell.radius, Color.Red, 5);
* }*/
if (ConfigValue.DrawSpellPosition.GetBool() && spell.SpellObject != null)
{
//spellPos = SpellDetector.GetCurrentSpellPosition(spell, true, ObjectCache.gamePing);
/*if (true)
* {
* var spellPos2 = spell.startPos + spell.direction * spell.info.projectileSpeed * (Evade.GetTickCount - spell.startTime - spell.info.spellDelay) / 1000 + spell.direction * spell.info.projectileSpeed * ((float)ObjectCache.gamePing / 1000);
* Render.Circle.DrawCircle(new Vector3(spellPos2.X, spellPos2.Y, myHero.Position.Z), (int)spell.radius, Color.Red, 8);
* }*/
/*if (spell.spellObject != null && spell.spellObject.IsValid && spell.spellObject.IsVisible &&
* spell.spellObject.Position.To2D().Distance(ObjectCache.myHeroCache.serverPos2D) < spell.info.range + 1000)*/
Render.Circle.DrawCircle(new Vector3(spellPos.X, spellPos.Y, MyHero.Position.Z), (int)spell.Radius, GetSpellColor(spell.Dangerlevel), width);
}
}
else if (spell.SpellType == SpellType.Circular)
{
Render.Circle.DrawCircle(new Vector3(spell.EndPos.X, spell.EndPos.Y, spell.Height), (int)spell.Radius, GetSpellColor(spell.Dangerlevel), width);
if (spell.Info.SpellName == "VeigarEventHorizon")
{
Render.Circle.DrawCircle(new Vector3(spell.EndPos.X, spell.EndPos.Y, spell.Height), (int)spell.Radius - 125, GetSpellColor(spell.Dangerlevel), width);
}
}
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)
{
}
}
}
}