public virtual void Display(Prediction prediction, IEnumerable<Overlay> overlays)
{
Invoke(new Action(Clear));
_displayedPrediction = prediction;
_overlays = overlays;
}
public override void SetUp()
{
base.SetUp();
context = new PredictorContext(this);
p = new Prediction().AddFilesTouchCountInCommitsPredictor();
p.Init(this, new string[] { "1", "2" });
}
/// <summary>
/// Create a new prediction.
/// </summary>
/// <param name="model">A valid Model</param>
/// <param name="name">The name you want to give to the new prediction. </param>
public Task<Prediction> Create(Model model, string name = null, Prediction.Arguments arguments = null)
{
arguments = arguments ?? new Prediction.Arguments();
if (!string.IsNullOrWhiteSpace(name)) arguments.Name = name;
arguments.Model = model.Resource;
return Create<Prediction>(arguments);
}
public override void Apply(Prediction prediction)
{
List<PointPrediction> pointPredictions = prediction.PointPredictions;
if (pointPredictions.Count > 0)
{
Dictionary<int, Point> idPoint = new Dictionary<int, Point>();
foreach (Point p in prediction.Points)
idPoint.Add(p.Id, p);
List<Tuple<PointPrediction, Dictionary<string, double>>> pointPredictionIncidentScore = new List<Tuple<PointPrediction, Dictionary<string, double>>>(pointPredictions.Count);
Set<Thread> threads = new Set<Thread>(Configuration.ProcessorCount);
for (int i = 0; i < Configuration.ProcessorCount; ++i)
{
Thread t = new Thread(new ParameterizedThreadStart(core =>
{
List<Tuple<PointPrediction, Dictionary<string, double>>> threadPointPredictionIncidentScore = new List<Tuple<PointPrediction, Dictionary<string, double>>>((int)((pointPredictions.Count / (float)Configuration.ProcessorCount) + 1));
for (int j = (int)core; j < pointPredictions.Count; j += Configuration.ProcessorCount)
{
PointPrediction pointPrediction = pointPredictions[j];
Dictionary<PointPrediction, double> neighborInvDist = new Dictionary<PointPrediction, double>();
foreach (PointPrediction neighbor in pointPredictions)
{
double distance = idPoint[pointPrediction.PointId].Location.DistanceTo(idPoint[neighbor.PointId].Location);
if (pointPrediction == neighbor || (distance >= _minimum && distance <= _maximum))
neighborInvDist.Add(neighbor, _maximum - distance);
}
double totalInvDistance = neighborInvDist.Values.Sum();
Dictionary<string, double> incidentScore = new Dictionary<string, double>(pointPrediction.IncidentScore.Count);
foreach (string incident in pointPrediction.IncidentScore.Keys)
incidentScore.Add(incident, neighborInvDist.Keys.Sum(neighbor => (neighborInvDist[neighbor] / totalInvDistance) * neighbor.IncidentScore[incident]));
threadPointPredictionIncidentScore.Add(new Tuple<PointPrediction, Dictionary<string, double>>(pointPrediction, incidentScore));
}
lock (pointPredictionIncidentScore) { pointPredictionIncidentScore.AddRange(threadPointPredictionIncidentScore); }
}));
t.Start(i);
threads.Add(t);
}
foreach (Thread t in threads)
t.Join();
foreach (Tuple<PointPrediction, Dictionary<string, double>> pointPredictionScores in pointPredictionIncidentScore)
{
pointPredictionScores.Item1.IncidentScore = pointPredictionScores.Item2;
pointPredictionScores.Item1.TotalThreat = pointPredictionScores.Item2.Values.Sum();
}
PointPrediction.UpdateThreatScores(pointPredictions, prediction);
prediction.SmoothingDetails = GetSmoothingDetails();
}
}
public void ChangeMode(Algorithm algorithm)
{
switch (algorithm)
{
case Algorithm.AGL:
absoluteGaussianPair = absoluteLetterGaussianPair;
prediction = Absolute;
break;
case Algorithm.AGK:
absoluteGaussianPair = absoluteKeyboardGaussianPair;
prediction = Absolute;
break;
case Algorithm.RGK:
absoluteGaussianPair = absoluteKeyboardGaussianPair;
relativeGaussianPair = relativeKeyboardGaussianPair;
prediction = Relative;
break;
}
}
public override void Apply(Prediction prediction)
{
List<PointPrediction> pointPredictions = prediction.PointPredictions;
if (pointPredictions.Count > 0)
{
Dictionary<int, Point> idPoint = new Dictionary<int, Point>();
foreach (Point p in prediction.Points)
idPoint.Add(p.Id, p);
IEnumerable<PostGIS.Point> kdeEvalPoints = pointPredictions.Select(p => idPoint[p.PointId].Location);
List<PostGIS.Point> kdeInputPoints = new List<PostGIS.Point>();
foreach (string incident in pointPredictions[0].IncidentScore.Keys.ToArray())
if (incident != PointPrediction.NullLabel)
{
double minScore = pointPredictions.Min(p => p.IncidentScore[incident]);
kdeInputPoints.Clear();
foreach (PointPrediction pointPrediction in pointPredictions)
{
PostGIS.Point pointPredictionLocation = idPoint[pointPrediction.PointId].Location;
double replicates = pointPrediction.IncidentScore[incident] / minScore;
for (int i = 0; i < replicates; ++i)
kdeInputPoints.Add(pointPredictionLocation);
}
List<float> density = KernelDensityDCM.GetDensityEstimate(kdeInputPoints, _sampleSize, false, 0, 0, kdeEvalPoints, _normalize);
for (int i = 0; i < density.Count; ++i)
pointPredictions[i].IncidentScore[incident] = density[i];
}
foreach (PointPrediction pointPrediction in pointPredictions)
pointPrediction.TotalThreat = pointPrediction.IncidentScore.Keys.Sum(incident => incident == PointPrediction.NullLabel ? 0 : pointPrediction.IncidentScore[incident]);
PointPrediction.UpdateThreatScores(pointPredictions, prediction);
}
prediction.SmoothingDetails = GetSmoothingDetails();
}
public static Prediction BuildPrediction(XElement predictionElement)
{
var result = new Prediction
{
Seconds = predictionElement.GetAttributeValue(NextBusName.Seconds, int.Parse),
Minutes = predictionElement.GetAttributeValue(NextBusName.Minutes, int.Parse),
IsDeparture = predictionElement.GetAttributeValue(NextBusName.IsDeparture, bool.Parse),
AffectedByLayover = predictionElement.GetAttributeValue(NextBusName.AffectedByLayover, bool.Parse),
DirectionTag = predictionElement.GetAttributeValue(NextBusName.DirectionTag),
Block = predictionElement.GetAttributeValue(NextBusName.Block),
VehicleId = predictionElement.GetAttributeValue(NextBusName.VehicleId)
};
var epochAttribute = predictionElement.Attribute(NextBusName.EpochTime);
if (epochAttribute != null)
{
var epochTime = predictionElement.GetAttributeValue(NextBusName.EpochTime, long.Parse);
result.DateTimeUtc = UnixTime.ToDateTimeFrom(epochTime);
}
return result;
}
protected void cmdAdd_Click(object sender, EventArgs e)
{
string _topic = Topic.Value;
string _description = Description.Value;
int _categoryID = Int32.Parse(Category.SelectedValue);
Facebook.Schema.user u = Master.Api.Users.GetInfo();
Prediction prediction = new Prediction();
prediction.InsertDate = DateTime.Now;
prediction.UserFaceID = u.uid.ToString();
prediction.IsActive = true;
prediction.RateID = 1;
prediction.Topic = _topic;
prediction.Description = _description;
prediction.CategoryID = _categoryID;
repository.Add(prediction);
try
{
repository.Save();
}
catch (Exception)
{
Response.Write("Error add prediction");
}
}
public int Calcuate(int a, int b)
{
var engine = Python.CreateEngine();
var code =
"prediction.Result = features.A + features.B + features.C * features.TimeStep";
var script = engine.CreateScriptSourceFromString(code);
var scope = engine.CreateScope();
var features = new Features
{
A = a,
B = b
};
scope.SetVariable("features", features);
var prediction = new Prediction();
scope.SetVariable("prediction", prediction);
var result = script.Execute(scope);
var test = scope.GetVariable<Prediction>("prediction");
return test.Result;
}
partial void DeletePrediction(Prediction instance);
public override void OnPlayerControlTick()
{
if (!Host.IsServer)
{
return;
}
using (Prediction.Off())
{
var input = Owner.Input;
bool useRope = input.Pressed(InputButton.Attack1);
if (!useRope && !input.Pressed(InputButton.Attack2))
{
return;
}
var startPos = Owner.EyePos;
var dir = Owner.EyeRot.Forward;
var tr = Trace.Ray(startPos, startPos + dir * MaxTraceDistance)
.Ignore(Owner)
.Run();
if (!tr.Hit || !tr.Entity.IsValid())
{
return;
}
if (tr.Entity is LightEntity)
{
// TODO: Set properties
return;
}
var light = new LightEntity
{
Enabled = true,
DynamicShadows = false,
Range = 128,
Falloff = 1.0f,
LinearAttenuation = 0.0f,
QuadraticAttenuation = 1.0f,
Brightness = 1,
Color = Color.Random,
};
light.UseFogNoShadows();
light.SetModel(Model);
light.SetupPhysicsFromModel(PhysicsMotionType.Dynamic, false);
light.WorldPos = tr.EndPos + -light.CollisionBounds.Center + tr.Normal * light.CollisionBounds.Size * 0.5f;
if (useRope)
{
var rope = Particles.Create("particles/rope.vpcf");
rope.SetEntity(0, light, Vector3.Down * 6.5f); // Should be an attachment point
var attachEnt = tr.Body.IsValid() ? tr.Body.Entity : tr.Entity;
var attachLocalPos = tr.Body.Transform.PointToLocal(tr.EndPos);
if (attachEnt.IsWorld)
{
rope.SetPos(1, attachLocalPos);
}
else
{
rope.SetEntityBone(1, attachEnt, tr.Bone, new Transform(attachLocalPos));
}
light.AttachRope = rope;
light.AttachJoint = PhysicsJoint.Spring
.From(light.PhysicsBody)
.To(tr.Body)
.WithPivot(light.WorldPos + Vector3.Down * 6.5f)
.WithFrequency(5.0f)
.WithDampingRatio(0.7f)
.WithReferenceMass(0)
.WithMinRestLength(0)
.WithMaxRestLength(100)
.WithCollisionsEnabled()
.Create();
}
}
}
private int TargetHitWithR()
{
if (!R.IsReady() || _ekkoPast == null)
{
return(0);
}
return(HeroManager.Enemies.Where(x => x.IsValidTarget()).Count(x => _ekkoPast.Distance(Prediction.GetPrediction(x, .2f).UnitPosition) < 400));
}
public static Dictionary<long, Dictionary<string, int>> GetSliceLocationTrueCount(IEnumerable<Incident> incidents, Prediction prediction)
{
Dictionary<long, Dictionary<string, int>> sliceLocationTrueCount = new Dictionary<long, Dictionary<string, int>>();
DiscreteChoiceModel model = prediction.Model;
long sliceTicks = -1;
if (model is TimeSliceDCM)
sliceTicks = (model as TimeSliceDCM).TimeSliceTicks;
foreach (Incident incident in incidents)
{
long slice = 1;
if (sliceTicks > 0)
slice = incident.Time.Ticks / sliceTicks;
int row = (int)((incident.Location.Y - prediction.PredictionArea.BoundingBox.MinY) / prediction.PredictionPointSpacing);
int col = (int)((incident.Location.X - prediction.PredictionArea.BoundingBox.MinX) / prediction.PredictionPointSpacing);
string location = row + "-" + col;
sliceLocationTrueCount.EnsureContainsKey(slice, typeof(Dictionary<string, int>));
sliceLocationTrueCount[slice].EnsureContainsKey(location, typeof(int));
sliceLocationTrueCount[slice][location]++;
}
return sliceLocationTrueCount;
}
internal abstract string GetDetails(Prediction prediction, Dictionary<string, string> attFeatureIdInformation);
public static void VacuumTable(Prediction prediction)
{
DB.Connection.ExecuteNonQuery("VACUUM ANALYZE " + GetTableName(prediction));
}
private void CastMecR(bool forceUlt)
{
//check if only one target
if (countEnemiesNearPosition(Player.ServerPosition, R.Range + 500) < 2 && forceUlt)
{
CastSingleR();
return;
}
int maxHit = 0;
Vector3 start = Vector3.Zero;
Vector3 end = Vector3.Zero;
//loop one
foreach (var target in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(R.Range)).OrderByDescending(GetComboDamage))
{
//loop 2
foreach (var enemy in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(R.Range + 1000) && x.NetworkId != target.NetworkId && x.Distance(target) < 900)
.OrderByDescending(x => x.Distance(target)))
{
int hit = 2;
var targetPred = Prediction.GetPrediction(target, .25f);
var enemyPred = Prediction.GetPrediction(enemy, .25f);
var midpoint = (enemyPred.CastPosition + targetPred.CastPosition) / 2;
var startpos = midpoint + Vector3.Normalize(enemyPred.CastPosition - targetPred.CastPosition) * 600;
var endPos = midpoint - Vector3.Normalize(enemyPred.CastPosition - targetPred.CastPosition) * 600;
if (!IsPassWall(midpoint, startpos) && !IsPassWall(midpoint, endPos) && countEnemiesNearPosition(Player.ServerPosition, R.Range + 1000) > 2)
{
//loop 3
foreach (var enemy2 in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(R.Range + 1000) && x.NetworkId != target.NetworkId && x.NetworkId != enemy.NetworkId && x.Distance(target) < 1000))
{
var enemy2Pred = Prediction.GetPrediction(enemy2, .25f);
Object[] obj = VectorPointProjectionOnLineSegment(startpos.To2D(), endPos.To2D(), enemy2Pred.CastPosition.To2D());
var isOnseg = (bool)obj[2];
var pointLine = (Vector2)obj[1];
if (pointLine.Distance(enemy2Pred.CastPosition.To2D()) < 110 && isOnseg)
{
hit++;
}
}
}
if (hit > maxHit && hit > 1)
{
maxHit = hit;
start = startpos;
end = endPos;
}
}
}
if (start != Vector3.Zero && end != Vector3.Zero && R.IsReady())
{
if (forceUlt)
{
CastR(start, end);
}
if (menu.Item("ComboActive").GetValue <KeyBind>().Active&& maxHit >= menu.Item("R_If_Enemy_Count_Combo").GetValue <Slider>().Value)
{
CastR(start, end);
}
if (maxHit >= menu.Item("R_If_Enemy_Count").GetValue <Slider>().Value)
{
CastR(start, end);
}
}
}
public void svmproject(Dictionary <int, Characteristic> Characteristics)
{
Dictionary <int, Characteristic> _characteristics = new Dictionary <int, Characteristic>();
_characteristics = Characteristics;
Model model;
RangeTransform range;
double C;
double gamma;
// default values
Parameter parameters = new Parameter();
//parameters.SvmType = SvmType.C_SVC;
//parameters.KernelType = KernelType.RBF;
//parameters.Degree = 3;
//parameters.Gamma = 0;
//parameters.Coefficient0 = 0;
//parameters.Nu = 0.5;
//parameters.CacheSize = 40;
//parameters.C = 1000;
//parameters.EPS = 1e-3;
//parameters.P = 0.1;
//parameters.Shrinking = true;
//parameters.WeightCount = 0;
//parameters.WeightLabels = new int[0];
//parameters.Weights = new double[0];
//parameters.C = 5;
//parameters.Gamma = 1;
string str = null;
for (int i = 1; i < _characteristics.Count(); i++)
{
if (_characteristics[i].IsQualifiedColony == false && _characteristics[i].IsInvalidColony == true)
{
str = str + "0";
str = str + " 1:" + _characteristics[i].Area.ToString() + " 2:" + _characteristics[i].MajToMinAxisRatio.ToString() +
" 3:" + _characteristics[i].CentreAcerageColor.R.ToString() + " 4:" + _characteristics[i].CentreAcerageColor.G.ToString()
+ " 5:" + _characteristics[i].CentreAcerageColor.B.ToString() + "\r\n";
}
if (_characteristics[i].IsQualifiedColony == true && _characteristics[i].IsInvalidColony == false)
{
str = str + "1";
str = str + " 1:" + _characteristics[i].Area.ToString() + " 2:" + _characteristics[i].MajToMinAxisRatio.ToString() +
" 3:" + _characteristics[i].CentreAcerageColor.R.ToString() + " 4:" + _characteristics[i].CentreAcerageColor.G.ToString()
+ " 5:" + _characteristics[i].CentreAcerageColor.B.ToString() + "\r\n";
}
}
if (str != null)
{
byte[] array = Encoding.ASCII.GetBytes(str);
MemoryStream stream = new MemoryStream(array); //convert stream 2 string
Problem train = new Problem();
train = Problem.Read(stream);
range = Scaling.DetermineRange(train);
train = Scaling.Scale(train, range);
//String outfile001="D:\\parameters.txt";
ParameterSelection.Grid(train, parameters, @"D:\\parameters.txt", out C, out gamma);
parameters.C = C;
parameters.Gamma = gamma;
model = Training.Train(train, parameters);
//MessageBox.Show("学习完毕");
//stream.Dispose();
stream.Close();
}
else
{
MessageBox.Show("无学习数据");
model = null;
range = null;
}
string str1 = null;
for (int i = 1; i < _characteristics.Count(); i++)
{
str1 = str1 + "0";
str1 = str1 + " 1:" + _characteristics[i].Area.ToString() + " 2:" + _characteristics[i].MajToMinAxisRatio.ToString() +
" 3:" + _characteristics[i].CentreAcerageColor.R.ToString() + " 4:" + _characteristics[i].CentreAcerageColor.G.ToString()
+ " 5:" + _characteristics[i].CentreAcerageColor.B.ToString() + "\r\n";
}
if (str1 != null)
{
byte[] array = Encoding.ASCII.GetBytes(str1);
MemoryStream stream = new MemoryStream(array); //convert stream 2 string
Problem pre = new Problem();
pre = Problem.Read(stream);
pre = Scaling.Scale(pre, range);
Prediction.Predict(pre, @"D:\result.txt", model, false);
MessageBox.Show("筛选完毕");
//stream.Dispose();
stream.Close();
}
else
{
MessageBox.Show("无筛选数据");
}
//svm_problem prob = new svm_problem();
//prob.l = point_list.Count;
//prob.y = new double[prob.l];
// if(param.svm_type == svm_parameter.EPSILON_SVR ||
// param.svm_type == svm_parameter.NU_SVR)
//{
// if(param.gamma == 0) param.gamma = 1;
// prob.x = new svm_node[prob.l][];
// for(int i=0;i<prob.l;i++)
// {
// point p = (point)point_list[i];
// prob.x[i][0] = new svm_node();
// prob.x[i][0].index = 1;
// prob.x[i][0].value_Renamed = p.x;
// prob.y[i] = p.y;
// }
// svm_model model = svm.svm_train(prob, param);
// svm_node[] x = new svm_node[1];
// x[0] = new svm_node();
// x[0].index = 1;
// int[] j = new int[XLEN];
//C = Convert.ToInt16(numericUpDown8.Value);
//gamma = Convert.ToInt16(numericUpDown9.Value);
//StudyAlgorithm study = new StudyAlgorithm();
//study.GetModel(AllColony, C, gamma, out model, out range);
//ScreenAlgorithm screenAlgorithm = new ScreenAlgorithm();
//screenAlgorithm.ScreenTheColony(CharacteristicsValue, model, range);
}
public override void Simulate(Client client)
{
var owner = Owner;
if (owner == null)
{
return;
}
if (!IsServer)
{
return;
}
using (Prediction.Off())
{
var input = Input;
var eyePos = owner.EyePos;
var eyeRot = owner.EyeRot;
var eyeDir = owner.EyeRot.Forward;
if (HeldBody.IsValid() && HeldBody.PhysicsGroup != null)
{
if (holdJoint.IsValid() && !holdJoint.IsActive)
{
GrabEnd();
}
else if (input.Pressed(InputButton.Attack1))
{
if (HeldBody.PhysicsGroup.BodyCount > 1)
{
// Don't throw ragdolls as hard
HeldBody.PhysicsGroup.ApplyImpulse(eyeDir * (ThrowForce * 0.5f), true);
HeldBody.PhysicsGroup.ApplyAngularImpulse(Vector3.Random * ThrowForce, true);
}
else
{
HeldBody.ApplyImpulse(eyeDir * (HeldBody.Mass * ThrowForce));
HeldBody.ApplyAngularImpulse(Vector3.Random * (HeldBody.Mass * ThrowForce));
}
GrabEnd();
}
else if (input.Pressed(InputButton.Attack2))
{
timeSinceDrop = 0;
GrabEnd();
}
else
{
GrabMove(eyePos, eyeDir, eyeRot);
}
return;
}
if (timeSinceDrop < DropCooldown)
{
return;
}
var tr = Trace.Ray(eyePos, eyePos + eyeDir * MaxPullDistance)
.UseHitboxes()
.Ignore(owner)
.Radius(2.0f)
.HitLayer(CollisionLayer.Debris)
.Run();
if (!tr.Hit || !tr.Body.IsValid() || !tr.Entity.IsValid() || tr.Entity.IsWorld)
{
return;
}
if (tr.Entity.PhysicsGroup == null)
{
return;
}
var modelEnt = tr.Entity as ModelEntity;
if (!modelEnt.IsValid())
{
return;
}
var body = tr.Body;
if (input.Pressed(InputButton.Attack1))
{
if (tr.Distance < MaxPushDistance && !IsBodyGrabbed(body))
{
var pushScale = 1.0f - Math.Clamp(tr.Distance / MaxPushDistance, 0.0f, 1.0f);
body.ApplyImpulseAt(tr.EndPos, eyeDir * (body.Mass * (PushForce * pushScale)));
}
}
else if (input.Down(InputButton.Attack2))
{
var physicsGroup = tr.Entity.PhysicsGroup;
if (physicsGroup.BodyCount > 1)
{
body = modelEnt.PhysicsBody;
if (!body.IsValid())
{
return;
}
}
if (eyePos.Distance(body.Position) <= AttachDistance)
{
GrabStart(modelEnt, body, eyePos + eyeDir * HoldDistance, eyeRot);
}
else if (!IsBodyGrabbed(body))
{
physicsGroup.ApplyImpulse(eyeDir * -PullForce, true);
}
}
}
}
public static PassiveStatus GetPassiveStatus(this Obj_AI_Hero target, float delay = 0.25f)
{
var allobjects = GetPassiveObjects()
.Where(x => x.Object != null && x.Object.IsValid &&
x.Object.Position.To2D().Distance(target.Position.To2D()) <= 50);
var targetpredictedpos = Prediction.GetPrediction(target, delay).UnitPosition.To2D();
if (!allobjects.Any())
{
return(new PassiveStatus(false, PassiveType.None, new Vector2(), new List <PassiveDirection>(), new List <Vector2>()));
}
else
{
var x = allobjects.First();
var listdirections = new List <PassiveDirection>();
foreach (var a in allobjects)
{
listdirections.Add(a.PassiveDirection);
}
var listpositions = new List <Vector2>();
foreach (var a in listdirections)
{
if (a == PassiveDirection.NE)
{
var pos = targetpredictedpos;
pos.Y = pos.Y + 200;
listpositions.Add(pos);
}
else if (a == PassiveDirection.NW)
{
var pos = targetpredictedpos;
pos.X = pos.X + 200;
listpositions.Add(pos);
}
else if (a == PassiveDirection.SE)
{
var pos = targetpredictedpos;
pos.X = pos.X - 200;
listpositions.Add(pos);
}
else if (a == PassiveDirection.SW)
{
var pos = targetpredictedpos;
pos.Y = pos.Y - 200;
listpositions.Add(pos);
}
}
if (x.PassiveType == PassiveType.PrePassive)
{
return(new PassiveStatus(true, PassiveType.PrePassive, targetpredictedpos, listdirections, listpositions));
}
if (x.PassiveType == PassiveType.NormalPassive)
{
return(new PassiveStatus(true, PassiveType.NormalPassive, targetpredictedpos, listdirections, listpositions));
}
if (x.PassiveType == PassiveType.UltiPassive)
{
return(new PassiveStatus(true, PassiveType.UltiPassive, targetpredictedpos, listdirections, listpositions));
}
return(new PassiveStatus(false, PassiveType.None, new Vector2(), new List <PassiveDirection>(), new List <Vector2>()));
}
}
public override async Task ExecuteComboAsync(Unit target, CancellationToken tk = new CancellationToken())
{
var manta = this.MyHero.GetItemById(ItemId.item_manta);
if (!await this.MoveOrBlinkToEnemy(target, tk, 0, 150))
{
if (!this.MyHero.IsSilenced())
{
if (this._blinkAbility.IsAbilityEnabled() && this._blinkAbility.CanBeCasted(target) &&
this._blinkAbility.CanHit(target))
{
var usedManta = false;
if (manta != null && manta.IsAbilityEnabled() && manta.CanBeCasted() && this.MyHero.IsSilenced())
{
Log.Debug($"use manta 1 because silenced");
manta.UseAbility();
await Await.Delay(125, tk);
manta = null;
usedManta = true;
}
if (!usedManta)
{
if (this.MyHero.Distance2D(target) >= 350)
{
Vector3 pos;
if (!target.IsMoving)
{
pos = (target.NetworkPosition - this.MyHero.NetworkPosition).Normalized();
pos *= 100;
pos = target.NetworkPosition - pos;
}
else
{
pos = Prediction.InFront(target, 250);
}
Log.Debug($"jumping {pos}");
this._blinkAbility.UseAbility(pos);
await Await.Delay(this.GetAbilityDelay(pos, this._blinkAbility), tk);
if (manta != null && manta.IsAbilityEnabled() && manta.CanBeCasted())
{
Log.Debug($"use manta after blink");
manta.UseAbility();
await Await.Delay(125, tk);
}
}
}
}
}
}
await this.HasNoLinkens(target, tk);
await this.UseItems(target, tk);
await this.DisableEnemy(target, tk);
if (!this.MyHero.IsSilenced())
{
if (this._ultAbility.IsAbilityEnabled() && this._ultAbility.CanBeCasted())
{
var radius = this._ultAbility.GetAbilityData("mana_void_aoe_radius");
var damage = this._ultAbility.GetAbilityData("mana_void_damage_per_mana");
var spellAmp = this.GetSpellAmp();
var targetHealth = target.Health * (1.0f + target.MagicResistance());
var enemy =
ObjectManager.GetEntitiesParallel <Hero>()
.Where(
x =>
x.IsValid && x.IsAlive && x.IsVisible && x.Team != this.MyHero.Team &&
this._ultAbility.CanHit(x) && !x.IsLinkensProtected() &&
targetHealth < (x.MaximumMana - x.Mana) * damage * spellAmp &&
x.Distance2D(target) < radius)
.OrderByDescending(x => x.MaximumMana - x.Mana)
.FirstOrDefault();
if (enemy != null)
{
var useUlt = this.EnemyCountForUlt == 0;
if (!useUlt)
{
var enemyDamage = (enemy.MaximumMana - enemy.Mana) * damage * spellAmp;
var enemyCount =
ObjectManager.GetEntitiesParallel <Hero>()
.Count(
x =>
x.IsValid && x.IsAlive && x.IsVisible &&
x.Team != this.MyHero.Team && !x.IsIllusion &&
x.Health < enemyDamage * (1.0f - x.MagicResistance()) &&
x.Distance2D(enemy) < radius);
useUlt = this.EnemyCountForUlt <= enemyCount;
}
if (useUlt)
{
Log.Debug(
$"Kill it with fire {targetHealth} < {(enemy.MaximumMana - enemy.Mana) * damage * spellAmp}");
this._ultAbility.UseAbility(enemy);
await Await.Delay(this.GetAbilityDelay(enemy, this._ultAbility), tk);
}
}
}
}
if (ZaioMenu.ShouldUseOrbwalker)
{
this.Orbwalk();
}
var illusions =
ObjectManager.GetEntitiesParallel <Hero>()
.Where(
x =>
x.IsValid && x.IsAlive && x.IsIllusion && x.IsControllable && x.Team == this.MyHero.Team &&
x.Distance2D(this.MyHero) < 1000);
if (illusions.Any())
{
foreach (var illusion in illusions)
{
illusion.Attack(target);
}
await Await.Delay(125, tk);
}
}
public static void DrawBestLine(Spell spell, Spell spell2, int midPointRange, float extraPrerange = 1, bool wallCheck = true)
{
//---------------------------------MEC----------------------------
int maxHit = 0;
Vector3 start = Vector3.Zero;
Vector3 end = Vector3.Zero;
//loop one
foreach (var target in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(spell.Range)))
{
//loop 2
var target1 = target;
var target2 = target;
foreach (var enemy in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(spell.Range + spell2.Range) && x.NetworkId != target1.NetworkId &&
x.Distance(target1.Position) < spell2.Range - 100).OrderByDescending(x => x.Distance(target2.Position)))
{
int hit = 2;
var targetPred = Prediction.GetPrediction(target, spell.Delay);
var enemyPred = Prediction.GetPrediction(enemy, spell.Delay);
var midpoint = (enemyPred.CastPosition + targetPred.CastPosition) / 2;
var startpos = midpoint + Vector3.Normalize(enemyPred.CastPosition - targetPred.CastPosition) * midPointRange;
var endPos = midpoint - Vector3.Normalize(enemyPred.CastPosition - targetPred.CastPosition) * midPointRange;
Geometry.Polygon.Rectangle rec1 = new Geometry.Polygon.Rectangle(startpos, endPos, spell.Width);
if (!rec1.Points.Exists(Util.IsWall) && Player.CountEnemiesInRange(spell.Range + spell2.Range) > 2)
{
//loop 3
var target3 = target;
var enemy1 = enemy;
foreach (var enemy2 in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(spell.Range + spell2.Range) && x.NetworkId != target3.NetworkId && x.NetworkId != enemy1.NetworkId && x.Distance(target3.Position) < spell2.Range))
{
var enemy2Pred = Prediction.GetPrediction(enemy2, spell.Delay);
Object[] obj = Util.VectorPointProjectionOnLineSegment(startpos.To2D(), endPos.To2D(), enemy2Pred.CastPosition.To2D());
var isOnseg = (bool)obj[2];
var pointLine = (Vector2)obj[1];
if (pointLine.Distance(enemy2Pred.CastPosition.To2D()) < spell.Width && isOnseg)
{
hit++;
}
}
}
if (hit > maxHit && hit > 1 && !rec1.Points.Exists(Util.IsWall))
{
maxHit = hit;
start = startpos;
end = endPos;
}
}
}
if (maxHit >= 2)
{
Vector2 wts = Drawing.WorldToScreen(Player.Position);
Drawing.DrawText(wts[0], wts[1], Color.Wheat, "Hit: " + maxHit);
Geometry.Polygon.Rectangle rec1 = new Geometry.Polygon.Rectangle(start, end, spell.Width);
rec1.Draw(Color.Blue, 4);
}
else
{
//-------------------------------Single---------------------------
var target = TargetSelector.GetTarget(spell.Range + spell2.Range, TargetSelector.DamageType.Magical);
if (target == null)
{
return;
}
var vector1 = Player.ServerPosition + Vector3.Normalize(target.ServerPosition - Player.ServerPosition) * (spell.Range * extraPrerange);
var pred = Prediction.GetPrediction(target, spell.Delay);
Geometry.Polygon.Rectangle rec1 = new Geometry.Polygon.Rectangle(vector1, vector1.Extend(pred.CastPosition, spell2.Range), spell.Width);
if (Player.Distance(target) < spell.Range)
{
vector1 = pred.CastPosition.Extend(target.ServerPosition, spell2.Range * .3f);
Geometry.Polygon.Rectangle rec2 = new Geometry.Polygon.Rectangle(vector1, vector1.Extend(pred.CastPosition, spell2.Range), spell.Width);
if ((!rec2.Points.Exists(Util.IsWall) || !wallCheck) && pred.Hitchance >= HitChance.Medium && target.IsMoving)
{
Vector2 wts = Drawing.WorldToScreen(Player.Position);
Drawing.DrawText(wts[0], wts[1], Color.Wheat, "Hit: " + 1);
rec2.Draw(Color.Blue, 4);
}
}
else if (!rec1.Points.Exists(Util.IsWall) || !wallCheck)
{
//wall check
if (pred.Hitchance >= HitChance.High)
{
Vector2 wts = Drawing.WorldToScreen(Player.Position);
Drawing.DrawText(wts[0], wts[1], Color.Wheat, "Hit: " + 1);
rec1.Draw(Color.Blue, 4);
}
}
}
}
/// <summary>
/// Create a new prediction.
/// </summary>
public Task<Prediction> Create(Prediction.Arguments arguments)
{
return Create<Prediction>(arguments);
}
public static void CastBestLine(bool forceUlt, Spell spell, Spell spell2, int midPointRange, Menu menu, float extraPrerange = 1, bool wallCheck = true)
{
if (!spell.IsReady())
{
return;
}
int maxHit = 0;
Vector3 start = Vector3.Zero;
Vector3 end = Vector3.Zero;
//loop one
foreach (var target in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(spell.Range)))
{
//loop 2
var target1 = target;
var target2 = target;
foreach (var enemy in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(spell.Range + spell2.Range) && x.NetworkId != target1.NetworkId &&
x.Distance(target1.Position) < spell2.Range - 100).OrderByDescending(x => x.Distance(target2.Position)))
{
int hit = 2;
var targetPred = Prediction.GetPrediction(target, spell.Delay);
var enemyPred = Prediction.GetPrediction(enemy, spell.Delay);
var midpoint = (enemyPred.CastPosition + targetPred.CastPosition) / 2;
var startpos = midpoint + Vector3.Normalize(enemyPred.CastPosition - targetPred.CastPosition) * midPointRange;
var endPos = midpoint - Vector3.Normalize(enemyPred.CastPosition - targetPred.CastPosition) * midPointRange;
Geometry.Polygon.Rectangle rec1 = new Geometry.Polygon.Rectangle(startpos, endPos, spell.Width);
if (!rec1.Points.Exists(Util.IsWall) && Player.CountEnemiesInRange(spell.Range + spell2.Range) > 2)
{
//loop 3
var target3 = target;
var enemy1 = enemy;
foreach (var enemy2 in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(spell.Range + spell2.Range) && x.NetworkId != target3.NetworkId && x.NetworkId != enemy1.NetworkId && x.Distance(target3.Position) < 1000))
{
var enemy2Pred = Prediction.GetPrediction(enemy2, spell.Delay);
Object[] obj = Util.VectorPointProjectionOnLineSegment(startpos.To2D(), endPos.To2D(), enemy2Pred.CastPosition.To2D());
var isOnseg = (bool)obj[2];
var pointLine = (Vector2)obj[1];
if (pointLine.Distance(enemy2Pred.CastPosition.To2D()) < spell.Width && isOnseg)
{
hit++;
}
}
}
if (hit > maxHit && hit > 1 && !rec1.Points.Exists(Util.IsWall))
{
maxHit = hit;
start = startpos;
end = endPos;
}
}
}
if (start != Vector3.Zero && end != Vector3.Zero && spell.IsReady())
{
spell2.UpdateSourcePosition(start, start);
if (forceUlt)
{
CastLineSpell(start, end);
}
if (menu.Item("ComboActive", true).GetValue <KeyBind>().Active&& maxHit >= menu.Item("Line_If_Enemy_Count_Combo", true).GetValue <Slider>().Value)
{
CastLineSpell(start, end);
}
if (maxHit >= menu.Item("Line_If_Enemy_Count", true).GetValue <Slider>().Value)
{
CastLineSpell(start, end);
}
}
//check if only one target
if (forceUlt)
{
CastSingleLine(spell, spell2, wallCheck, extraPrerange);
}
}
public override void Drawing_OnDraw(EventArgs args)
{
if (menu.Item("Draw_Disabled").GetValue <bool>())
{
return;
}
if (menu.Item("Draw_Q").GetValue <bool>())
{
if (Q.Level > 0)
{
Utility.DrawCircle(Player.Position, Q.Range, Q.IsReady() ? Color.Green : Color.Red);
}
}
if (menu.Item("Draw_W").GetValue <bool>())
{
if (W.Level > 0)
{
Utility.DrawCircle(Player.Position, W.Range - 2, W.IsReady() ? Color.Green : Color.Red);
}
}
if (menu.Item("Draw_E").GetValue <bool>())
{
if (E.Level > 0)
{
Utility.DrawCircle(Player.Position, E.Range, E.IsReady() ? Color.Green : Color.Red);
}
}
if (menu.Item("Draw_R").GetValue <bool>())
{
if (R.Level > 0)
{
Utility.DrawCircle(Player.Position, R.Range, R.IsReady() ? Color.Green : Color.Red);
}
}
if (menu.Item("Draw_R_Pred").GetValue <bool>() && R.IsReady())
{
if (countEnemiesNearPosition(Player.ServerPosition, R.Range + 500) < 2)
{
var target = SimpleTs.GetTarget(R.Range, SimpleTs.DamageType.Magical);
if (target == null)
{
return;
}
var vector1 = target.ServerPosition - Vector3.Normalize(target.ServerPosition - Player.ServerPosition) * 300;
_r2.UpdateSourcePosition(vector1, vector1);
var pred = _r2.GetPrediction(target, true);
var midpoint = (Player.ServerPosition + pred.UnitPosition) / 2;
var vector2 = midpoint - Vector3.Normalize(pred.UnitPosition - Player.ServerPosition) * 300;
if (Player.Distance(target) < 400)
{
vector1 = midpoint + Vector3.Normalize(pred.UnitPosition - Player.ServerPosition) * 800;
if (!IsPassWall(pred.UnitPosition, vector1) && !IsPassWall(pred.UnitPosition, vector2))
{
Vector2 wts = Drawing.WorldToScreen(Player.Position);
Drawing.DrawText(wts[0], wts[1], Color.Wheat, "Hit: " + 1);
Vector2 wtsPlayer = Drawing.WorldToScreen(vector1);
Vector2 wtsPred = Drawing.WorldToScreen(vector2);
Drawing.DrawLine(wtsPlayer, wtsPred, 1, Color.Wheat);
Utility.DrawCircle(vector1, 50, Color.Aqua);
Utility.DrawCircle(vector2, 50, Color.Yellow);
Utility.DrawCircle(pred.UnitPosition, 50, Color.Red);
}
}
else if (!IsPassWall(pred.UnitPosition, vector1) && !IsPassWall(pred.UnitPosition, pred.CastPosition))
{
if (pred.Hitchance >= HitChance.Medium)
{
Vector2 wts = Drawing.WorldToScreen(Player.Position);
Drawing.DrawText(wts[0], wts[1], Color.Wheat, "Hit: " + 1);
Vector2 wtsPlayer = Drawing.WorldToScreen(vector1);
Vector2 wtsPred = Drawing.WorldToScreen(pred.CastPosition);
Drawing.DrawLine(wtsPlayer, wtsPred, 1, Color.Wheat);
Utility.DrawCircle(vector1, 50, Color.Aqua);
Utility.DrawCircle(pred.CastPosition, 50, Color.Yellow);
}
}
return;
}
//-----------------------------------------------------------------Draw Ult Mec-----------------------------------------------
int maxHit = 0;
Vector3 start = Vector3.Zero;
Vector3 end = Vector3.Zero;
Vector3 mid = Vector3.Zero;
//loop one
foreach (var target in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(R.Range)).OrderByDescending(GetComboDamage))
{
//loop 2
foreach (
var enemy in
ObjectManager.Get <Obj_AI_Hero>()
.Where(
x =>
x.IsValidTarget(R.Range + 1000) && x.NetworkId != target.NetworkId &&
x.Distance(target) < 900)
.OrderByDescending(x => x.Distance(target)))
{
int hit = 2;
var targetPred = Prediction.GetPrediction(target, .25f);
var enemyPred = Prediction.GetPrediction(enemy, .25f);
var midpoint = (enemyPred.CastPosition + targetPred.CastPosition) / 2;
var startpos = midpoint + Vector3.Normalize(enemyPred.CastPosition - targetPred.CastPosition) * 600;
var endPos = midpoint - Vector3.Normalize(enemyPred.CastPosition - targetPred.CastPosition) * 600;
if (!IsPassWall(midpoint, startpos) && !IsPassWall(midpoint, endPos) && countEnemiesNearPosition(Player.ServerPosition, R.Range + 1000) > 2)
{
//loop 3
foreach (var enemy2 in ObjectManager.Get <Obj_AI_Hero>().Where(x => x.IsValidTarget(R.Range + 1000) && x.NetworkId != target.NetworkId && x.NetworkId != enemy.NetworkId && x.Distance(target) < 1000))
{
var enemy2Pred = Prediction.GetPrediction(enemy2, .25f);
Object[] obj = VectorPointProjectionOnLineSegment(startpos.To2D(), endPos.To2D(), enemy2Pred.CastPosition.To2D());
var isOnseg = (bool)obj[2];
var pointLine = (Vector2)obj[1];
if (pointLine.Distance(enemy2Pred.CastPosition.To2D()) < 100 + enemy2.BoundingRadius &&
isOnseg)
{
hit++;
}
}
}
if (hit > maxHit)
{
maxHit = hit;
start = startpos;
end = endPos;
mid = midpoint;
}
}
}
if (maxHit >= 2)
{
Vector2 wts = Drawing.WorldToScreen(Player.Position);
Drawing.DrawText(wts[0], wts[1], Color.Wheat, "Hit: " + maxHit);
Vector2 wtsPlayer = Drawing.WorldToScreen(start);
Vector2 wtsPred = Drawing.WorldToScreen(end);
Drawing.DrawLine(wtsPlayer, wtsPred, 1, Color.Wheat);
Utility.DrawCircle(start, 50, Color.Aqua);
Utility.DrawCircle(end, 50, Color.Yellow);
Utility.DrawCircle(mid, 50, Color.Red);
}
//---------------------------------------------------End drawing Ult Mec---------------------------------------
}
}
/// <summary>
/// Discover what is relevant by retroactively predicting and measuring, rather than using correlation
/// </summary>
private static void CrystalBall()
{
var lastGames = _gameRepository.GetLastResultedGames(100);
var predictions = new List<Prediction>();
var homeAwayPredictions = new List<Prediction>();
var positiveStats = new Statline().PositiveStats;
var negativeStats = new Statline().NegativeStats;
foreach (var game in lastGames)
{
// get team statlines for date before game date
var gameStatlines = _statlineRepository.GetStatlinesForGame(game);
Game game1 = game;
var home = gameStatlines.Single(s => s.Team == game1.HomeTeam);
var away = gameStatlines.Single(s => s.Team == game1.AwayTeam);
var actualWinner = game1.HomeScore > game1.AwayScore ? home.Team : away.Team;
// REVISIT: Extend variables to have positive/negative. Write a comparison function that checks these
foreach (var variable in positiveStats)
{
predictions.Add(new Prediction
{
GameId = game.Id,
PredictedWinner = home.GetByName(variable.Name) > away.GetByName(variable.Name) ? home.Team : away.Team,
ActualWinner = actualWinner,
});
}
foreach (var variable in negativeStats)
{
predictions.Add(new Prediction
{
GameId = game.Id,
PredictedWinner = home.GetByName(variable.Name) < away.GetByName(variable.Name) ? home.Team : away.Team,
ActualWinner = actualWinner,
});
}
var homeAwayPrediction = new Prediction
{
GameId = game.Id,
PredictedWinner = home.HomeWins > away.AwayWins ? home.Team : away.Team,
ActualWinner = actualWinner,
};
predictions.Add(homeAwayPrediction);
homeAwayPredictions.Add(homeAwayPrediction);
}
Console.WriteLine("Crystal ball performance: {0}/{1} = {2}%",
predictions.Count(p => p.PredictedWinner == p.ActualWinner),
predictions.Count,
Math.Round((double) (predictions.Count(p => p.PredictedWinner == p.ActualWinner) / predictions.Count * 100), 2)
);
Console.WriteLine("Crystal ball home & away performance: {0}/{1} = {2}%",
homeAwayPredictions.Count(p => p.PredictedWinner == p.ActualWinner),
homeAwayPredictions.Count,
Math.Round((double)(homeAwayPredictions.Count(p => p.PredictedWinner == p.ActualWinner) / homeAwayPredictions.Count * 100), 2)
);
}
private void Combo()
{
Obj_AI_Hero target = TargetSelector.GetTarget(
E.Range, TargetSelector.DamageType.Physical, true, HeroManager.Enemies.Where(h => h.IsInvulnerable));
if (target == null)
{
return;
}
var ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
if (config.Item("useIgnite", true).GetValue <bool>() &&
ignitedmg > HealthPrediction.GetHealthPrediction(target, 700) && hasIgnite &&
!CombatHelper.CheckCriticalBuffs(target) && !Q.IsReady() && !justQ)
{
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
}
if (config.Item("usew", true).GetValue <Slider>().Value > player.HealthPercent &&
player.CountEnemiesInRange(500) > 0)
{
W.Cast();
}
if (R.IsReady() && config.Item("user", true).GetValue <bool>())
{
var Rtarget =
HeroManager.Enemies.FirstOrDefault(e => e.HealthPercent < 50 && e.CountAlliesInRange(660) > 0);
if (Rtarget != null)
{
R.CastIfWillHit(Rtarget, config.Item("Rmin", true).GetValue <Slider>().Value);
}
}
if (config.Item("useItems").GetValue <bool>())
{
ItemHandler.UseItems(target, config, ComboDamage(target), config.Item("AutoW", true).GetValue <bool>());
}
var barrels =
GetBarrels()
.Where(
o =>
o.IsValid && !o.IsDead && o.Distance(player) < 1600 && o.SkinName == "GangplankBarrel" &&
o.GetBuff("gangplankebarrellife").Caster.IsMe)
.ToList();
if (config.Item("useq", true).GetValue <bool>() && Q.IsReady() && config.Item("usee", true).GetValue <bool>() &&
E.IsReady() && Orbwalking.CanMove(100) && !justE)
{
var Qbarrels = GetBarrels().Where(o => o.Distance(player) < Q.Range && KillableBarrel(o));
foreach (var Qbarrel in Qbarrels)
{
if (Qbarrel.Distance(target) < BarrelExplosionRange)
{
continue;
}
var point =
GetBarrelPoints(Qbarrel.Position)
.Where(
p =>
p.IsValid() && !p.IsWall() && p.Distance(player.Position) < E.Range &&
p.Distance(Prediction.GetPrediction(target, GetQTime(Qbarrel)).UnitPosition) <
BarrelExplosionRange &&
savedBarrels.Count(b => b.barrel.Position.Distance(p) < BarrelExplosionRange) < 1)
.OrderBy(p => p.Distance(target.Position))
.FirstOrDefault();
if (point != null)
{
E.Cast(point);
Utility.DelayAction.Add(1, () => Q.CastOnUnit(Qbarrel));
return;
}
}
}
if (config.Item("usee", true).GetValue <bool>() && E.IsReady() && player.Distance(target) < E.Range && !justE &&
target.Health > Q.GetDamage(target) + player.GetAutoAttackDamage(target) && Orbwalking.CanMove(100) &&
config.Item("eStacksC", true).GetValue <Slider>().Value < E.Instance.Ammo)
{
CastE(target, barrels);
}
var meleeRangeBarrel =
barrels.FirstOrDefault(
b =>
(b.Health < 2 || (b.Health == 2 && Q.IsReady())) &&
b.Distance(player) < Orbwalking.GetAutoAttackRange(player, b) &&
b.CountEnemiesInRange(BarrelExplosionRange) > 0);
if (meleeRangeBarrel != null && Orbwalking.CanMove(100))
{
player.IssueOrder(GameObjectOrder.AutoAttack, meleeRangeBarrel);
}
if (Q.IsReady())
{
if (barrels.Any())
{
var detoneateTargetBarrels = barrels.Where(b => b.Distance(player) < Q.Range);
if (config.Item("detoneateTarget", true).GetValue <bool>())
{
if (detoneateTargetBarrels.Any())
{
foreach (var detoneateTargetBarrel in detoneateTargetBarrels)
{
if (!KillableBarrel(detoneateTargetBarrel))
{
continue;
}
if (
detoneateTargetBarrel.Distance(
Prediction.GetPrediction(target, GetQTime(detoneateTargetBarrel)).UnitPosition) <
BarrelExplosionRange &&
target.Distance(detoneateTargetBarrel.Position) < BarrelExplosionRange)
{
Q.CastOnUnit(detoneateTargetBarrel, config.Item("packets").GetValue <bool>());
return;
}
var detoneateTargetBarrelSeconds =
barrels.Where(b => b.Distance(detoneateTargetBarrel) < BarrelConnectionRange);
if (detoneateTargetBarrelSeconds.Any())
{
foreach (var detoneateTargetBarrelSecond in detoneateTargetBarrelSeconds)
{
if (
detoneateTargetBarrelSecond.Distance(
Prediction.GetPrediction(
target, GetQTime(detoneateTargetBarrel) + 0.15f).UnitPosition) <
BarrelExplosionRange &&
target.Distance(detoneateTargetBarrelSecond.Position) < BarrelExplosionRange)
{
Q.CastOnUnit(detoneateTargetBarrel, config.Item("packets").GetValue <bool>());
return;
}
}
}
}
}
if (config.Item("detoneateTargets", true).GetValue <Slider>().Value > 1)
{
var enemies =
HeroManager.Enemies.Where(e => e.IsValidTarget() && e.Distance(player) < 600)
.Select(e => Prediction.GetPrediction(e, 0.25f));
var enemies2 =
HeroManager.Enemies.Where(e => e.IsValidTarget() && e.Distance(player) < 600)
.Select(e => Prediction.GetPrediction(e, 0.35f));
if (detoneateTargetBarrels.Any())
{
foreach (var detoneateTargetBarrel in detoneateTargetBarrels)
{
if (!KillableBarrel(detoneateTargetBarrel))
{
continue;
}
var enemyCount =
enemies.Count(
e =>
e.UnitPosition.Distance(detoneateTargetBarrel.Position) <
BarrelExplosionRange);
if (enemyCount >= config.Item("detoneateTargets", true).GetValue <Slider>().Value&&
detoneateTargetBarrel.CountEnemiesInRange(BarrelExplosionRange) >=
config.Item("detoneateTargets", true).GetValue <Slider>().Value)
{
Q.CastOnUnit(detoneateTargetBarrel, config.Item("packets").GetValue <bool>());
return;
}
var detoneateTargetBarrelSeconds =
barrels.Where(b => b.Distance(detoneateTargetBarrel) < BarrelConnectionRange);
if (detoneateTargetBarrelSeconds.Any())
{
foreach (var detoneateTargetBarrelSecond in detoneateTargetBarrelSeconds)
{
if (enemyCount +
enemies2.Count(
e =>
e.UnitPosition.Distance(detoneateTargetBarrelSecond.Position) <
BarrelExplosionRange) >=
config.Item("detoneateTargets", true).GetValue <Slider>().Value&&
detoneateTargetBarrelSecond.CountEnemiesInRange(BarrelExplosionRange) >=
config.Item("detoneateTargets", true).GetValue <Slider>().Value)
{
Q.CastOnUnit(
detoneateTargetBarrel, config.Item("packets").GetValue <bool>());
return;
}
}
}
}
}
}
}
}
if (config.Item("useq", true).GetValue <bool>() && Q.CanCast(target) && Orbwalking.CanMove(100) && !justE)
{
CastQonHero(target, barrels);
}
}
}
public static Dictionary<string, int> GetOverallLocationTrueCount(IEnumerable<Incident> incidents, Prediction prediction)
{
Dictionary<string, int> overallLocationTrueCount = new Dictionary<string, int>();
Dictionary<long, Dictionary<string, int>> sliceLocationTrueCount = GetSliceLocationTrueCount(incidents, prediction);
foreach (long slice in sliceLocationTrueCount.Keys)
foreach (string location in sliceLocationTrueCount[slice].Keys)
overallLocationTrueCount.Add(slice + "-" + location, sliceLocationTrueCount[slice][location]);
return overallLocationTrueCount;
}
public static void UseComboItems(Obj_AI_Hero target, bool killSteal = false)
{
if (_menu == null || !_menu.Item(_menu.Name + ".enabled").GetValue <bool>())
{
return;
}
try
{
var distance = target == null ? 0 : target.Distance(ObjectManager.Player.Position, true);
if (distance >= Math.Pow(MaxRange, 2))
{
return;
}
foreach (var item in
Items.Where(
i =>
((i.Flags & _itemFlags) != 0) &&
_menu.Item(_menu.Name + "." + i.Name + ".combo").GetValue <bool>() && i.Item.IsOwned() &&
i.Item.IsReady() && distance <= Math.Pow(i.Range, 2) &&
(killSteal ||
ObjectManager.Player.CountEnemiesInRange(i.Range) >=
_menu.Item(_menu.Name + "." + i.Name + ".min-enemies-range").GetValue <Slider>().Value&&
ObjectManager.Player.HealthPercent <=
_menu.Item(_menu.Name + "." + i.Name + ".player-health-below").GetValue <Slider>().Value&&
ObjectManager.Player.HealthPercent >=
_menu.Item(_menu.Name + "." + i.Name + ".player-health-above").GetValue <Slider>().Value&&
(target == null ||
target.HealthPercent <=
_menu.Item(_menu.Name + "." + i.Name + ".target-health-below").GetValue <Slider>().Value&&
target.HealthPercent >=
_menu.Item(_menu.Name + "." + i.Name + ".target-health-above").GetValue <Slider>().Value)))
)
{
switch (item.CastType)
{
case CastType.Target:
item.Item.Cast(target);
break;
case CastType.Self:
item.Item.Cast(ObjectManager.Player);
break;
case CastType.None:
item.Item.Cast();
break;
case CastType.Position:
var prediction = Prediction.GetPrediction(target, item.Delay, item.Radius, item.Speed);
if (prediction.Hitchance >= HitChance.Medium)
{
item.Item.Cast(prediction.CastPosition);
}
break;
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
/// <summary>
/// Gets Prediction result
/// </summary>
/// <param name="input">Neccesary inputs for prediction calculations</param>
/// <returns>Prediction result as <see cref="Prediction.Result"/></returns>
public static Prediction.Result GetPrediction(Prediction.Input input)
{
return GetPrediction(input.Target, input.SpellWidth, input.SpellDelay, input.SpellMissileSpeed, input.SpellRange, input.SpellCollisionable, input.Path, input.AvgReactionTime, input.LastMovChangeTime, input.AvgPathLenght, input.From.To2D(), input.RangeCheckFrom.To2D());
}
private async Task ExecuteAsync(CancellationToken token)
{
try
{
if (Game.IsPaused || !Owner.IsValid || !Owner.IsAlive || Owner.IsStunned() || Owner.IsInvisible())
{
return;
}
if (Menu.AutoComboWhenComboItem && Menu.ComboKeyItem)
{
return;
}
if (Menu.AutoOwnerMinHealthItem > ((float)Owner.Health / Owner.MaximumHealth) * 100)
{
return;
}
var target = EntityManager <Hero> .Entities.Where(x =>
x.IsValid &&
x.IsVisible &&
x.IsAlive &&
!x.IsIllusion &&
x.IsEnemy(Owner) &&
Extensions.Active(x)).OrderBy(x => x.Distance2D(Owner)).FirstOrDefault();
if (target == null)
{
return;
}
if (!Extensions.Cancel(target) || Extensions.ComboBreaker(target, false))
{
return;
}
if (Menu.BladeMailItem && target.HasModifier("modifier_item_blade_mail_reflect"))
{
return;
}
if (target.IsBlockingAbilities())
{
Config.LinkenBreaker.Handler.RunAsync();
return;
}
var stunDebuff = target.Modifiers.FirstOrDefault(x => x.IsStunDebuff);
var hexDebuff = target.Modifiers.FirstOrDefault(x => x.Name == "modifier_sheepstick_debuff");
// Hex
var hex = Abilities.Hex;
if (hex != null &&
Menu.AutoItemToggler.Value.IsEnabled(hex.ToString()) &&
hex.CanBeCasted &&
hex.CanHit(target) &&
(stunDebuff == null || !stunDebuff.IsValid || stunDebuff.RemainingTime <= 0.3f) &&
(hexDebuff == null || !hexDebuff.IsValid || hexDebuff.RemainingTime <= 0.3f))
{
hex.UseAbility(target);
await Await.Delay(hex.GetCastDelay(target), token);
}
// Orchid
var orchid = Abilities.Orchid;
if (orchid != null &&
Menu.AutoItemToggler.Value.IsEnabled(orchid.ToString()) &&
orchid.CanBeCasted &&
orchid.CanHit(target))
{
orchid.UseAbility(target);
await Await.Delay(orchid.GetCastDelay(target), token);
}
// Bloodthorn
var bloodthorn = Abilities.Bloodthorn;
if (bloodthorn != null &&
Menu.AutoItemToggler.Value.IsEnabled(bloodthorn.ToString()) &&
bloodthorn.CanBeCasted &&
bloodthorn.CanHit(target))
{
bloodthorn.UseAbility(target);
await Await.Delay(bloodthorn.GetCastDelay(target), token);
}
// Mystic Flare
var mysticFlare = Abilities.MysticFlare;
if (Menu.AutoAbilityToggler.Value.IsEnabled(mysticFlare.ToString()) &&
Menu.AutoMinHealthToUltItem <= ((float)target.Health / target.MaximumHealth) * 100 &&
mysticFlare.CanBeCasted &&
mysticFlare.CanHit(target))
{
var input = new PredictionInput
{
Owner = Owner,
Delay = mysticFlare.CastPoint + mysticFlare.ActivationDelay,
Range = mysticFlare.CastRange,
Radius = mysticFlare.Radius,
};
var output = Prediction.GetPrediction(input.WithTarget(target));
var castPosition = output.CastPosition;
Vector3 position;
if (target.NetworkActivity != NetworkActivity.Move || target.IsStunned() || target.IsRooted())
{
position = castPosition;
}
else
{
position = castPosition + (100 * target.Direction2D().ToVector3());
}
if (Owner.HasAghanimsScepter())
{
var dubleMysticFlare = EntityManager <Hero> .Entities.Count(x =>
x.IsVisible &&
x.IsAlive &&
!x.IsIllusion &&
x.IsEnemy(Owner) &&
x.Distance2D(Owner) <= mysticFlare.CastRange) <= 1;
if (dubleMysticFlare)
{
position = castPosition + (175 * target.Direction2D().ToVector3());
}
}
mysticFlare.UseAbility(position);
await Await.Delay(mysticFlare.GetCastDelay(position), token);
}
// Nullifier
var nullifier = Abilities.Nullifier;
if (nullifier != null &&
Menu.ItemToggler.Value.IsEnabled(nullifier.ToString()) &&
nullifier.CanBeCasted &&
nullifier.CanHit(target) &&
(stunDebuff == null || !stunDebuff.IsValid || stunDebuff.RemainingTime <= 0.5f) &&
(hexDebuff == null || !hexDebuff.IsValid || hexDebuff.RemainingTime <= 0.5f))
{
nullifier.UseAbility(target);
await Await.Delay(nullifier.GetCastDelay(target), token);
}
// RodofAtos
var rodofAtos = Abilities.RodofAtos;
if (rodofAtos != null &&
Menu.AutoItemToggler.Value.IsEnabled(rodofAtos.ToString()) &&
rodofAtos.CanBeCasted &&
rodofAtos.CanHit(target) &&
!target.Modifiers.Any(x => x.IsValid && x.Name == "modifier_rod_of_atos_debuff" && x.RemainingTime > 0.5f) &&
(stunDebuff == null || !stunDebuff.IsValid || stunDebuff.RemainingTime <= 0.5f))
{
rodofAtos.UseAbility(target);
await Await.Delay(rodofAtos.GetCastDelay(target), token);
}
// AncientSeal
var ancientSeal = Abilities.AncientSeal;
if (Menu.AutoAbilityToggler.Value.IsEnabled(ancientSeal.ToString()) &&
ancientSeal.CanBeCasted &&
ancientSeal.CanHit(target))
{
ancientSeal.UseAbility(target);
await Await.Delay(ancientSeal.GetCastDelay(target), token);
return;
}
// Veil
var veil = Abilities.Veil;
if (veil != null &&
Menu.AutoItemToggler.Value.IsEnabled(veil.ToString()) &&
veil.CanBeCasted &&
veil.CanHit(target))
{
veil.UseAbility(target.Position);
await Await.Delay(veil.GetCastDelay(target.Position), token);
}
// Ethereal
var ethereal = Abilities.Ethereal;
if (ethereal != null &&
Menu.AutoItemToggler.Value.IsEnabled(ethereal.ToString()) &&
ethereal.CanBeCasted &&
ethereal.CanHit(target))
{
ethereal.UseAbility(target);
MultiSleeper.Sleep(ethereal.GetHitTime(target), "ethereal");
await Await.Delay(ethereal.GetCastDelay(target), token);
}
// Shivas
var shivas = Abilities.Shivas;
if (shivas != null &&
Menu.AutoItemToggler.Value.IsEnabled(shivas.ToString()) &&
shivas.CanBeCasted &&
shivas.CanHit(target))
{
shivas.UseAbility();
await Await.Delay(shivas.GetCastDelay(), token);
}
if (!MultiSleeper.Sleeping("ethereal") || target.IsEthereal())
{
// ConcussiveShot
var concussiveShot = Abilities.ConcussiveShot;
if (Menu.AutoAbilityToggler.Value.IsEnabled(concussiveShot.ToString()) &&
Extensions.ConcussiveShotTarget(target, concussiveShot.TargetHit) &&
concussiveShot.CanBeCasted &&
Owner.Distance2D(target) < Menu.ConcussiveShotUseRadiusItem - Owner.HullRadius)
{
concussiveShot.UseAbility();
await Await.Delay(concussiveShot.GetCastDelay(), token);
}
// ArcaneBolt
var arcaneBolt = Abilities.ArcaneBolt;
if (Menu.AutoAbilityToggler.Value.IsEnabled(arcaneBolt.ToString()) &&
arcaneBolt.CanBeCasted &&
arcaneBolt.CanHit(target))
{
arcaneBolt.UseAbility(target);
UpdateManager.BeginInvoke(() =>
{
MultiSleeper.Sleep(arcaneBolt.GetHitTime(target) - (arcaneBolt.GetCastDelay(target) + 350), $"arcanebolt_{ target.Name }");
},
arcaneBolt.GetCastDelay(target) + 50);
await Await.Delay(arcaneBolt.GetCastDelay(target), token);
return;
}
// Dagon
var dagon = Abilities.Dagon;
if (dagon != null &&
Menu.AutoItemToggler.Value.IsEnabled("item_dagon_5") &&
dagon.CanBeCasted &&
dagon.CanHit(target))
{
dagon.UseAbility(target);
await Await.Delay(dagon.GetCastDelay(target), token);
return;
}
}
}
catch (TaskCanceledException)
{
// canceled
}
catch (Exception e)
{
Config.Main.Log.Error(e);
}
}
private void UseSpells(bool useQ, bool useW, bool useE, bool useR, string source)
{
if (source == "Harass" && !ManaManager.HasMana("Harass"))
{
return;
}
var target = TargetSelector.GetTarget(Q.Range, TargetSelector.DamageType.Physical);
if (!target.IsValidTarget(Q.Range))
{
return;
}
//items
if (source == "Combo")
{
var dmg = GetComboDamage(target);
ItemManager.Target = target;
//see if killable
if (dmg > target.Health - 50)
{
ItemManager.KillableTarget = true;
}
ItemManager.UseTargetted = true;
}
if (useW && W.IsReady())
{
var wTarget = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Magical);
var pred = Util.GetP(Player.ServerPosition, W, wTarget, 2.5f, true);
if (menu.Item("W_On_Cc", true).GetValue <bool>())
{
foreach (var enemies in HeroManager.Enemies.Where(x => x.IsValidTarget(W.Range)))
{
if (enemies.HasBuffOfType(BuffType.Snare) || enemies.HasBuffOfType(BuffType.Stun) || enemies.HasBuffOfType(BuffType.Fear) || enemies.HasBuffOfType(BuffType.Suppression))
{
W.Cast(enemies);
break;
}
}
}
if (pred.Hitchance >= HitChance.VeryHigh)
{
W.Cast(pred.CastPosition);
}
}
if (useE && E.IsReady())
{
var etarget = TargetSelector.GetTarget(E.Range + 425, TargetSelector.DamageType.Magical);
if (etarget.IsValidTarget(E.Range + 425))
{
var vec = Player.ServerPosition.Extend(etarget.ServerPosition, E.Range - 10);
if (vec.Distance(target.ServerPosition) < 425 && ShouldE(vec))
{
E.Cast(vec);
Utility.DelayAction.Add((int)E.Delay * 1000 + Game.Ping, () => Player.IssueOrder(GameObjectOrder.AttackUnit, etarget));
}
}
}
if (useQ && Q.IsReady())
{
SpellCastManager.CastBasicSkillShot(Q, Q.Range, TargetSelector.DamageType.Magical,
HitChanceManager.GetQHitChance(source));
SpellCastManager.CastBasicSkillShot(Q2, Q2.Range, TargetSelector.DamageType.Magical,
HitChanceManager.GetQHitChance(source));
}
if (useR && R.IsReady() && _ekkoPast != null)
{
if (menu.Item("R_On_Killable", true).GetValue <bool>())
{
if ((from enemie in HeroManager.Enemies.Where(x => x.IsValidTarget()).Where(x => Prediction.GetPrediction(x, 25f).UnitPosition.Distance(_ekkoPast.ServerPosition) < 400)
let dmg = GetComboDamage(enemie) where dmg > enemie.Health select enemie).Any())
{
R.Cast();
return;
}
}
if (AoeR())
{
R.Cast();
}
}
}
public override async Task ExecuteAsync(CancellationToken token)
{
Target = this.TargetSelector.Active.GetTargets().FirstOrDefault(x => !x.IsInvulnerable());
var silenced = UnitExtensions.IsSilenced(this.Owner);
var sliderValue = this.Config.UseBlinkPrediction.Item.GetValue <Slider>().Value;
var isChanneling = UnitExtensions.IsChanneling(this.Owner);
if (!silenced)
{
try
{
if ((this.BlinkDagger != null) &&
(this.BlinkDagger.Item.IsValid) &&
Target != null && Owner.Distance2D(Target) <= 1200 + sliderValue &&
!(Owner.Distance2D(Target) <= sliderValue) &&
this.BlinkDagger.Item.CanBeCasted() &&
this.Config.ItemToggler.Value.IsEnabled(this.BlinkDagger.Item.Name) && !isChanneling)
{
var l = (this.Owner.Distance2D(Target) - sliderValue) / sliderValue;
var posA = this.Owner.Position;
var posB = Target.Position;
var x = (posA.X + (l * posB.X)) / (1 + l);
var y = (posA.Y + (l * posB.Y)) / (1 + l);
var position = new Vector3((int)x, (int)y, posA.Z);
Log.Debug("Using BlinkDagger");
this.BlinkDagger.UseAbility(position);
await Await.Delay(this.GetItemDelay(position), token);
}
if ((this.Euls != null) && this.Euls.Item.IsValid && Target != null &&
this.Owner.Distance2D(Target) <= this.Euls.CastRange && this.Euls.Item.CanBeCasted(Target) &&
this.Config.ItemToggler.Value.IsEnabled(this.Euls.Item.Name))
{
Log.Debug($"Using Eul");
this.Euls.UseAbility(this.Target);
await Await.Delay(this.GetItemDelay(Target), token);
}
if (Hex != null && Hex.IsValid && Hex.CanBeCasted(Target) &&
!isChanneling &&
this.Config.AbilityToggler.Value.IsEnabled(this.Hex.Name))
{
Log.Debug($"Using Hex");
Hex.UseAbility(Target);
await Await.Delay(GetAbilityDelay(this.Owner, Hex), token);
}
if (Ethershock != null && Ethershock.IsValid && Ethershock.CanBeCasted(Target) &&
!isChanneling &&
this.Config.AbilityToggler.Value.IsEnabled(this.Ethershock.Name))
{
Log.Debug($"Using Ethershock!");
Ethershock.UseAbility(Target);
await Await.Delay(GetAbilityDelay(this.Owner, Ethershock), token);
}
}
catch (TaskCanceledException)
{
// ignore
}
catch (Exception e)
{
Log.Error($"{e}");
}
}
if (!silenced)
{
try
{
var invulTargetsToo = this.TargetSelector.Active.GetTargets().FirstOrDefault();
if (Wards != null && Wards.IsValid && Wards.CanBeCasted() &&
!isChanneling && invulTargetsToo != null && invulTargetsToo.IsValid &&
this.Config.AbilityToggler.Value.IsEnabled(this.Wards.Name))
{
var delay = Wards.GetCastPoint();
var wardsCastRange = Wards.CastRange;
var input = new PredictionInput(this.Owner, invulTargetsToo, delay, float.MaxValue,
wardsCastRange, 30,
PredictionSkillshotType.SkillshotCircle)
{
CollisionTypes = CollisionTypes.None
};
output = Prediction.GetPrediction(input);
if (output.HitChance >= HitChance.Medium)
{
Log.Debug($"Casting Wards");
this.Wards.UseAbility(output.CastPosition);
if (this.Config.FailSwitch.Value.Equals(true) && (Target.IsRotating() && Target.MovementSpeed >= 300 || Ensage.SDK.Extensions.EntityExtensions.Distance2D(Target, output.CastPosition) >= 200))
{
Log.Error($"stopping");
this.Owner.Stop();
await Await.Delay(100, token);
}
await Await.Delay(GetAbilityDelay(output.CastPosition, this.Wards), token);
}
}
}
catch (TaskCanceledException)
{
// ignored
}
catch (Exception e)
{
Log.Error($"{e}");
}
}
if (this.BloodThorn != null &&
this.BloodThorn.Item.IsValid &&
Target != null && !isChanneling &&
this.BloodThorn.Item.CanBeCasted(Target) &&
this.Config.ItemToggler.Value.IsEnabled(this.BloodThorn.Item.Name))
{
Log.Debug("Using Bloodthorn");
this.BloodThorn.UseAbility(Target);
await Await.Delay(this.GetItemDelay(Target), token);
}
if ((this.SheepStick != null) &&
(this.SheepStick.Item.IsValid) &&
Target != null && !isChanneling &&
this.SheepStick.Item.CanBeCasted(Target) &&
this.Config.ItemToggler.Value.IsEnabled("item_sheepstick"))
{
Log.Debug("Using Sheepstick");
this.SheepStick.UseAbility(Target);
await Await.Delay(this.GetItemDelay(Target), token);
}
if (this.Dagon != null &&
this.Dagon.Item.IsValid &&
Target != null && !isChanneling &&
this.Dagon.Item.CanBeCasted(Target) &&
this.Config.ItemToggler.Value.IsEnabled(Dagon5.Item.Name))
{
Log.Debug("Using Dagon");
this.Dagon.UseAbility(Target);
await Await.Delay(this.GetItemDelay(Target), token);
}
if (this.Orchid != null &&
this.Orchid.Item.IsValid &&
Target != null && !isChanneling &&
this.Orchid.Item.CanBeCasted(Target) &&
this.Config.ItemToggler.Value.IsEnabled("item_orchid"))
{
Log.Debug("Using Orchid");
this.Orchid.UseAbility(Target);
await Await.Delay(this.GetItemDelay(Target), token);
}
if (this.RodofAtos != null &&
this.RodofAtos.Item.IsValid &&
Target != null && !isChanneling &&
this.RodofAtos.Item.CanBeCasted(Target) &&
this.Config.ItemToggler.Value.IsEnabled("item_rod_of_atos"))
{
Log.Debug("Using RodofAtos");
this.RodofAtos.UseAbility(Target);
await Await.Delay(this.GetItemDelay(Target), token);
}
if (this.VeilofDiscord != null &&
this.VeilofDiscord.Item.IsValid &&
Target != null && !isChanneling &&
this.VeilofDiscord.Item.CanBeCasted() &&
this.Config.ItemToggler.Value.IsEnabled("item_veil_of_discord"))
{
Log.Debug("Using VeilofDiscord");
this.VeilofDiscord.UseAbility(Target.Position);
await Await.Delay(this.GetItemDelay(Target), token);
}
if (this.HurricanePike != null &&
this.HurricanePike.Item.IsValid &&
Target != null && !isChanneling &&
this.HurricanePike.Item.CanBeCasted() &&
this.Config.ItemToggler.Value.IsEnabled("item_hurricane_pike"))
{
Log.Debug("Using HurricanePike");
this.HurricanePike.UseAbility(Target);
await Await.Delay(this.GetItemDelay(Target), token);
}
if (this.ShivasGuard != null &&
this.ShivasGuard.Item.IsValid &&
Target != null && !isChanneling &&
this.ShivasGuard.Item.CanBeCasted() &&
Owner.Distance2D(Target) <= 900 &&
this.Config.ItemToggler.Value.IsEnabled("item_shivas_guard"))
{
Log.Debug("Using Shiva's Guard");
this.ShivasGuard.UseAbility();
await Await.Delay((int)Game.Ping, token);
}
if (this.Mjollnir != null &&
this.Mjollnir.Item.IsValid &&
Target != null && !isChanneling &&
this.Mjollnir.Item.CanBeCasted() &&
this.Config.ItemToggler.Value.IsEnabled("item_mjollnir"))
{
Log.Debug("Using Mjollnir");
this.Mjollnir.UseAbility(Owner);
await Await.Delay(this.GetItemDelay(Target), token);
}
try
{
if (Shackles != null && Shackles.IsValid && Shackles.CanBeCasted(Target) &&
!isChanneling &&
(Wards == null || !Wards.IsValid || !Wards.CanBeCasted() ||
!this.Config.AbilityToggler.Value.IsEnabled(this.Wards.Name)) && HexSync() &&
this.Config.AbilityToggler.Value.IsEnabled(this.Shackles.Name))
{
Log.Debug($"Using Shackles!");
Shackles.UseAbility(Target);
await Await.Delay(GetAbilityDelay(this.Target, Shackles) + 1000, token);
}
}
catch (TaskCanceledException)
{
// ignore
}
catch (Exception e)
{
Log.Error(e);
}
/*if (Refresher != null && Refresher.Item.IsValid && Target != null &&
* !isChanneling && this.Refresher.Item.CanBeCasted() && !this.Wards.CanBeCasted() && !this.Shackles.CanBeCasted() &&
* this.Config.ItemToggler.Value.IsEnabled(Refresher.Item.Name))
* {
* Log.Debug($"Using Refresher Orb");
* Refresher.UseAbility();
* await Await.Delay(100, token);
* }*/
if (Target != null && Owner.IsValidOrbwalkingTarget(Target) && !isChanneling)
{
this.Context.Orbwalker.Active.OrbwalkTo(Target);
Log.Debug($"Orbwalking");
}
await Await.Delay(100, token);
}
public override async Task ExecuteAsync(CancellationToken token)
{
if (Config.TargetItem.Value.SelectedValue.Contains("Lock") &&
(Target == null || !Target.IsValid || !Target.IsAlive))
{
if (!TargetSelector.IsActive)
{
TargetSelector.Activate();
}
if (TargetSelector.IsActive)
{
Target = TargetSelector.Active.GetTargets().FirstOrDefault() as Hero;
}
if (Target != null)
{
if (TargetSelector.IsActive)
{
TargetSelector.Deactivate();
}
}
}
else if (Config.TargetItem.Value.SelectedValue.Contains("Default") && TargetSelector.IsActive)
{
Target = TargetSelector.Active.GetTargets().FirstOrDefault() as Hero;
}
if (Target != null &&
(!Config.BladeMailItem || !Target.HasModifier("modifier_item_blade_mail_reflect")) &&
!Config.Data.CancelCombo(Target))
{
var IsStun = Target.Modifiers.FirstOrDefault(x => x.IsStunDebuff);
var IsDebuff = Target.Modifiers.FirstOrDefault(x => x.IsDebuff && x.Name == "modifier_rod_of_atos_debuff");
if (!Target.IsMagicImmune() && !Target.IsLinkensProtected() && !Config.Data.AntimageShield(Target))
{
// Hex
if (Main.Hex != null &&
Config.ItemsToggler.Value.IsEnabled(Main.Hex.Item.Name) &&
Main.Hex.CanBeCasted &&
Main.Hex.CanHit(Target) &&
(IsStun == null || IsStun.RemainingTime <= 0.3))
{
Main.Hex.UseAbility(Target);
await Await.Delay(Main.Hex.GetCastDelay(Target), token);
}
// Orchid
if (Main.Orchid != null &&
Config.ItemsToggler.Value.IsEnabled(Main.Orchid.Item.Name) &&
Main.Orchid.CanBeCasted &&
Main.Orchid.CanHit(Target))
{
Main.Orchid.UseAbility(Target);
await Await.Delay(Main.Orchid.GetCastDelay(Target), token);
}
// Bloodthorn
if (Main.Bloodthorn != null &&
Config.ItemsToggler.Value.IsEnabled(Main.Bloodthorn.Item.Name) &&
Main.Bloodthorn.CanBeCasted &&
Main.Bloodthorn.CanHit(Target))
{
Main.Bloodthorn.UseAbility(Target);
await Await.Delay(Main.Bloodthorn.GetCastDelay(Target), token);
}
// MysticFlare
if (Main.MysticFlare != null &&
Config.AbilityToggler.Value.IsEnabled(Main.MysticFlare.Ability.Name) &&
Main.MysticFlare.CanBeCasted &&
Main.MysticFlare.CanHit(Target) &&
Config.Data.Active(Target, IsStun))
{
var CheckHero = EntityManager <Hero> .Entities.Where(
x =>
!x.IsIllusion &&
x.IsAlive &&
x.IsVisible &&
x.IsValid &&
x.Team != Owner.Team &&
x.Distance2D(Owner) <= Main.MysticFlare.CastRange);
var UltimateScepter = Owner.HasAghanimsScepter();
var DubleMysticFlare = UltimateScepter && CheckHero.Count() == 1;
var Input =
new PredictionInput(
Owner,
Target,
0,
float.MaxValue,
Main.MysticFlare.CastRange,
DubleMysticFlare ? -250 : -100,
PredictionSkillshotType.SkillshotCircle,
true)
{
CollisionTypes = CollisionTypes.None
};
var Output = Prediction.GetPrediction(Input);
Main.MysticFlare.UseAbility(Output.CastPosition);
await Await.Delay(Main.MysticFlare.GetCastDelay(Target), token);
}
// RodofAtos
if (Main.RodofAtos != null &&
Config.ItemsToggler.Value.IsEnabled(Main.RodofAtos.Item.Name) &&
Main.RodofAtos.CanBeCasted &&
Main.RodofAtos.CanHit(Target) &&
(IsStun == null || IsStun.RemainingTime <= 0.5) &&
(IsDebuff == null || IsDebuff.RemainingTime <= 0.5))
{
Main.RodofAtos.UseAbility(Target);
await Await.Delay(Main.RodofAtos.GetCastDelay(Target), token);
}
// AncientSeal
if (Main.AncientSeal != null &&
Config.AbilityToggler.Value.IsEnabled(Main.AncientSeal.Ability.Name) &&
Main.AncientSeal.CanBeCasted &&
Main.AncientSeal.CanHit(Target))
{
Main.AncientSeal.UseAbility(Target);
await Await.Delay(Main.AncientSeal.GetCastDelay(Target), token);
}
// ConcussiveShot
if (Main.ConcussiveShot != null &&
Config.AbilityToggler.Value.IsEnabled(Main.ConcussiveShot.Ability.Name) &&
(!Config.WTargetItem ||
(Target == Config.UpdateMode.WShow ||
(Config.UpdateMode.WShow != null && Target.Distance2D(Config.UpdateMode.WShow) <= 250))) &&
Main.ConcussiveShot.CanBeCasted &&
Owner.Distance2D(Target.Position) <= Config.WRadiusItem + 25)
{
Main.ConcussiveShot.UseAbility();
await Await.Delay(Main.ConcussiveShot.GetCastDelay(), token);
}
// ArcaneBolt
if (Main.ArcaneBolt != null &&
Config.AbilityToggler.Value.IsEnabled(Main.ArcaneBolt.Ability.Name) &&
Main.ArcaneBolt.CanBeCasted &&
Main.ArcaneBolt.CanHit(Target))
{
Main.ArcaneBolt.UseAbility(Target);
await Await.Delay(Main.ArcaneBolt.GetCastDelay(Target), token);
}
// Veil
if (Main.Veil != null &&
Config.ItemsToggler.Value.IsEnabled(Main.Veil.Item.Name) &&
Main.Veil.CanBeCasted &&
Main.Veil.CanHit(Target))
{
Main.Veil.UseAbility(Target.Position);
await Await.Delay(Main.Veil.GetCastDelay(Target), token);
}
// Ethereal
if (Main.Ethereal != null &&
Config.ItemsToggler.Value.IsEnabled(Main.Ethereal.Item.Name) &&
Main.Ethereal.CanBeCasted &&
Main.Ethereal.CanHit(Target))
{
Main.Ethereal.UseAbility(Target);
await Await.Delay(Main.Ethereal.GetCastDelay(Target), token);
}
// Dagon
if (Main.Dagon != null &&
Config.ItemsToggler.Value.IsEnabled("item_dagon_5") &&
Main.Dagon.CanBeCasted &&
Main.Dagon.CanHit(Target) &&
(Main.AncientSeal == null || (Target.HasModifier("modifier_skywrath_mage_ancient_seal") && !Main.AncientSeal.CanBeCasted) ||
!Config.AbilityToggler.Value.IsEnabled(Main.AncientSeal.Ability.Name)) &&
(Main.Ethereal == null || (Target.IsEthereal() && !Main.Ethereal.CanBeCasted) ||
!Config.ItemsToggler.Value.IsEnabled(Main.Ethereal.Item.Name)))
{
Main.Dagon.UseAbility(Target);
await Await.Delay(Main.Dagon.GetCastDelay(Target), token);
}
}
else
{
await Config.LinkenBreaker.Breaker(token, Target);
}
if (Target == null || Target.IsAttackImmune() || Target.IsInvulnerable())
{
if (!Orbwalker.Settings.Move)
{
Orbwalker.Settings.Move.Item.SetValue(true);
}
Orbwalker.Move(Game.MousePosition);
}
else if (Target != null)
{
if (Owner.Distance2D(Target) <= Config.MinDisInOrbwalk &&
Target.Distance2D(Game.MousePosition) <= Config.MinDisInOrbwalk)
{
if (Orbwalker.Settings.Move)
{
Orbwalker.Settings.Move.Item.SetValue(false);
}
Orbwalker.OrbwalkTo(Target);
}
else
{
if (!Orbwalker.Settings.Move)
{
Orbwalker.Settings.Move.Item.SetValue(true);
}
Orbwalker.OrbwalkTo(Target);
}
}
}
else
{
if (!Orbwalker.Settings.Move)
{
Orbwalker.Settings.Move.Item.SetValue(true);
}
Orbwalker.Move(Game.MousePosition);
}
}
public override IEnumerable<string> SelectFeatures(Prediction prediction)
{
throw new NotImplementedException("Feature selection is not implemented for SVM Rank classifiers.");
}
/// <summary>
/// Gets Prediction result
/// </summary>
/// <param name="target">Target for spell</param>
/// <param name="width">Spell width</param>
/// <param name="delay">Spell delay</param>
/// <param name="missileSpeed">Spell missile speed</param>
/// <param name="range">Spell range</param>
/// <param name="collisionable">Spell collisionable</param>
/// <param name="type">Spell skillshot type</param>
/// <param name="path">Waypoints of target</param>
/// <param name="avgt">Average reaction time (in ms)</param>
/// <param name="movt">Passed time from last movement change (in ms)</param>
/// <param name="avgp">Average Path Lenght</param>
/// <param name="from">Spell casted position</param>
/// <param name="rangeCheckFrom"></param>
/// <returns>Prediction result as <see cref="Prediction.Result"/></returns>
public static Prediction.Result GetPrediction(Obj_AI_Base target, float width, float delay, float missileSpeed, float range, bool collisionable, List <Vector2> path, float avgt, float movt, float avgp, Vector2 from, Vector2 rangeCheckFrom)
{
return(Prediction.GetPrediction(target, width, delay, missileSpeed, range, collisionable, SkillshotType.SkillshotCircle, path, avgt, movt, avgp, from, rangeCheckFrom));
}
internal override string GetDetails(Prediction prediction, Dictionary<string, string> attFeatureIdInformation)
{
return "No details available for RandomForest predictions.";
}
public void UpdatePosition()
{
Effect.SetControlPoint(0, Prediction.InFront(Core.Me, Dist));
}
internal static List<int> Insert(NpgsqlConnection connection,
IEnumerable<Tuple<PostGIS.Point, string, DateTime>> points,
Prediction prediction,
Area area,
bool vacuum)
{
NpgsqlCommand cmd = DB.Connection.NewCommand(null, null, connection);
string pointTable = GetTableName(prediction);
List<int> ids = new List<int>();
StringBuilder pointValues = new StringBuilder();
int pointNum = 0;
int pointsPerBatch = 1000;
foreach (Tuple<PostGIS.Point, string, DateTime> pointIncidentTime in points)
{
PostGIS.Point point = pointIncidentTime.Item1;
string incidentType = pointIncidentTime.Item2;
DateTime time = pointIncidentTime.Item3;
if (point.SRID != area.Shapefile.SRID)
throw new Exception("Area SRID (" + area.Shapefile.SRID + ") does not match point SRID (" + point.SRID);
pointValues.Append((pointValues.Length > 0 ? "," : "") + "(DEFAULT,'" + incidentType + "',st_geometryfromtext('POINT(" + point.X + " " + point.Y + ")'," + point.SRID + "),@time_" + pointNum + ")");
ConnectionPool.AddParameters(cmd, new Parameter("time_" + pointNum, NpgsqlDbType.Timestamp, time));
if ((++pointNum % pointsPerBatch) == 0)
{
cmd.CommandText = "INSERT INTO " + pointTable + " (" + Columns.Insert + ") VALUES " + pointValues + " RETURNING " + Columns.Id;
NpgsqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
ids.Add(Convert.ToInt32(reader[0]));
reader.Close();
pointValues.Clear();
cmd.Parameters.Clear();
}
}
if (pointValues.Length > 0)
{
cmd.CommandText = "INSERT INTO " + pointTable + " (" + Columns.Insert + ") VALUES " + pointValues + " RETURNING " + Columns.Id;
NpgsqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
ids.Add(Convert.ToInt32(reader[0]));
reader.Close();
pointValues.Clear();
cmd.Parameters.Clear();
}
if (vacuum)
VacuumTable(prediction);
return ids;
}
private void LogicR()
{
foreach (var t in Program.Enemies.Where(t => t.IsValidTarget() && BallPos.Distance(Prediction.GetPrediction(t, R.Delay).CastPosition) < R.Width && BallPos.Distance(t.ServerPosition) < R.Width))
{
if (Program.Combo && Config.Item("Ralways" + t.ChampionName, true).GetValue <bool>())
{
R.Cast();
}
if (Config.Item("Rks", true).GetValue <bool>())
{
var comboDmg = OktwCommon.GetKsDamage(t, R);
if (t.IsValidTarget(Q.Range))
{
comboDmg += Q.GetDamage(t);
}
if (W.IsReady())
{
comboDmg += W.GetDamage(t);
}
if (Orbwalker.InAutoAttackRange(t))
{
comboDmg += (float)Player.GetAutoAttackDamage(t) * 2;
}
if (t.Health < comboDmg)
{
R.Cast();
}
Program.debug("ks");
}
if (Config.Item("Rturrent", true).GetValue <bool>() && BallPos.UnderTurret(false) && !BallPos.UnderTurret(true))
{
R.Cast();
Program.debug("Rturrent");
}
if (Config.Item("Rlifesaver", true).GetValue <bool>() && Player.Health < Player.CountEnemiesInRange(800) * Player.Level * 20 && Player.Distance(BallPos) > t.Distance(Player.Position))
{
R.Cast();
Program.debug("ls");
}
}
int countEnemies = CountEnemiesInRangeDeley(BallPos, R.Width, R.Delay);
if (countEnemies >= Config.Item("rCount", true).GetValue <Slider>().Value&& BallPos.CountEnemiesInRange(R.Width) == countEnemies)
{
R.Cast();
}
}
static int CheckMultiHit(Vector3 minion)
{
var count = 0;
var allMinions = MinionManager.GetMinions(ObjectManager.Player.ServerPosition, Q.Range);
foreach (Obj_AI_Base minionvar in allMinions.Where(x => Vector3.Distance(minion, Prediction.GetPrediction(x, 250f).UnitPosition) < 200))
{
count++;
}
return(count);
}
internal override string GetDetails(Prediction prediction, Dictionary<string, string> attFeatureIdInformation)
{
return "No details available for SVM Rank classifiers.";
}
public override IDeepCopyable CopyTo(IDeepCopyable other)
{
var dest = other as RiskAssessment;
if (dest == null)
{
throw new ArgumentException("Can only copy to an object of the same type", "other");
}
base.CopyTo(dest);
if (Identifier != null)
{
dest.Identifier = new List <Hl7.Fhir.Model.Identifier>(Identifier.DeepCopy());
}
if (BasedOn != null)
{
dest.BasedOn = (Hl7.Fhir.Model.ResourceReference)BasedOn.DeepCopy();
}
if (Parent != null)
{
dest.Parent = (Hl7.Fhir.Model.ResourceReference)Parent.DeepCopy();
}
if (StatusElement != null)
{
dest.StatusElement = (Code <Hl7.Fhir.Model.ObservationStatus>)StatusElement.DeepCopy();
}
if (Method != null)
{
dest.Method = (Hl7.Fhir.Model.CodeableConcept)Method.DeepCopy();
}
if (Code != null)
{
dest.Code = (Hl7.Fhir.Model.CodeableConcept)Code.DeepCopy();
}
if (Subject != null)
{
dest.Subject = (Hl7.Fhir.Model.ResourceReference)Subject.DeepCopy();
}
if (Encounter != null)
{
dest.Encounter = (Hl7.Fhir.Model.ResourceReference)Encounter.DeepCopy();
}
if (Occurrence != null)
{
dest.Occurrence = (Hl7.Fhir.Model.Element)Occurrence.DeepCopy();
}
if (Condition != null)
{
dest.Condition = (Hl7.Fhir.Model.ResourceReference)Condition.DeepCopy();
}
if (Performer != null)
{
dest.Performer = (Hl7.Fhir.Model.ResourceReference)Performer.DeepCopy();
}
if (Reason != null)
{
dest.Reason = new List <Hl7.Fhir.Model.CodeableReference>(Reason.DeepCopy());
}
if (Basis != null)
{
dest.Basis = new List <Hl7.Fhir.Model.ResourceReference>(Basis.DeepCopy());
}
if (Prediction != null)
{
dest.Prediction = new List <Hl7.Fhir.Model.RiskAssessment.PredictionComponent>(Prediction.DeepCopy());
}
if (MitigationElement != null)
{
dest.MitigationElement = (Hl7.Fhir.Model.FhirString)MitigationElement.DeepCopy();
}
if (Note != null)
{
dest.Note = new List <Hl7.Fhir.Model.Annotation>(Note.DeepCopy());
}
return(dest);
}
public override IEnumerable<string> SelectFeatures(Prediction prediction)
{
throw new NotImplementedException("Feature selection has not been implemented for RandomForest classifiers.");
}
public override IDeepCopyable CopyTo(IDeepCopyable other)
{
var dest = other as RiskAssessment;
if (dest != null)
{
base.CopyTo(dest);
if (Subject != null)
{
dest.Subject = (Hl7.Fhir.Model.ResourceReference)Subject.DeepCopy();
}
if (DateElement != null)
{
dest.DateElement = (Hl7.Fhir.Model.FhirDateTime)DateElement.DeepCopy();
}
if (Condition != null)
{
dest.Condition = (Hl7.Fhir.Model.ResourceReference)Condition.DeepCopy();
}
if (Encounter != null)
{
dest.Encounter = (Hl7.Fhir.Model.ResourceReference)Encounter.DeepCopy();
}
if (Performer != null)
{
dest.Performer = (Hl7.Fhir.Model.ResourceReference)Performer.DeepCopy();
}
if (Identifier != null)
{
dest.Identifier = (Hl7.Fhir.Model.Identifier)Identifier.DeepCopy();
}
if (Method != null)
{
dest.Method = (Hl7.Fhir.Model.CodeableConcept)Method.DeepCopy();
}
if (Basis != null)
{
dest.Basis = new List <Hl7.Fhir.Model.ResourceReference>(Basis.DeepCopy());
}
if (Prediction != null)
{
dest.Prediction = new List <Hl7.Fhir.Model.RiskAssessment.PredictionComponent>(Prediction.DeepCopy());
}
if (MitigationElement != null)
{
dest.MitigationElement = (Hl7.Fhir.Model.FhirString)MitigationElement.DeepCopy();
}
return(dest);
}
else
{
throw new ArgumentException("Can only copy to an object of the same type", "other");
}
}
internal static void DeleteTable(Prediction prediction)
{
DB.Connection.ExecuteNonQuery("DROP TABLE " + GetTableName(prediction) + " CASCADE");
}
private void Combo()
{
Obj_AI_Hero target = TargetSelector.GetTarget(W.Range, TargetSelector.DamageType.Magical);
if (target == null)
{
return;
}
if (config.Item("useItems").GetValue <bool>())
{
ItemHandler.UseItems(target, config, ComboDamage(target));
}
bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
if (config.Item("usew", true).GetValue <bool>() && W.IsReady())
{
CastW();
}
if (config.Item("usee", true).GetValue <bool>() && E.CanCast(target) && player.Distance(target) < E.Range)
{
E.CastIfHitchanceEquals(target, HitChance.High, config.Item("packets").GetValue <bool>());
}
var ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
var canUlt = config.Item("user", true).GetValue <bool>() && !MordeGhost &&
!config.Item("ult" + target.SkinName, true).GetValue <bool>() &&
(!config.Item("ultDef", true).GetValue <bool>() ||
(config.Item("ultDef", true).GetValue <bool>() && !CombatHelper.HasDef(target)));
if (canUlt &&
(player.Distance(target.Position) <= 400f ||
(R.CanCast(target) && target.Health < 250f &&
Environment.Hero.countChampsAtrangeA(target.Position, 600f) >= 1)) &&
R.GetDamage(target) * 0.8f > target.Health)
{
R.CastOnUnit(target, config.Item("packets").GetValue <bool>());
}
if (canUlt && hasIgnite && player.Distance(target) < 600 &&
R.GetDamage(target) * 0.8f + ignitedmg > HealthPrediction.GetHealthPrediction(target, 400))
{
IgniteTarget = target;
Utility.DelayAction.Add(500, () => IgniteTarget = null);
R.CastOnUnit(target, config.Item("packets").GetValue <bool>());
}
if (config.Item("useIgnite").GetValue <bool>() && ignitedmg > target.Health && hasIgnite)
{
if (IgniteTarget != null)
{
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), IgniteTarget);
return;
}
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
}
if (MordeGhost && !GhostDelay && config.Item("moveGhost", true).GetValue <bool>())
{
var ghost = ObjectManager.Get <Obj_AI_Minion>().FirstOrDefault(m => m.HasBuff("mordekaisercotgpetbuff2"));
var Gtarget = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Magical);
switch (config.Item("ghostTarget", true).GetValue <StringList>().SelectedIndex)
{
case 0:
Gtarget = TargetSelector.GetTarget(R.Range, TargetSelector.DamageType.Magical);
break;
case 1:
Gtarget =
ObjectManager.Get <Obj_AI_Hero>()
.Where(i => i.IsEnemy && !i.IsDead && player.Distance(i) <= R.Range)
.OrderBy(i => i.Health)
.FirstOrDefault();
break;
case 2:
Gtarget =
ObjectManager.Get <Obj_AI_Hero>()
.Where(i => i.IsEnemy && !i.IsDead && player.Distance(i) <= R.Range)
.OrderBy(i => player.Distance(i))
.FirstOrDefault();
break;
default:
break;
}
if (ghost != null && Gtarget.IsValid && !ghost.IsWindingUp)
{
if (ghost.IsMelee)
{
if (CanCloneAttack(ghost) || player.HealthPercent < 25)
{
R.CastOnUnit(Gtarget, config.Item("packets").GetValue <bool>());
}
else
{
var prediction = Prediction.GetPrediction(Gtarget, 2);
R.Cast(
target.Position.Extend(
prediction.UnitPosition, Orbwalking.GetRealAutoAttackRange(Gtarget)),
config.Item("packets").GetValue <bool>());
}
}
else
{
if (CanCloneAttack(ghost) || player.HealthPercent < 25)
{
R.CastOnUnit(Gtarget, config.Item("packets").GetValue <bool>());
}
else
{
var pred = Orbwalking.AutoAttack.GetPrediction(Gtarget);
var point =
CombatHelper.PointsAroundTheTargetOuterRing(
pred.UnitPosition, Orbwalking.GetRealAutoAttackRange(Gtarget), 15)
.Where(p => !p.IsWall())
.OrderBy(p => p.CountEnemiesInRange(500))
.ThenBy(p => p.Distance(player.Position))
.FirstOrDefault();
if (point.IsValid())
{
R.Cast(point, config.Item("packets").GetValue <bool>());
}
}
}
GhostDelay = true;
Utility.DelayAction.Add(200, () => GhostDelay = false);
}
}
}
public static string GetTableName(Prediction prediction)
{
return "point_" + prediction.Id;
}
private void LogicW()
{
if (!W.Instance.Name.Contains("oggle"))
{
if (Config.Item("useW", true).GetValue <KeyBind>().Active)
{
W.Cast(Player.Position.Extend(Game.CursorPos, -100));
}
var t = TargetSelector.GetTarget(W.Range - 250, TargetSelector.DamageType.Magical);
if (t.IsValidTarget())
{
var close = HeroManager.Enemies.FirstOrDefault(x => x.IsMelee && x.IsValidTarget(350) && x.IsFacing(Player));
if (close != null)
{
W.Cast(Prediction.GetPrediction(Player, 0.2f).CastPosition.Extend(Prediction.GetPrediction(close, 0.2f).CastPosition, 50));
}
var pred = Prediction.GetPrediction(t, 0.3f);
var castPos = pred.CastPosition;
var tP = Player.Distance(t);
var tC = Player.Distance(castPos);
if (Program.Combo && Player.Mana > RMANA + WMANA)
{
if (tP < tC && tP > 500)
{
Console.WriteLine("pull");
W.Cast(Player.Position.Extend(castPos, tP + 250));
}
else if (tP > tC && tP < 500)
{
Console.WriteLine("push");
W.Cast(Player.Position.Extend(castPos, tP - 250));
}
}
}
if (Config.Item("turretW", true).GetValue <bool>())
{
var turret = Cache.TurretList.FirstOrDefault(x => x.IsValidTarget(W.Range) && x.HealthPercent < 22.5 + W.Level * 2.5);
if (turret != null)
{
W.Cast(turret);
}
}
}
else
{
W.Cast();
}
}
internal static string CreateTable(Prediction prediction, int srid)
{
string table = GetTableName(prediction);
DB.Connection.ExecuteNonQuery(
"CREATE TABLE " + table + " (" +
Columns.Id + " SERIAL PRIMARY KEY," +
Columns.IncidentType + " VARCHAR," +
Columns.Location + " GEOMETRY(GEOMETRY," + srid + ")," +
Columns.Time + " TIMESTAMP);" +
"CREATE INDEX ON " + table + " (" + Columns.IncidentType + ");" +
"CREATE INDEX ON " + table + " USING GIST (" + Columns.Location + ");");
return table;
}
private static List <string> ProcessLine(ShowBy showBy, PredictorCollection predictorCollection, string line,
MerLength merLength, int?dOfCenter, HlaSetSpecification hlaSetSpecification, bool modelOnly)
{
try
{
string hlaOrSupertypeOrNull;
string inputPeptide = ExtractInputs(hlaSetSpecification, line, predictorCollection, out hlaOrSupertypeOrNull);
List <string> output = new List <string>();
foreach (List <Prediction> predictionList in predictorCollection.MaxProbabilityPredictions(showBy, inputPeptide, merLength, dOfCenter, hlaSetSpecification, hlaOrSupertypeOrNull, modelOnly).Values)
{
string outputLine = InsertMaterial(line, hlaSetSpecification.InputHeaderCollection().Length, Prediction.CollectionToString(predictionList, false, hlaSetSpecification.IncludeHlaInOutput()));
output.Add(outputLine);
}
return(output);
}
catch (Exception exception)
{
string errorString = SpecialFunctions.CreateTabString(
line,
string.Format("Error: {0}{1}", exception.Message, exception.InnerException == null ? "" : string.Format(" ({0})", exception.InnerException)));
List <string> output = new List <string>();
output.Add(errorString);
return(output);
}
}
public abstract IEnumerable<string> SelectFeatures(Prediction prediction);
internal static void GravesCombo()
{
if (Target.IsValidTarget(Chargeshot.Range))
{
var rpred = Prediction.GetPrediction(Target, 0.25f).UnitPosition;
if (rpred.Distance(Me.ServerPosition) <= Quickdraw.Range + 200)
{
if (Chargeshot.IsReady() && (Quickdraw.IsReady() && Buckshot.IsReady()))
{
if (MainMenu.Item("usercombo").GetValue <bool>())
{
if (GetComboDamage(Target) >= Target.Health)
{
Chargeshot.CastIfHitchanceEquals(Target, HitChance.High);
}
}
}
}
}
var qtarget = TargetSelector.GetTarget(Buckshot.Range, TargetSelector.DamageType.Physical);
if (qtarget.IsValidTarget())
{
var predpros = Prediction.GetPrediction(qtarget, 0.25f).UnitPosition;
if (predpros.Distance(Me.ServerPosition) > 535)
{
if (qtarget.Distance(Me.ServerPosition) <= 675)
{
if (Utils.GameTimeTickCount - LR < 1500)
{
Buckshot.CastIfHitchanceEquals(qtarget, HitChance.High);
}
}
}
}
var wtarget = TargetSelector.GetTarget(Smokescreen.Range, TargetSelector.DamageType.Magical);
if (wtarget.IsValidTarget() && wtarget.Distance(Me.ServerPosition) <= Smokescreen.Range)
{
if (MainMenu.Item("usew").GetValue <bool>())
{
if (Smokescreen.IsReady() && Utils.GameTimeTickCount - LR >= 1200)
{
if (Me.GetAutoAttackDamage(qtarget) * 3 < qtarget.Health)
{
if (!Quickdraw.IsReady() && !Buckshot.IsReady())
{
Smokescreen.CastIfHitchanceEquals(wtarget, HitChance.VeryHigh);
}
}
}
}
}
if (qtarget.IsValidTarget() && qtarget.Distance(Me.ServerPosition) > 535)
{
if (qtarget.Distance(Me.ServerPosition) <= 535 + Quickdraw.Range)
{
if (Quickdraw.IsReady() && Utils.GameTimeTickCount - LR >= 1200)
{
if (Me.GetAutoAttackDamage(qtarget) * 3 >= qtarget.Health)
{
CastE(qtarget);
}
}
}
}
}
public async Task<IEnumerable<Prediction>> GetLatestPrediction(string deviceId)
{
var storageConnectionString = _settings.StorageConnectionString;
var table = await AzureTableStorageHelper.GetTableAsync(storageConnectionString, _settings.PredictionTableName);
var startTime = DateTimeOffset.Now.AddSeconds(-TimeOffsetInSeconds).DateTime;
var deviceFilter = TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal, deviceId);
var timestampFilter = TableQuery.GenerateFilterConditionForDate("Timestamp", QueryComparisons.GreaterThanOrEqual, startTime);
var filter = TableQuery.CombineFilters(deviceFilter, TableOperators.And, timestampFilter);
TableQuery<PredictionRecord> query = new TableQuery<PredictionRecord>()
.Where(filter)
.Take(MaxRecordsToReceive)
.Select(new[] { "Timestamp", "Rul" });
var result = new Collection<Prediction>();
var entities = table.ExecuteQuery(query)
.OrderByDescending(x => x.RowKey)
.Take(MaxRecordsToSend);
foreach (var entity in entities)
{
var prediction = new Prediction
{
DeviceId = entity.PartitionKey,
Timestamp = entity.Timestamp.DateTime,
RemainingUsefulLife = (int)double.Parse(entity.Rul),
Cycles = int.Parse(entity.RowKey)
};
result.Add(prediction);
}
return result.OrderBy(x => x.Cycles);
}
internal static void GravesOnUpdate(EventArgs args)
{
Target = TargetSelector.GetTarget(Chargeshot.Range, TargetSelector.DamageType.Physical);
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
{
GravesCombo();
}
if (MainMenu.Item("autosmoke").GetValue <bool>() && Smokescreen.IsReady())
{
foreach (var hero in HeroManager.Enemies.Where(x => x.IsValidTarget(Smokescreen.Range)))
{
Smokescreen.CastIfHitchanceEquals(hero, HitChance.Immobile);
}
}
if (MainMenu.Item("fleekey").GetValue <KeyBind>().Active)
{
if (Utils.GameTimeTickCount - LM >= 100)
{
Me.IssueOrder(GameObjectOrder.MoveTo, Game.CursorPos);
LM = Utils.GameTimeTickCount;
}
if (Smokescreen.IsReady() && Target.IsValidTarget(Smokescreen.Range))
{
Smokescreen.CastIfHitchanceEquals(Target, HitChance.Medium);
}
else if (Quickdraw.IsReady())
{
if (Utils.GameTimeTickCount - LE > 500)
{
Quickdraw.Cast(Game.CursorPos);
}
}
}
if (MainMenu.Item("allin").GetValue <KeyBind>().Active)
{
if (!Me.Spellbook.IsCastingSpell)
{
Orbwalking.Orbwalk(Target, Game.CursorPos);
}
if (Target.IsValidTarget(Chargeshot.Range))
{
var rpred = Prediction.GetPrediction(Target, 0.25f).UnitPosition;
if (rpred.Distance(Me.ServerPosition) <= Quickdraw.Range + 200)
{
if (Chargeshot.IsReady() && Quickdraw.IsReady() && Buckshot.IsReady())
{
Chargeshot.CastIfHitchanceEquals(Target, HitChance.High);
}
}
}
}
if (Target.IsValidTarget() && Chargeshot.IsReady())
{
foreach (var hero in HeroManager.Enemies.Where(x => x.IsValidTarget(Chargeshot.Range)))
{
if (GetRDamage(hero) >= hero.Health && MainMenu.Item("secure").GetValue <bool>())
{
var pred = Prediction.GetPrediction(hero, 0.25f).UnitPosition;
if (pred.Distance(Me.ServerPosition) <= Me.AttackRange)
{
if (Me.GetAutoAttackDamage(hero, true) * 2 >= hero.Health)
{
return;
}
}
Chargeshot.CastIfHitchanceEquals(hero, HitChance.High);
}
}
if (MainMenu.Item("shootr").GetValue <KeyBind>().Active)
{
Chargeshot.CastIfHitchanceEquals(Target, HitChance.VeryHigh);
}
if (MainMenu.Item("usercombo").GetValue <bool>())
{
if (Proj1(Target.ServerPosition, Chargeshot.Width, Chargeshot.Range) >=
MainMenu.Item("rmulti").GetValue <Slider>().Value)
{
if (Orbwalker.ActiveMode == Orbwalking.OrbwalkingMode.Combo)
{
if (Target.CountAlliesInRange(650) >= 2)
{
Chargeshot.CastIfHitchanceEquals(Target, HitChance.Medium);
}
}
}
}
}
}
public static Dictionary<long, Dictionary<string, List<double>>> GetSliceLocationThreats(Prediction prediction)
{
Dictionary<long, Dictionary<string, List<double>>> sliceLocationThreats = new Dictionary<long, Dictionary<string, List<double>>>();
DiscreteChoiceModel model = prediction.Model;
long sliceTicks = -1;
if (model is TimeSliceDCM)
sliceTicks = (model as TimeSliceDCM).TimeSliceTicks;
Dictionary<int, Point> idPoint = new Dictionary<int, Point>();
foreach (Point point in prediction.Points)
idPoint.Add(point.Id, point);
foreach (PointPrediction pointPrediction in prediction.PointPredictions)
{
long slice = 1;
if (sliceTicks > 0)
slice = pointPrediction.Time.Ticks / sliceTicks;
PostGIS.Point point = idPoint[pointPrediction.PointId].Location;
int row = (int)((point.Y - prediction.PredictionArea.BoundingBox.MinY) / prediction.PredictionPointSpacing);
int col = (int)((point.X - prediction.PredictionArea.BoundingBox.MinX) / prediction.PredictionPointSpacing);
string location = row + "-" + col;
sliceLocationThreats.EnsureContainsKey(slice, typeof(Dictionary<string, List<double>>));
sliceLocationThreats[slice].EnsureContainsKey(location, typeof(List<double>));
sliceLocationThreats[slice][location].Add(pointPrediction.TotalThreat);
}
return sliceLocationThreats;
}
private void OnUpdate()
{
if (TargetSelector.IsActive)
{
OffTarget = TargetSelector.Active.GetTargets().FirstOrDefault();
Context.Particle.Remove("Text");
}
else
{
Context.Particle.AddOrUpdate(
Owner,
"Text",
"materials/ensage_ui/particles/text.vpcf",
ParticleAttachment.AbsOrigin,
RestartType.None,
0,
Owner.Position - new Vector3(0, 200, 0),
1,
new Vector3(121, 8611111, 231651),
2,
new Vector3(111, 1111121, 115111),
3,
new Vector3(113, 1151114, 111111),
4,
new Vector3(111, 1111111, 111118),
5,
new Vector3(111, 1111511, 111111),
6,
new Vector3(111, 1111111, 111111),
7,
new Vector3(511, 1111111, 111111),
10,
new Vector3(50, 16, 0),
11,
new Vector3(255, 0, 0));
}
var Targets =
EntityManager <Hero> .Entities.OrderBy(x => x == OffTarget).Where(
x => x.IsValid && x.IsVisible && x.Team != Owner.Team && !x.IsIllusion).ToList();
if (OffTarget != null)
{
var Input =
new PredictionInput(
Owner,
OffTarget,
1,
float.MaxValue,
2000,
420,
PredictionSkillshotType.SkillshotCircle,
true,
Targets)
{
CollisionTypes = CollisionTypes.None
};
Output = Prediction.GetPrediction(Input);
}
if (OffTarget != null &&
OffTarget.Distance2D(Output.CastPosition) <= 1000 && Output.AoeTargetsHit.Count >= (Config.AmountItem.Value == 1 ? 0 : Config.AmountItem.Value))
{
Context.Particle.AddOrUpdate(
Owner,
"BlackHoleRadius",
"particles/ui_mouseactions/drag_selected_ring.vpcf",
ParticleAttachment.AbsOrigin,
RestartType.None,
0,
Output.CastPosition,
1,
Color.Aqua,
2,
420 * 1.1f);
}
else
{
Context.Particle.Remove("BlackHoleRadius");
}
Lens = Owner.GetItemById(AbilityId.item_aether_lens);
if (Blink != null && Config.ComboRadiusItem.Value)
{
Context.Particle.DrawRange(
Owner,
"ComboRadius",
Blink.CastRange + (Lens != null ? Lens.GetCastRange() : 0),
Color.Aqua);
}
else
{
Context.Particle.Remove("ComboRadius");
}
if (Target != null || OffTarget != null)
{
Context.Particle.DrawTargetLine(
Owner,
"Target",
Target != null ? Target.Position : (Output != null && Output.AoeTargetsHit.Count
>= (Config.AmountItem.Value == 1 ? 0 : Config.AmountItem.Value))
? Output.CastPosition : OffTarget.Position,
Target != null ? Color.Red : Color.Aqua);
}
else
{
Context.Particle.Remove("Target");
}
if (!CanExecute && Target != null)
{
Target = null;
}
}
public static Dictionary<string, List<double>> GetOverallLocationThreats(Prediction prediction)
{
Dictionary<string, List<double>> overallLocationThreats = new Dictionary<string, List<double>>();
Dictionary<long, Dictionary<string, List<double>>> sliceLocationThreats = GetSliceLocationThreats(prediction);
foreach (long slice in sliceLocationThreats.Keys)
foreach (string location in sliceLocationThreats[slice].Keys)
overallLocationThreats.Add(slice + "-" + location, sliceLocationThreats[slice][location]);
return overallLocationThreats;
}
public static void UseFleeItems()
{
if (_menu == null || !_menu.Item(_menu.Name + ".enabled").GetValue <bool>())
{
return;
}
try
{
foreach (var item in
Items.Where(
i =>
i.Flags.HasFlag(ItemFlags.Flee) &&
_menu.Item(_menu.Name + "." + i.Name + ".flee").GetValue <bool>() && i.Item.IsOwned() &&
i.Item.IsReady() && i.Item.IsOwned() && i.Item.IsReady() &&
ObjectManager.Player.CountEnemiesInRange(i.Range) >=
_menu.Item(_menu.Name + "." + i.Name + ".min-enemies-range").GetValue <Slider>().Value&&
ObjectManager.Player.HealthPercent <=
_menu.Item(_menu.Name + "." + i.Name + ".player-health-below").GetValue <Slider>().Value&&
ObjectManager.Player.HealthPercent >=
_menu.Item(_menu.Name + "." + i.Name + ".player-health-above").GetValue <Slider>().Value))
{
if (item.CastType != CastType.Self)
{
var lItem = item;
var localItem = item;
foreach (var enemy in
GameObjects.EnemyHeroes.Where(
t =>
t.IsValidTarget() && !Invulnerable.HasBuff(t) &&
t.HealthPercent <=
_menu.Item(_menu.Name + "." + lItem.Name + ".target-health-below")
.GetValue <Slider>()
.Value&&
t.HealthPercent >=
_menu.Item(_menu.Name + "." + lItem.Name + ".target-health-above")
.GetValue <Slider>()
.Value)
.OrderByDescending(
t =>
t.Position.Distance(ObjectManager.Player.Position, true) <
Math.Pow(localItem.Range, 2)))
{
if (!Utils.IsStunned(enemy) && !Utils.IsSlowed(enemy))
{
switch (localItem.CastType)
{
case CastType.Target:
localItem.Item.Cast(enemy);
break;
case CastType.Position:
var prediction = Prediction.GetPrediction(
enemy, localItem.Delay, localItem.Radius, localItem.Speed);
if (prediction.Hitchance >= HitChance.Medium)
{
localItem.Item.Cast(prediction.CastPosition);
}
break;
}
}
}
}
else
{
if (ObjectManager.Player.CountEnemiesInRange(item.Range) >
_menu.Item(_menu.Name + "." + item.Name + ".min-enemies-range").GetValue <Slider>().Value)
{
item.Item.Cast();
}
}
}
}
catch (Exception ex)
{
Global.Logger.AddItem(new LogItem(ex));
}
}
/// <summary>
/// Gets Prediction result
/// </summary>
/// <param name="input">Neccesary inputs for prediction calculations</param>
/// <param name="vectorLenght">Vector Lenght</param>
/// <returns>Prediction result as <see cref="Prediction.Vector.Result"/></returns>
public static Result GetPrediction(Prediction.Input input, float vectorLenght)
{
return GetPrediction(input.Target, input.SpellWidth, input.SpellDelay, input.SpellMissileSpeed, input.SpellRange, vectorLenght, input.Path, input.AvgReactionTime, input.LastMovChangeTime, input.AvgPathLenght, input.RangeCheckFrom.To2D());
}
private void Combo()
{
AIHeroClient target = DrawHelper.GetBetterTarget(W.Range, TargetSelector.DamageType.Magical);
if (target == null)
{
return;
}
if (config.Item("useItems").GetValue <bool>())
{
ItemHandler.UseItems(target, config);
}
if (config.Item("RunFOTT", true).GetValue <bool>() &&
(!config.Item("RunFOTTHP", true).GetValue <bool>() ||
(config.Item("RunFOTTHP", true).GetValue <bool>() && player.Health > target.Health)))
{
Vector3 pos;
if (target.IsMoving)
{
var rand = new Random();
if (ChaseFix)
{
pos = target.Position.Extend(
Prediction.GetPrediction(target, 0.6f).UnitPosition, rand.Next(480, 550));
}
else
{
var positions = CombatHelper.PointsAroundTheTargetOuterRing(target.ServerPosition, 130, 16);
pos = positions[rand.Next(positions.Count)];
}
if (player.Distance(pos) < 90)
{
if (!ChaseFix)
{
ChaseFix = true;
}
else
{
ChaseFix = false;
}
}
}
else
{
pos = Vector3.Zero;
}
if (Orbwalking.CanMove(100))
{
if (player.Distance(pos) > 40 && pos.IsValid())
{
Orbwalking.Move = false;
Orbwalking.Attack = false;
Player.IssueOrder(GameObjectOrder.MoveTo, pos);
}
}
}
var qTarget =
HeroManager.Enemies.FirstOrDefault(
enemy =>
enemy.IsValidTarget() && enemy.Distance(player) < 200 &&
CombatHelper.IsFacing(enemy, player.Position, 90f) &&
!CombatHelper.IsFacing(player, enemy.Position, 90f) && player.IsMoving && enemy.IsMoving);
if (config.Item("useq", true).GetValue <bool>() &&
(qTarget != null || target.HasBuff("poisontrailtarget") || player.Distance(target) <= 500))
{
CastQ();
}
if (config.Item("usew", true).GetValue <bool>() && !config.Item("WwithE", true).GetValue <bool>() &&
W.IsReady() && W.CanCast(target))
{
var tarPered = W.GetPrediction(target);
if (W.Range - 80 > tarPered.CastPosition.Distance(player.Position) &&
tarPered.Hitchance >= HitChance.VeryHigh)
{
W.Cast(tarPered.CastPosition);
}
}
if (R.IsReady() && config.Item("user", true).GetValue <bool>() &&
(((config.Item("rUnderHealt", true).GetValue <Slider>().Value > player.HealthPercent &&
0 < player.CountEnemiesInRange(750)) ||
config.Item("rMinEnemy", true).GetValue <Slider>().Value <= player.CountEnemiesInRange(750)) &&
(!config.Item("rkeepManaE", true).GetValue <bool>() ||
(config.Item("rkeepManaE", true).GetValue <bool>() &&
player.Mana - R.Instance.SData.Mana > E.Instance.SData.Mana))))
{
R.Cast();
}
var ignitedmg = (float)player.GetSummonerSpellDamage(target, Damage.SummonerSpell.Ignite);
bool hasIgnite = player.Spellbook.CanUseSpell(player.GetSpellSlot("SummonerDot")) == SpellState.Ready;
if (config.Item("useIgnite", true).GetValue <bool>() && ignitedmg > target.Health && hasIgnite)
{
player.Spellbook.CastSpell(player.GetSpellSlot("SummonerDot"), target);
}
var blockOrb = false;
var throwPos = target.Position.Extend(player.Position, 500);
if (config.Item("usee", true).GetValue <bool>() && E.IsReady() &&
((throwPos.CountAlliesInRange(700) > target.CountAlliesInRange(700) &&
HeroManager.Allies.FirstOrDefault(a => a.Distance(throwPos) < 700 && a.HealthPercent < 25) == null) ||
W.GetDamage(target) > target.Health || !target.HasBuff("poisontrailtarget") ||
config.Item("WwithE", true).GetValue <bool>()))
{
var pos = Prediction.GetPrediction(target, W.Delay / 2)
.UnitPosition.Extend(player.Position, 515 + player.Distance(target.Position));
if (config.Item("WwithE", true).GetValue <bool>() && E.CanCast(target) && W.IsReady() &&
player.Mana > E.Instance.SData.Mana + W.Instance.SData.Mana + 15 && !pos.IsWall() &&
target.Health > E.GetDamage(target) + Q.GetDamage(target))
{
W.Cast(pos);
return;
}
if (E.CanCast(target))
{
E.CastOnUnit(target);
}
else if (target.Distance(player) < E.Range + 100)
{
blockOrb = true;
}
}
if (blockOrb)
{
Orbwalking.Attack = false;
}
}
