74 replies to this topic

[gamsteron]

GamSterOn BlitzCrank

 

 

Auto Grab ON/OFF

-

Auto Grab only selected target ON/OFF

-

Use Q ON/OFF

-

Use E ON/OFF

-

Use R ON/OFF

-

Auto Cast Q on dash - only GPred ON/OFF

-

Use E if enemy in aa range ON/OFF

-

Use E if Q Cast Pred possible ON/OFF

-

no collide R with Q

-

no collide E with Q

-

Prediction List: Open Predict, GPrediction

-

Hitchance Slider

-

Focus List

-

Manual Target Select

-

Focus only selected target - even if none target is selected ON/OFF

-

Target Selector from focus list calculate enemy hp, magic resist, attack damage, attack speed, ability power - all in one

 

 

platinum elo:

 
 
 

Download

 https://raw.githubus.../Blitzcrank.lua

 

credits to: MeoBeo Icesythe7

[Required]

Good job! Nice to see new people here

[FlyFloop]

I made my own prediction + target selector + object manager [ofc this is first release, we can do better and faster pred etc.]. There's BLITZGRAB:

 

https://raw.githubus.../Blitzcrank.lua

 

platin

GJ

[Cloud]

All I can say is. Good job.

[gamsteron]

1.2 [2016.04.29 15:20]

better orbwalking - blitz spell logic

 

1.1

fixed orbwalker + added melee movement

R after Q

hitchance from 3 to 6

 

 

 

what to do ?:

-fix minion collision + add malza, heimer minions etc.

-better prediction: add logic lose/gain vision etc.

-better target selector

-spell timers attack only if q, r not ready or q collision or time to spell > x[ms], maybe e after attack ?

[Icesythe7]

autoupdater http://gamingonstero...e-for-everyone/

[kuteznh0k]

i added and enable that then how to use in the game? press any button?

[Deftsu]

i added and enable that then how to use in the game? press any button?

shift

[gamsteron]

1.3

* auto update

* new menu (on/off functions etc., pred hitchance)

* Target Selector:

-> remove usless code

-> added manual target selector -> left mouse click

-> attack and use spells only on champions from list in menu

 

 

soon:

minion collision fix + minion waypoint analysis + more object collision (champions etc.) and more prediction changes

+ more

[CptZeyx]

doing a really awesome work! Well done mysterious member 

[Hanndel]

doing a really awesome work! Well done mysterious member 

[gamsteron]

1.4

fiixed manual selected target -> added validtarget..

fixed focus champions from list - now is perfect

[Ryzuki]

Wow. So OPP   gj guy 

[gamsteron]

1.5

removed orb logic after spells before spells -> now combo is faster !

[acelya]

Nice one o:

[velikistrumf]

So op script gg

[castle]

gj matte

i'm in a relationship with this script

[Icesythe7]

add 

if myHero.charName ~= "Blitzcrank" then
  return 
end

to top of your script so people that don't turn scripts off dont load the script for a champion other than blitzcrank

[gamsteron]

add 

if myHero.charName ~= "Blitzcrank" then
  return 
end

to top of your script so people that don't turn scripts off dont load the script for a champion other than blitzcrank

 

1.6 added

 

