/// <summary>
/// Called on do-cast.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="args">The args.</param>
public static void OnDoCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (sender.IsMe)
{
if (AutoAttack.IsAutoAttack(args.SData.Name))
{
/// <summary>
/// Initializes the orbwalkingmodes.
/// </summary>
switch (Variables.Orbwalker.ActiveMode)
{
case OrbwalkingMode.Combo:
Logics.Weaving(sender, args);
break;
case OrbwalkingMode.LaneClear:
Logics.JungleClear(sender, args);
Logics.BuildingClear(sender, args);
break;
}
PassiveTarget = args.Target as AttackableUnit;
}
else
{
switch (args.SData.Name)
{
case "MissFortuneRicochetShot":
PassiveTarget = args.Target as AttackableUnit;
break;
}
}
}
}
private static float TotalDmg(Obj_AI_Base enemy, bool useQ, bool useE, bool useR, bool qRange)
{
var qaaDmg = new Double[] { 20, 40, 60, 80, 100 };
var damage = 0d;
var rTicks = RMenu["rTicks"].GetValue <MenuSlider>();
bool inQRange = ((qRange && AutoAttack.InAutoAttackRange(enemy)) || qRange == false);
//Base Q damage
if (useQ && Q.IsReady() && inQRange)
{
damage += player.GetSpellDamage(enemy, SpellSlot.Q);
damage += Damage.CalculateDamage(player, enemy, DamageType.Magical, qaaDmg[Q.Level - 1] + 0.5 * player.TotalMagicalDamage + player.TotalAttackDamage);
}
// Q damage on AA
if (useQ && !Q.IsReady() && player.HasBuff("viktorpowertransferreturn") && inQRange)
{
damage += Damage.CalculateDamage(player, enemy, DamageType.Magical, qaaDmg[Q.Level - 1] + 0.5 * player.TotalMagicalDamage + player.TotalAttackDamage);
}
//E damage
if (useE && E.IsReady())
{
if (player.HasBuff("viktoreaug") || player.HasBuff("viktorqeaug") || player.HasBuff("viktorqweaug"))
{
damage += player.GetSpellDamage(enemy, SpellSlot.E, LeagueSharp.Data.Enumerations.DamageStage.Detonation);
}
else
{
damage += player.GetSpellDamage(enemy, SpellSlot.E);
}
}
//R damage + 2 ticks
if (useR && R.Level > 0 && R.IsReady() && R.Instance.Name == "ViktorChaosStorm")
{
damage += Damage.GetSpellDamage(player, enemy, SpellSlot.R, LeagueSharp.Data.Enumerations.DamageStage.DamagePerSecond) * rTicks;
damage += Damage.GetSpellDamage(player, enemy, SpellSlot.R);
}
// Ludens Echo damage
if (Items.HasItem(3285))
{
damage += Damage.CalculateDamage(player, enemy, DamageType.Magical, 100 + player.FlatMagicDamageMod * 0.1);
}
//sheen damage
if (Items.HasItem(3057))
{
damage += Damage.CalculateDamage(player, enemy, DamageType.Physical, 0.5 * player.BaseAttackDamage);
}
//lich bane dmg
if (Items.HasItem(3100))
{
damage += Damage.CalculateDamage(player, enemy, DamageType.Magical, 0.5 * player.FlatMagicDamageMod + 0.75 * player.BaseAttackDamage);
}
return((float)damage);
}
private static void OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs Args)
{
if (Args.SData == null)
{
return;
}
if (!Enable)
{
return;
}
if (!sender.IsEnemy || sender.IsMinion || AutoAttack.IsAutoAttack(Args.SData.Name) || sender.Type != GameObjectType.obj_AI_Hero)
{
return;
}
if (Args.SData.Name == "YasuoWMovingWall")
{
YasuoWall.CastTime = Game.Time;
YasuoWall.CastPosition = sender.Position.Extend(Args.End, 400);
YasuoWall.YasuoPosition = sender.Position;
YasuoWall.WallLvl = sender.Spellbook.Spells[1].Level;
}
}
/// <summary>
/// Called on do-cast.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="args">The args.</param>
public static void OnDoCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
/*
* if (sender.IsMe && (AutoAttack.IsAutoAttack(args.SData.Name) || args.Slot.Equals(SpellSlot.Q)))
* {
*
* if (!Vars.Q.IsReady() && GameObjects.Player.Spellbook.GetSpell(SpellSlot.Q).Level > 0
* && GameObjects.Player.Spellbook.GetSpell(SpellSlot.E).Level == 0)
* {
* //Vars.E.Cast(Game.CursorPos);
* ObjectManager.Player.Spellbook.CastSpell(SpellSlot.E, Game.CursorPos);
* }
* }
*/
if (sender.IsMe && AutoAttack.IsAutoAttack(args.SData.Name))
{
/// <summary>
/// Initializes the orbwalkingmodes.
/// </summary>
switch (Variables.Orbwalker.ActiveMode)
{
case OrbwalkingMode.Combo:
Logics.Weaving(sender, args);
break;
case OrbwalkingMode.LaneClear:
Logics.JungleClear(sender, args);
Logics.BuildingClear(sender, args);
break;
}
}
}
/// <summary>
/// Sets the resetter slots.
/// </summary>
public static void Initialize()
{
if (GameObjects.Player.Spellbook.Spells.Any(s => AutoAttack.IsAutoAttackReset(s.Name.ToLower())))
{
Vars.HasAnyReset = true;
}
}
private static void Jungle()
{
var Mobs = GameObjects.Jungle.Where(x => x.IsValidTarget(Q.Range) && !GameObjects.JungleSmall.Contains(x)).ToList();
if (Mobs.Count() > 0)
{
if (Me.ManaPercent >= Menu["JungleClear"]["Mana"].GetValue <MenuSlider>().Value)
{
if (Menu["JungleClear"]["Q"] && Q.IsReady() && !AutoAttack.IsAutoAttack(Me.ChampionName))
{
Q.Cast(Mobs.FirstOrDefault());
}
}
if (Menu["JungleClear"]["Item"])
{
if (Menu["Items"]["Hydra"] && Items.HasItem(3074) && Mobs.FirstOrDefault().IsValidTarget(AttackRange()))
{
Items.UseItem(3074, Mobs.FirstOrDefault());
}
if (Menu["Items"]["Tiamat"] && Items.HasItem(3077) && Mobs.FirstOrDefault().IsValidTarget(AttackRange()))
{
Items.UseItem(3077, Mobs.FirstOrDefault());
}
}
}
}
private static void OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (!sender.IsMe || !Enabled)
{
return;
}
var spellName = args.SData.Name;
var target = args.Target as AttackableUnit;
if (target != null && target.IsValid && AutoAttack.IsAutoAttack(spellName))
{
LastAutoAttackTick = Variables.TickCount - Game.Ping / 2;
MissileLaunched = false;
if (!target.Compare(LastTarget))
{
InvokeAction(new OrbwalkerActionArgs {
Target = target, Type = OrbwalkingType.TargetSwitch
});
LastTarget = target;
}
InvokeAction(
new OrbwalkerActionArgs {
Target = target, Sender = sender, Type = OrbwalkingType.OnAttack
});
}
if (AutoAttack.IsAutoAttackReset(spellName))
{
DelayAction.Add(250, ResetAutoAttackTimer);
}
}
/// <summary>
/// Process Spell Cast subscribed event function.
/// </summary>
/// <param name="sender"><see cref="Obj_AI_Base" /> sender</param>
/// <param name="args">Processed Spell Cast Data</param>
private static void OnObjAiBaseProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (!sender.LSIsValidTarget(2000, false) || !AutoAttack.IsAutoAttack(args.SData.Name) || !sender.IsAlly)
{
return;
}
if (!(sender is Obj_AI_Minion) && !(sender is Obj_AI_Turret))
{
return;
}
var target = args.Target as Obj_AI_Minion;
if (target == null)
{
return;
}
ActiveAttacks.Remove(sender.NetworkId);
ActiveAttacks.Add(
sender.NetworkId,
new PredictedDamage(
sender,
target,
Variables.TickCount - (Game.Ping / 2),
sender.AttackCastDelay * 1000,
(sender.AttackDelay * 1000) - (sender is Obj_AI_Turret ? 70 : 0),
sender.IsMelee ? int.MaxValue : (int)args.SData.MissileSpeed,
(float)sender.GetAutoAttackDamage(target)));
}
void OnCollisionEnter(Collision collision)
{
GameObject collisionObject = collision.gameObject;
Player player = collisionObject.GetComponent <Player>();
if (player != null)
{
if (player.GetId() != _ownerId)
{
player.DoDamage(damage);
}
else
{
return;
}
}
AutoAttack autoAttack = collisionObject.GetComponent <AutoAttack>();
// The reason for the second condition is so that only one of the autoattacks
if (autoAttack != null && _ownerId < autoAttack.GetOwnerId())
{
float xPosition = (transform.position.x + autoAttack.transform.position.x) / 2;
float zPosition = (transform.position.z + autoAttack.transform.position.z) / 2;
Vector3 position = new Vector3(xPosition, 1f, zPosition);
_gameController.SendBroadcast(new AbilityInput(0, AbilityType.EXPLOSION, position), true);
}
Destroy(gameObject);
}
private void Obj_AI_Base_OnProcessAutoAttack(Obj_AI_Base sender, Obj_AI_BaseMissileClientDataEventArgs e)
{
//Ignore auto attacks happening too far away
if (sender == null || !sender.IsValidTarget(4000, true) || sender is Obj_AI_Hero)
{
return;
}
//Only process for minion targets
var targetM = e.Target as Obj_AI_Minion;
if (targetM == null)
{
return;
}
AutoAttack attack = null;
if (sender.IsMelee)
{
attack = new MeleeAttack(sender, targetM, 0);
}
else
{
attack = new RangedAttack(sender, targetM, 0);
}
Attacks.AddAttack(attack);
}
/// <summary>
/// Called on do-cast.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="args">The args.</param>
public static void OnDoCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (sender.IsMe && AutoAttack.IsAutoAttack(args.SData.Name))
{
/// <summary>
/// Initializes the orbwalkingmodes.
/// </summary>
switch (Variables.Orbwalker.ActiveMode)
{
case OrbwalkingMode.Combo:
Logics.Weaving(sender, args);
break;
case OrbwalkingMode.LastHit:
Logics.Clear(sender, args);
break;
case OrbwalkingMode.LaneClear:
Logics.Clear(sender, args);
Logics.JungleClear(sender, args);
Logics.BuildingClear(sender, args);
break;
}
}
}
/// <summary>
/// OnProcessSpellCast event.
/// </summary>
/// <param name="sender">
/// The sender
/// </param>
/// <param name="args">
/// The event data
/// </param>
private void OnObjAiBaseProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (sender.IsValid && sender.IsMe)
{
var spellName = args.SData.Name;
var target = args.Target as AttackableUnit;
if (target != null && target.IsValid && AutoAttack.IsAutoAttack(spellName))
{
this.LastAutoAttackTick = Variables.TickCount - (Game.Ping / 2);
this.MissileLaunched = false;
this.LastMovementOrderTick = 0;
this.TotalAutoAttacks++;
if (!target.Compare(this.LastTarget))
{
this.InvokeAction(
new OrbwalkingActionArgs {
Target = target, Type = OrbwalkingType.TargetSwitch
});
this.LastTarget = target;
}
this.InvokeAction(
new OrbwalkingActionArgs {
Target = target, Sender = sender, Type = OrbwalkingType.OnAttack
});
}
if (AutoAttack.IsAutoAttackReset(spellName))
{
this.ResetSwingTimer();
}
}
}
/// Aa cancel thanks Doug!
private static void OndoCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (!sender.IsMe || !AutoAttack.IsAutoAttack(args.SData.Name))
{
return;
}
if (args.Target == null || !args.Target.IsValid)
{
return;
}
if (Variables.Orbwalker.ActiveMode == OrbwalkingMode.Combo)
{
if (Variables.Orbwalker.GetTarget() == null)
{
return;
}
if (
!(args.Target is Obj_AI_Turret || args.Target is Obj_Barracks || args.Target is Obj_BarracksDampener ||
args.Target is Obj_Building) && q.IsReady() && UseQ)
{
DelayAction.Add(
50,
() =>
{
q.Cast();
Variables.Orbwalker.ResetSwingTimer();
});
}
}
}
private static void OnDoCast(AIBaseClient sender, AIBaseClientProcessSpellCastEventArgs args)
{
if (sender.IsEnemy)
{
if (SweetHeart != null && MenuWrapper.Misc.R.Value)
{
if ((sender.Type != GameObjectType.AIHeroClient || AutoAttack.IsAutoAttack(args.SData.Name)) && args.Target != null && args.Target.NetworkId == SweetHeart.NetworkId)
{
_incomingDamage.Add(SweetHeart.Position.Distance(sender.Position) / args.SData.MissileSpeed + Game.Time, (float)sender.GetAutoAttackDamage(SweetHeart));
}
else if (sender.Type == GameObjectType.AIHeroClient)
{
var attacker = sender as AIHeroClient;
var slot = attacker.GetSpellSlot(args.SData.Name);
if (slot != SpellSlot.Unknown)
{
if (slot.HasFlag(SpellSlot.Q | SpellSlot.W | SpellSlot.E | SpellSlot.R) &&
(args.Target != null && args.Target.NetworkId == SweetHeart.NetworkId ||
args.End.Distance(SweetHeart.Position) < Math.Pow(args.SData.LineWidth, 2)))
{
_instantDamage.Add(Game.Time + 2, (float)attacker.GetSpellDamage(SweetHeart, slot));
}
}
}
}
}
}
/// <summary>
/// Obj_AI_Base.OnProcessSpellCast Event to detect auto attacks
/// </summary>
/// <param name="sender"><see cref="Obj_AI_Base" /> sender</param>
/// <param name="args"><see cref="GameObjectProcessSpellCastEventArgs" /> args</param>
private static void Obj_AI_Base_OnProcessSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (sender.IsMe && AutoAttack.IsAutoAttack(args.SData.Name))
{
_missleLaunched = false;
}
}
/// <summary>
/// Delegate to the OnDoCast event
/// </summary>
/// <param name="sender">The sender unit.</param>
/// <param name="args">The <see cref="GameObjectProcessSpellCastEventArgs"/> instance containing the event data.</param>
private void AfterAttack(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
if (sender.IsMe && AutoAttack.IsAutoAttack(args.SData.Name))
{
this.OnAfterAttack(sender, args);
}
}
protected AutoAttack SpawnAutoAttack(int id, Vector3 startPosition, Vector3 targetPosition)
{
AutoAttack autoAttack = _players[id].SpawnAutoAttack(startPosition, targetPosition);
autoAttack.SetGameController(this);
return(autoAttack);
}
private void InitializeComponents()
{
hitSensor = transform.parent.GetComponentInChildren <HitSensor>();
cast = GetComponent <Cast>();
autoAttack = GetComponent <AutoAttack>();
player = GameObject.FindWithTag(Tags.Player).GetComponentInChildren <Player>();
mover = GetComponent <RootMover>();
}
AutoAttack[] generateAutoAttacks()
{
AutoAttack[] autoAttackWaves = new AutoAttack[3];
autoAttackWaves[0] = WaveOne.create(this.prefabProjectile, projectileSpeed);
autoAttackWaves[1] = WaveTwo.create(this.prefabProjectile, projectileSpeed);
autoAttackWaves[2] = WaveThree.create(this.prefabSpikes);
return(autoAttackWaves);
}
public static AutoAttack ReadFrom(System.IO.BinaryReader reader)
{
int pathfindRange = reader.ReadInt32();
EntityType[] validTargets = new Model.EntityType[reader.ReadInt32()];
for (int i = 0; i < validTargets.Length; i++)
{
switch (reader.ReadInt32())
{
case 0:
validTargets[i] = Model.EntityType.Wall;
break;
case 1:
validTargets[i] = Model.EntityType.House;
break;
case 2:
validTargets[i] = Model.EntityType.BuilderBase;
break;
case 3:
validTargets[i] = Model.EntityType.BuilderUnit;
break;
case 4:
validTargets[i] = Model.EntityType.MeleeBase;
break;
case 5:
validTargets[i] = Model.EntityType.MeleeUnit;
break;
case 6:
validTargets[i] = Model.EntityType.RangedBase;
break;
case 7:
validTargets[i] = Model.EntityType.RangedUnit;
break;
case 8:
validTargets[i] = Model.EntityType.Resource;
break;
case 9:
validTargets[i] = Model.EntityType.Turret;
break;
default:
throw new System.Exception("Unexpected tag value");
}
}
var result = new AutoAttack(pathfindRange, validTargets);
return(result);
}
/// <summary>
/// OnCreate event.
/// </summary>
/// <param name="sender">
/// The sender.
/// </param>
/// <param name="args">
/// The event data.
/// </param>
private static void OnCreate(GameObject sender, EventArgs args)
{
var missile = sender as MissileClient;
if (missile != null && missile.SpellCaster.IsMe && AutoAttack.IsAutoAttack(missile.SData.Name))
{
MissileLaunched = true;
}
}
private static void HarassLogic()
{
var QTarget = GetTarget(bonusRange() + 60, DamageType.Physical);
var WTarget = GetTarget(W.Range, W.DamageType);
if (CheckTarget(QTarget) && Q.IsReady() && Menu["Q"]["HarassQ"].GetValue <MenuSliderButton>().BValue)
{
if (!JinxQ && (!AutoAttack.InAutoAttackRange(QTarget) || QTarget.CountEnemyHeroesInRange(250) > 2) && Variables.Orbwalker.GetTarget() == null)
{
var Distance = GetRealDistance(QTarget);
if (Player.ManaPercent >= Menu["Q"]["HarassQ"].GetValue <MenuSliderButton>().SValue || Player.GetAutoAttackDamage(QTarget) * 3 > QTarget.Health)
{
Q.Cast();
}
else if (!Player.IsWindingUp && Variables.Orbwalker.CanAttack && !Player.IsUnderEnemyTurret() && Distance < bonusRange() + QTarget.BoundingRadius + Player.BoundingRadius)
{
Q.Cast();
}
}
}
if (!JinxQ && !Player.IsWindingUp && Variables.Orbwalker.GetTarget() == null && Q.IsReady())
{
if (Variables.Orbwalker.CanAttack && Menu["Q"]["FarmQout"] && Player.Mana > R.Instance.ManaCost + W.Instance.ManaCost + E.Instance.ManaCost + 10)
{
foreach (var minion in GetMinions(Player.Position, bonusRange() + 30).Where(minion => !AutoAttack.InAutoAttackRange(minion) && GetRealPowPowRange(minion) < GetRealDistance(minion) && bonusRange() < GetRealDistance(minion)))
{
var hpPred = GetHealthPrediction(minion, 400, 70);
if (hpPred < Player.GetAutoAttackDamage(minion) * 1.1 && hpPred > 4)
{
Variables.Orbwalker.ForceTarget.Distance(minion);
Q.Cast();
return;
}
}
}
}
if (Player.CountEnemyHeroesInRange(bonusRange()) == 0)
{
if (Menu["W"]["HarassW"].GetValue <MenuSliderButton>().BValue&& !Player.IsWindingUp && CanHarras())
{
if (CheckTarget(WTarget) && W.IsReady())
{
foreach (var enemy in GameObjects.EnemyHeroes.Where(enemy => enemy.IsValidTarget(W.Range) && Menu["W"]["WList"][enemy.ChampionName.ToLower()].GetValue <MenuBool>()))
{
if (Player.ManaPercent >= Menu["W"]["HarassW"].GetValue <MenuSliderButton>().SValue)
{
CastSpell(W, enemy);
}
}
}
}
}
}
protected override void HandlePacket(Packet packet)
{
BitBuffer bitBuffer = new BitBuffer();
bitBuffer.PutBytes(packet.getData());
bitBuffer.Flip();
PlayerInput input = PlayerInput.fromBytes(bitBuffer);
switch (input.GetInputType())
{
case InputType.MOVEMENT:
_players[input.GetId()].SetTargetPosition(((MovementInput)input).GetPosition());
break;
case InputType.ABILITY:
AbilityInput ability = (AbilityInput)input;
Vector3 abilityStartPosition = Vector3.zero;
switch (ability.GetAbilityType())
{
case AbilityType.AUTOATTACK:
abilityStartPosition = _players[ability.GetId()].transform.position;
AutoAttack autoAttack = SpawnAutoAttack(ability.GetId(), abilityStartPosition, ability.GetTargetPosition());
_lastAbilityId = (_lastAbilityId + 1) % 255;
_autoAttacks.Add(_lastAbilityId, autoAttack);
break;
case AbilityType.FREEZE:
_players[ability.GetId()].SpawnFreeze(ability.GetTargetPosition());
break;
case AbilityType.FLASH:
_players[ability.GetId()].MoveTo(ability.GetTargetPosition());
_players[ability.GetId()].CancelMovement();
break;
case AbilityType.EXPLOSION:
CreateExplosion(ability.GetTargetPosition());
break;
}
_channel.SendAll(new AbilityResponse(ability, abilityStartPosition), true);
break;
case InputType.START_GAME:
_lastPlayerId++;
Vector3 startPosition = new Vector3(2f, 1.2f, 0f);
Player player = CreateServerPlayer(new PlayerInfo(_lastPlayerId, startPosition));
_players.Add(_lastPlayerId, player);
_channel.Send(new PlayerInfoBroadcast(_lastPlayerId, _players), packet.getAddress(), true);
PlayerInfo playerInfo = new PlayerInfo(_lastPlayerId, player.GetHealth(), new PositionInfo(startPosition));
_channel.SendAllExcluding(new NewPlayerEvent(playerInfo), packet.getAddress(), true);
break;
}
packet = _channel.GetPacket();
bitBuffer.Clear();
}
void AutoAttack() // attack the current target.
{
// TODO: This function must start an animation that fires an event that calls a function to fire some projectile.
agent.SetDestination(transform.position); // could also set the destination to current position as well. instead of turning it off.
GameObject bullet = Instantiate(projectile, firePos.position, firePos.rotation);
AutoAttack autoAttack = bullet.GetComponent <AutoAttack>();
autoAttack.damage = damage;
autoAttack.target = target.transform;
autoAttackCountdown = Time.time + autoAttackCooldown;
}
private void OnAutoStartAttack(AutoAttack type)
{
if (type == AutoAttack.Slam)
{
StartCoroutine(MoveUp(() => SlamAttack()));
}
if (type == AutoAttack.Middle)
{
StartCoroutine(MoveUp(() => MiddleFingerAttack()));
}
}
public AutoAttack SpawnAutoAttack(Vector3 startPosition, Vector3 targetPosition)
{
Vector3 relativePosition = targetPosition - transform.position;
Quaternion rotation = Quaternion.LookRotation(relativePosition);
startPosition = startPosition + 0.8f * relativePosition.normalized;
AutoAttack auto = Instantiate(autoAttackPrefab, startPosition, rotation).GetComponent <AutoAttack>();
auto.SetOwnerId(_id);
return(auto);
}
private static void OnSpellCast(Obj_AI_Base sender, GameObjectProcessSpellCastEventArgs args)
{
try
{
if (!sender.IsMe || !AutoAttack.IsAutoAttack(args.SData.Name))
{
return;
}
if (Combo)
{
if (args.Target is AIHeroClient)
{
var target = (AIHeroClient)args.Target;
if (!target.IsDead)
{
if (Menu["W"]["ComboW"].GetValue <MenuBool>() && W.IsReady())
{
W.Cast(W.GetPrediction(target).UnitPosition);
return;
}
if (Q.IsReady() && Menu["Q"]["ComboQ"].GetValue <MenuBool>() && Player.Distance(target) <= 550)
{
Q.Cast(target);
}
}
}
}
if (Harass)
{
if (args.Target is AIHeroClient)
{
var target = (AIHeroClient)args.Target;
if (!target.IsDead)
{
if (Menu["W"]["HarassW"].GetValue <MenuBool>() && W.IsReady())
{
W.Cast(W.GetPrediction(target).UnitPosition);
return;
}
if (Q.IsReady() && Menu["Q"]["HarassQ"].GetValue <MenuBool>() && Player.Distance(target) <= 550)
{
Q.Cast(target);
}
}
}
}
}
catch (Exception ex)
{
Console.WriteLine("Error In On DoCast" + ex);
}
}
/// <summary>
/// Game.OnCreate Event to detect missiles
/// </summary>
/// <param name="sender"><see cref="GameObject" /> sender</param>
/// <param name="args"><see cref="EventArgs" /> args</param>
private static void GameObject_OnCreate(GameObject sender, EventArgs args)
{
if (sender.IsValid)
{
var missile = (Obj_SpellMissile)sender;
if (missile.SpellCaster.IsMe && AutoAttack.IsAutoAttack(missile.SData.Name))
{
_missleLaunched = true;
}
}
}
void Start()
{
if (name == "Left")
{
leftFlg = true;
}
cameraObj = GameObject.Find("Main Camera").gameObject;
if (GameObject.Find("AutoBtn"))
{
autoScript = GameObject.Find("AutoBtn").GetComponent <AutoAttack>();
}
}
void TryInit()
{
if (player == null)
{
player = GameObject.FindGameObjectWithTag(playerTag);
}
if (player != null)
{
ani = player.GetComponent <Animation>();
gameObject.GetComponent <Button>().onClick.AddListener(OnClick);
m_autoAttack = player.GetComponent <AutoAttack>();
}
}
public static AutoAttack AutoAttackSettings(AutoAttack aa)
{
aa.active = EditorGUILayout.Toggle("Active", aa.active, GUILayout.Width(mWidth));
if(aa.active)
{
aa.interval = EditorGUILayout.FloatField("Time interval", aa.interval, GUILayout.Width(mWidth));
if(aa.interval < 0) aa.interval = 0;
aa.useSkill = EditorGUILayout.Toggle("Use skills", aa.useSkill, GUILayout.Width(mWidth));
if(aa.useSkill)
{
aa.skillID = EditorGUILayout.Popup("Skill", aa.skillID, DataHolder.Skills().GetNameList(true), GUILayout.Width(mWidth));
aa.skillLevel = EditorGUILayout.IntField("Skill level", aa.skillLevel, GUILayout.Width(mWidth));
aa.skillLevel = BaseTab.MinMaxCheck(aa.skillLevel, 1, DataHolder.Skill(aa.skillID).level.Length);
}
}
return aa;
}