i made new prediction logic c#:  -> i'll add this in 1.7 update

 

		public static Vector3 GetPosition(Obj_AI_Base unit, int extension)
		{
			int id = unit.NetworkId;
			int count = Events.waypoints[id].count;
			if (count < 3)
			{
				Vector3 p0 = unit.Position;
				Vector3 p1 = Events.waypoints[id].paths[1];
				float p0x = p0.X;
				float p0y = p0.Y;
				float p1x = p1.X;
				float p1y = p1.Y;
				float dist = (float)Math.Sqrt((p1x-p0x)*(p1x-p0x)+(p1y-p0y)*(p1y-p0y));
				if (dist > extension)
				{
					float dirx = (p1x-p0x) / dist;
					float diry = (p1y-p0y) / dist;
					float x = p0x + ( dirx * extension );
					float y = p0y + ( diry * extension );
					return new Vector3 { X = x, Y = y };
				}
				return p1;
			}
			return PointOnRoad(unit, extension);
		}
		
		static Vector3 PointOnRoad(Obj_AI_Base unit, int extension)
		{
			int id = unit.NetworkId;
			int count = Events.waypoints[id].count;
			float ums = unit.MoveSpeed;
			float lmt = Events.waypoints[id].last_move_time;
			float di = 0f;
			float gt = Game.Time*1000;
			for (int i = 1; i < count; i++)
			{
				Vector3 pi0 = Events.waypoints[id].paths[i-1];
				Vector3 pi1 = Events.waypoints[id].paths[i];
				float pi0x = pi0.X;
				float pi0y = pi0.Y;
				float pi1x = pi1.X;
				float pi1y = pi1.Y;
				float disti = (float)Math.Sqrt((pi1x-pi0x)*(pi1x-pi0x)+(pi1y-pi0y)*(pi1y-pi0y));
				di = di + disti;
				if (di>ums*(gt-lmt)/1000)
				{
					Vector3 pu = unit.Position;
					float pux = pu.X;
					float puy = pu.Y;
					float distu = (float)Math.Sqrt((pi1x-pux)*(pi1x-pux)+(pi1y-puy)*(pi1y-puy));
					if (distu > extension)
					{
						float dirx = (pi1x - pux)/distu;
						float diry = (pi1y - puy)/distu;
						float x = pux + ( dirx * extension );
						float y = puy + ( diry * extension );
						return new Vector3 { X = x, Y = y };
					}
					if (i == count - 1)
					{
						return pi1;
					}
					float dj = distu;
					for (int j = i+1; j < count; j++)
					{
						Vector3 pj0 = Events.waypoints[id].paths[j-1];
						Vector3 pj1 = Events.waypoints[id].paths[j];
						float pj0x = pi0.X;
						float pj0y = pi0.Y;
						float pj1x = pi1.X;
						float pj1y = pi1.Y;
						float distj = (float)Math.Sqrt((pj1x-pj0x)*(pj1x-pj0x)+(pj1y-pj0y)*(pj1y-pj0y));
						if (distj > extension - dj)
						{
							float dirx = (pj1x - pj0x)/distj;
							float diry = (pj1y - pj0y)/distj;
							float x = pux + ( dirx * extension );
							float y = puy + ( diry * extension );
							return new Vector3 { X = x, Y = y };
						}
						if (j == count - 1)
						{
							return pj1;
						}
						dj = dj + distj;
					}
				}
			}
			return Vector3.Zero;
		}

[Cloud]

 

1.6 added

 

i made new prediction logic c#:  -> i'll add this in 1.7 update

 

		public static Vector3 GetPosition(Obj_AI_Base unit, int lenght)
		{
			if (Events.waypoints[unit.NetworkId].count < 3)
			{
				float x = Events.waypoints[unit.NetworkId].paths[1].X - unit.Position.X;
				float y = Events.waypoints[unit.NetworkId].paths[1].Y - unit.Position.Y;
				float dist = GetDistance(x, y);
				if (dist > lenght)
				{
					Vector3 dir = (Events.waypoints[unit.NetworkId].paths[1] - unit.Position) / dist;
					return unit.Position + (dir * lenght);
				}
				return Events.waypoints[unit.NetworkId].paths[1];
			}
			return PointOnRoad(unit, lenght);
		}
		
		static Vector3 PointOnRoad(Obj_AI_Base unit, int extension)
		{
			float d = 0f;
			for (int i = 1; i < Events.waypoints[unit.NetworkId].count; i++)
			{
				float xx = Events.waypoints[unit.NetworkId].paths[i].X - Events.waypoints[unit.NetworkId].paths[i-1].X;
				float yy = Events.waypoints[unit.NetworkId].paths[i].Y - Events.waypoints[unit.NetworkId].paths[i-1].Y;
				d = d + GetDistance(xx,yy);
				if ( d > unit.MoveSpeed * ( ( Game.Time * 1000 ) - Events.waypoints[unit.NetworkId].last_move_time ) / 1000 )
				{
					float dist = 0f;
					float x = Events.waypoints[unit.NetworkId].paths[i].X - unit.Position.X;
					float y = Events.waypoints[unit.NetworkId].paths[i].Y - unit.Position.Y;
					dist = GetDistance(x,y);
					if (dist > extension)
					{
						Vector3 dir = ( Events.waypoints[unit.NetworkId].paths[i] - unit.Position ) / dist;
						return unit.Position + ( dir * extension );
					}
					if (i == Events.waypoints[unit.NetworkId].count - 1)
					{
						return Events.waypoints[unit.NetworkId].paths[i];
					}
					for (int j = i+1; j < Events.waypoints[unit.NetworkId].count; i++)
					{
						float x2 = Events.waypoints[unit.NetworkId].paths[j].X - Events.waypoints[unit.NetworkId].paths[j-1].X;
						float y2 = Events.waypoints[unit.NetworkId].paths[j].Y - Events.waypoints[unit.NetworkId].paths[j-1].Y;
						float dist2 = GetDistance(x2,y2);
						if (dist2 > extension - dist)
						{
							Vector3 dir = ( Events.waypoints[unit.NetworkId].paths[j] - Events.waypoints[unit.NetworkId].paths[j-1] ) / dist2;
							return Events.waypoints[unit.NetworkId].paths[j-1] + ( dir * ( extension - dist ) );
						}
						if (j == Events.waypoints[unit.NetworkId].count - 1)
						{
							return Events.waypoints[unit.NetworkId].paths[j];
						}
						dist = dist + dist2;
					}
				}
			}
			return Vector3.Zero;
		}

Nice.