I wanted to ask you if among all those great blog-tutorials of yours, there is simple ball-to-ball collision resonse tutorial. Like billiard kind of 2D physics? I need it for a game Im working on that needs collision response between circular asteroids. (including mass)

If not, would you please consider writing one?

There probably is, but it’ll be buried somewhere on the blitzbasic.com forums. So, here’s a new one!

The key insight for ball-to-ball collisions is that, at the moment of impact, the distance between the two balls is the sum of their radii, and the repulsive force is applied along the line between their centres. I’m going to use a lot of vector maths here, because it makes the maths a lot clearer.

So, the first task to detect a collision is to get the distance between the centres of the two balls. If the distance is less than their radii added together, then the balls have collided.

I’ll build up what needs to happen next through a few example cases. I’m not going to really explain the mechanics in depth because there’s loads of messy algebra and I have better things to do, but this should give you the idea.

Case 1: Ball 1 is stationary, ball 2 is travelling directly at ball 1, both balls have the same mass.

When the balls collide, the total momentum needs to be preserved, and the forces applied to each ball need to be of the same size. I’ll also assume the collision is elastic, so the total kinetic energy of the system stays the same. The only solution is that all of ball 2′s momentum is transferred to ball 1. Ball 2 stops and ball 1 starts moving in the same direction and at the same speed as ball 2.

Case 2: Ball 1 is stationary, ball 2 is travelling directly at ball 2, different masses.

One of Newton’s laws of motion is that force  is equal to mass times acceleration:

As the forces applied to each ball need to be equal, it follows that if the balls have different masses, the heavier ball accelerates less than the lighter one. In fact, the acceleration of ball 1 is proportional to

This way, the momentum is conserved:

Case 3: Both balls moving, ball 2 is travelling directly at ball 1, equal masses.

When both balls are moving, you can make the calculation simpler by considering only the relative velocities of the balls. By subtracting ball 1′s velocity from ball 2′s, you can perform the calculation as if ball 1 is stationary, and the resulting force will be the same.

Case 4: Ball 1 stationary, ball 2 hits ball 1 at an angle, equal masses.

The force is applied along the line between the two balls, so when that line isn’t parallel to the relative velocity, the balls bounce off each other at an angle.

All those cases put together should be enough to solve collisions in general. Here’s some code:

Global gwidth=800,gheight=600

Global balls:TList=New TList
Type ball
	Field x#,y#		'position
	Field vx#,vy#		'velocity
	Field radius#
	Field mass#

	Method New()
		balls.addlast Self
	End Method

	Function Create:ball(x#,y#,radius#,mass#)
		b:ball=New ball
		b.x=x
		b.y=y
		b.radius=radius
		b.mass=mass
		b.vx=(gwidth/2-x)*.01
		b.vy=(gheight/2-y)*.01
		Return b
	End Function

	Method update()
		x:+vx
		y:+vy

		'wrap edges of screen around
		If x<0
			x:+gwidth
		EndIf
		If x>gwidth
			x:-gwidth
		EndIf
		If y<0
			y:+gheight
		EndIf
		If y>gheight
			y:-gheight
		EndIf
	End Method

	Function collideAll()
		l:TList=balls.Copy()
		While l.Count()>1
			b:ball=ball(l.removefirst())
			For b2:ball=EachIn l

				dx#=b2.x-b.x		'get relative positions of b2 with respect to b
				dy#=b2.y-b.y
				d#=Sqr(dx*dx+dy*dy)	'get square of distance between b and b2

				dd#=b.radius+b2.radius-d	'get amount balls overlap

				If dd>0	'if distance between balls is less than their radii added together, then they are overlapping

					dx:/d	'by dividing the difference between the two balls' positions, we get a unit vector pointing from b to b2
					dy:/d

					dvx#=b2.vx-b.vx	'get relative velocity of b2 with respect to b
					dvy#=b2.vy-b.vy

					f#=dvx*dx+dvy*dy		'calculate force of impact - project relative velocity vector onto line from b to b2
					f:*2/(b.mass+b2.mass)	

					b2.vx:-dx*f*b.mass	'push b2 away from b
					b2.vy:-dy*f*b.mass

					b.vx:+dx*f*b2.mass	'push b in the opposite direction
					b.vy:+dy*f*b2.mass

					b.x:-dd*dx*b2.mass/(b.mass+b2.mass)	'position the balls so they are just touching and no longer overlap
					b.y:-dd*dy*b2.mass/(b.mass+b2.mass)
					b2.x:+dd*dx*b.mass/(b.mass+b2.mass)
					b2.y:+dd*dy*b.mass/(b.mass+b2.mass)

				EndIf

			Next
		Wend
	End Function

	Method draw()
		shade#=mass*5
		SetColor shade,shade,shade
		DrawOval x-radius,y-radius,radius*2,radius*2

		'because the edges of the screen wrap round, draw again shifted by a screen's width/height to maintain the illusion
		DrawOval gwidth+x-radius,y-radius,radius*2,radius*2
		DrawOval x-radius,gheight+y-radius,radius*2,radius*2
		DrawOval -gwidth+x-radius,y-radius,radius*2,radius*2
		DrawOval x-radius,-gheight+y-radius,radius*2,radius*2
	End Method

End Type

Function changeState()
	balls=New TList
	state=(state+1) Mod 5
	Select state
	Case 0
		b1:ball=ball.Create(400,300,50,50)
		b1.vx=0
		b1.vy=0
		b2:ball=ball.Create(200,300,50,50)
		b2.vx=1
		b2.vy=0
	Case 1
		b1:ball=ball.Create(400,300,50,50)
		b1.vx=0
		b1.vy=0
		b2:ball=ball.Create(200,300,20,20)
		b2.vx=1
		b2.vy=0
	Case 2
		b1:ball=ball.Create(400,300,50,50)
		b1.vx=1
		b1.vy=0
		b2:ball=ball.Create(200,300,50,50)
		b2.vx=2
		b2.vy=0

		b3:ball=ball.Create(400,450,50,50)
		b3.vx=0
		b3.vy=0
		b4:ball=ball.Create(200,450,50,50)
		b4.vx=1
		b4.vy=0
	Case 3
		b1:ball=ball.Create(400,300,50,50)
		b1.vx=-1
		b1.vy=0
		b2:ball=ball.Create(200,250,50,50)
		b2.vx=1
		b2.vy=0

	Case 4
		For c=1 To 5
			radius#=Rnd(10,50)
			mass=Rnd(.5,1)*radius
			ball.Create Rand(radius,gwidth-radius),Rand(radius,gheight-radius),radius,mass
		Next
	End Select
End Function

Function drawlines(txt$,x,y)
	Local lines$[]=txt.split("~n")
	For i=0 To Len(lines)-1
		DrawText lines[i],0,y
		y:+13
	Next
End Function

Graphics gwidth,gheight,0
SeedRnd MilliSecs()

Global state=-1
Global statetxt$[]=[	"Ball 1 stationary~nBall 2 heading directly at ball 1~nEqual masses",..
					"Ball 1 stationary~nBall 2 heading directly at ball 1~nDifferent masses",..
					"Both balls moving~nBall 2 heading directly at ball 1~nEqual masses~nBall 1's frame of reference shown below",..
					"Ball 1 stationary~nBall 2 hits ball 1 at an angle~nEqual masses",..
					"Lots of balls all over the place!"]

changeState

While Not (KeyHit(KEY_ESCAPE) Or AppTerminate())

	If KeyHit(KEY_SPACE)
		changeState
	EndIf

	ball.collideAll

	For b:ball=EachIn balls
		b.update
	Next

	For b:ball=EachIn balls
		b.draw
	Next

	SetColor 255,255,255
	Drawlines statetxt[state],0,0

	Flip
	Cls
Wend

I’m having a math-related crisis that one man (me) can not do alone. I’m trying to figure out a way to calculate the radius of the ellipse on the same angle as the light blue line; in other words, the length of the “mystery line.”

He attached a picture which didn’t do too much to help explain matters, but what he wanted to know was the distance from the centre of the ellipse to the edge, at a given angle.

We can assume that the ellipse is oriented vertically. The locus of the edge of the ellipse is, in this case,

where and are the horizontal and vertical radii.

We want to know the length of the line heading at an angle from the vertical to the edge of the ellipse. Call the length , so the co-ordinates of the end are given by

Substitute those into the first equation:

Take a factor of out:

and rearrange:

Here’s some code:

Graphics 600,600,0

an = 60
While Not (KeyHit(KEY_ESCAPE) Or AppTerminate())

	ew# = MouseX()-300
	eh# = MouseY()-300

	SetColor 100,100,100
	DrawOval 300-ew,300-eh,ew*2,eh*2

	an:+1

	l# = Sqr( 1/( (Sin(an)/ew)^2 + (Cos(an)/eh)^2) )

	lx# = 300+l*Sin(an)
	ly# = 300-l*Cos(an)

	SetColor 0,0,255
	DrawLine 300,300,lx,ly

	Flip
	Cls
Wend

Bresenham isn’t the right algorithm for this – the gaps between the dots are bound to be a lot bigger than single pixels, so ‘stupid’ linear interpolation should do the job satisfactorily.

However, if you want to make sure you definitely draw the start and end points of a line, as well as dots in between, or if you want to draw a line made up of several segments, it gets a bit more complicated.

Here are two methods:

The first tries to draw each line segment so that its start and end points get a dot, and then it changes the size of the gaps slightly so that all the dots are evenly spaced right up to the end.

The second goes along between the points, drawing dots at the given distance apart from each other. It might not draw dots exactly on the given points, but the dots are always exactly the right distance apart.

Strict

'this method will draw each line segment individually
'it will change the gap slightly so that the dots are spread evenly along each segment
'it always draws a dot on each corner and endpoint
Function drawdots1(points#[], gap#)
	If Len(points)<4 Return	'need at least two pairs of co-ordinates

	Local sx#,sy#,ex#,ey#
	Local dx#,dy#,d#,steps,tgap#
	Local x#,y#

	DrawDot points[0],points[1]	'draw a dot at the start of the line

	For Local i=0 To Len(points)-3 Step 2		'draw each line segment

		sx=points[i]			'get start and end of this segment
		sy=points[i+1]
		ex=points[i+2]
		ey=points[i+3]

		dx# = ex-sx			'calculate a vector in the direction of the line, so we can get the distance
		dy# = ey-sy
		d# = Sqr(dx*dx+dy*dy)

		steps = round(d/gap)	'work out how many dots to draw (distance between the points, divide by the desired gap size). Round to nearest whole number
		tgap# = d/steps		'work out what the gap needs to be to space the calculated number of needed dots evenly

		dx:*tgap/d			'work out the vector between each dot
		dy:*tgap/d

		For Local j=1 To steps
			x# = sx+j*dx	'calculate the dot's position by adding the gap vector to the position of the start of the line
			y# = sy+j*dy
			DrawDot x,y	'draw a dot
		Next
	Next
End Function

'this method will draw dots evenly spaced along the whole set of lines
'it might not draw dots on the corners.
Function drawdots2(points#[],gap#)
	If Len(points)<4 Return	'need at least two pairs of co-ordinates

	Local sx#,sy#,ex#,ey#
	Local dx#,dy#,d#,tstep#
	Local x#,y#

	Local t#=0	't will keep track of how far along each line segment we are - 0 for at the start, 1 for at the end

	For Local i=0 To Len(points)-3 Step 2	'go through the line segments

		sx=points[i]			'get start and end of this segment
		sy=points[i+1]
		ex=points[i+2]
		ey=points[i+3]

		dx = ex-sx			'work out a vector in the direction of the line
		dy = ey-sy
		d = Sqr(dx*dx+dy*dy)	'work out the length of the line

		tstep# = gap/d		'work out what fraction of the line each gap represents

		While t<1		'draw dots until we reach the end of the line

			x = sx+dx*t	'work out the position of the dot by multiplying the vector by t
			y = sy+dy*t
			DrawDot x,y	'draw the dot
			t:+tstep		'increase t by the amount corresponding to a gap
		Wend

		t:-1				'when we reach the end of the line, t might be more than 1, meaning we didn't manage to get a whole gap in at the end
						'subtract 1 from t, and carry over the remainder to the next line segment
	Next

	DrawDot ex,ey			'draw the end point of the line.
End Function

Function DrawDot(x#,y#)
	DrawOval x-2,y-2,4,4
End Function

Function Round(f#)	'round a floating point number to the nearest whole number
	Local i = Floor(f)
	If f-i>=.5
		Return i+1
	Else
		Return i
	EndIf
End Function

Graphics 800,600,0
Local points#[]
Local mode=0
Local gapsize#=20

While Not (KeyHit(KEY_ESCAPE) Or AppTerminate())
	DrawText "Click the mouse!",0,0
	DrawText "Right-click to change methods",0,15
	DrawText "Press up/down to change gap size",0,30

	If MouseHit(1)
		points :+ [Float(MouseX()),Float(MouseY())]
		If Len(points)>16
			points=points[2..]
		EndIf
	EndIf

	If MouseHit(2)
		mode=1-mode
	EndIf

	gapsize :+ (KeyDown(KEY_UP)-KeyDown(KEY_DOWN))*.25
	If gapsize<1 gapsize=1
	DrawText "Gap Size: "+gapsize,400,15

	If mode=0
		drawdots1(points,gapsize)
		DrawText "Using Method 1",400,0
	Else
		drawdots2(points,gapsize)
		DrawText "Using Method 2",400,0
	EndIf
	Flip
	Cls
Wend

Edited on 4/5/2011: anubis pointed out that the posted code was all mangled. I think I’ve fixed it, but in case I haven’t, here’s a link to the bmx file.

I know the following:

- The equation of the line L1
- The point (x1, y1)
- The perpendicular distance d
- L1 and L are parallel

However, I need to determine either:

- The equation of the line L, or
- The point (X, Y) (from which the equation of the line L can be easily derived)

Easy enough, when you think in terms of vectors.

• Let a be the point (x1,y1) on L1. Let b be the direction of L1.
• Find the unit vector n perpendicular to b.
• Then the point (x,y) = a+d*n.

Here’s some BlitzMax code:

Graphics 600,600,0

Global ax#=300,ay=300# 'a point on L1
Global bx#,by# 'the direction of L1
Global d#=50 'the distance of L from L1

DrawLine ax+vx*v,ay+vy*v,ax+vx*(v-8)+px*8,ay+vy*(v-8)+py*8
DrawLine ax+vx*v,ay+vy*v,ax+vx*(v-8)-px*8,ay+vy*(v-8)-py*8
End Function


Does any one know how to do this?

I know the following:

* Start x,y
* End x,y
* Gravity
* Height of the wall

Diagrams:

………………..wall
____s______|__________e_________

_s_|
……|
……|
……|_e_

etc

Any ideas?

where is distance travelled, is initial velocity, is acceleration, and is time elapsed.

Suppose that the projectile reaches the wall at and the end point at .

We’ll say that the distance from the start to the wall is , the distance to the end point is , and the height of the wall is .

We’ll also say that the speed of the projectile is  and the angle it is fired at is .

We can rearrange the first two equations (involving three unknowns, so we definitely need the other two!) to find in terms of :

Use the fact that to get

Substitute the thing we had for to get

Cancel down the left side and use :

Hooray, we’ve got a formula for ! Once we’ve found that, we can put it back into the handy equation for , and we’ve got both the angle and speed of the projectile. Remember this give the minimum solution – you can increase and rearrange the handy equation to get a suitable value for .

Graphics 600,600,0
Global bullets:TList=New TList
Type bullet
	Field x#,y#
	Field vx#,vy#
	Field path#[]

	Function Create:bullet(x#,y#,vx#,vy#)
		b:bullet=New bullet
		bullets.addlast b
		b.x=x
		b.y=y
		b.vx=vx
		b.vy=vy
		Return b
	End Function

	Method update()
		path:+[x,y]

		x:+vx
		y:+vy
		vy:+g
		DrawRect x-5,y-5,10,10

		For i=0 To Len(path)-1 Step 2
			DrawRect path[i],path[i+1],1,1
		Next

		If x>600 Or y>600
			bullets.remove Self
		EndIf
	End Method
End Type

Const g#=1,x1#=300

While Not (KeyHit(KEY_ESCAPE) Or AppTerminate())
	x2#=MouseX()
	y#=MouseY()-300

	DrawLine 300,300,300,300+y
	DrawLine 0,300,x2,300

	If MouseHit(1)
		If x2>x1 And y<0
			theta# = ATan(-y*x2/(x2*x1-x1*x1))
			v=Sqr(g*x2/(Sin(2*theta)))
			Print theta
			Print v
			bullet.Create(0,300,v*Cos(-theta),v*Sin(-theta))
		EndIf
	EndIf

	For bu:bullet=EachIn bullets
		bu.update
	Next

	Flip
	Cls
Wend

My mind’s gone a blank so I’m looking for some help here. What I need is the angle of elevation a weapon needs to be at to launch a projectile and hit a target. The target can be higher or lower than the weapon. I’m working in 2d so have the following information available:

X0 = X coord of weapon
Y0 = Y coord of weapon
X1 = X coord of target
Y1 = Y coord of target
Speed = Launch Speed of projectile
Gravity = -9.8

I’m not interested in including wind resistence etc..

A Level maths to the rescue! Use one of the equations of motion:

Where is the distance travelled, is the initial velocity, is the acceleration, and is time elapsed. We want to find an angle to shoot the projectile at which will satisfy this equation.

Deal with the x- and y-components of motion separately. There’s no acceleration in the x-axis, so that equation will be easy to rearrange to get an expression for :

Now we can put that into the equation for the y-axis:

Now some clever cancelling and use of trig identities:

which, if you’re willing to believe it, is a quadratic equation in . Use the quadratic formula to find and hence . Simples!

… that’s a lie, so here’s some bmax code:

Graphics 600,600,0Graphics 600,600,0
Global bullets:TList=New TList
Type bullet
	Field x#,y#
	Field vx#,vy#
	Field path#[]

	Function Create:bullet(x#,y#,vx#,vy#)
		b:bullet=New bullet
		bullets.addlast b
		b.x=x
		b.y=y
		b.vx=vx
		b.vy=vy
		Return b
	End Function

	Method update()
		path:+[x,y]

		x:+vx
		y:+vy
		vy:+g
		DrawRect x-5,y-5,10,10

		For i=0 To Len(path)-1 Step 2
			DrawRect path[i],path[i+1],1,1
		Next

		If x>600 Or y>600
			bullets.remove Self
		EndIf
	End Method
End Type

'the setup is that you've got a cannon at (0,300), trying to fire at the mouse cursor.
'gravity is directed down the screen and the velocity of the projectiles is fixed at 20 px per frame.
'there will be some inaccuracy in the projectiles drawn on the screen because I'm using a discrete timestep model, due to I'm lazy.

Const g#=1,v#=20

While Not (KeyHit(KEY_ESCAPE) Or AppTerminate())
	sx#=MouseX()
	sy#=MouseY()-300

	a#=g*sx*sx/(2*v*v)	'coefficients of the quadratic equation
	b#=sx
	c#=a-sy

	If b*b>4*a*c	'if solution exists

		t#=(-b+Sqr(b*b-4*a*c))/(2*a)		'this is tan(phi)

		an#=ATan(t)
		DrawLine 0,300,sx,sy+300

		If MouseHit(1)
			bullet.Create 0,300,v*Cos(an),v*Sin(an)
		EndIf

	Else
		DrawText "no solution!",0,0
	EndIf

	For bu:bullet=EachIn bullets
		bu.update
	Next

	Flip
	Cls
Wend

Hope that’s useful!

Andres asked in this post:

i’m having problems with a formula for my early stage game.

i want to calculate how the object bounces (the angle) from the wall.

i know the angle of the wall, object’s moving angle, the point where object and wall collide. If possible then the function or formula would work if the object comes from the other side of the wall too.

Countless other people have asked this as well. It’s one of those things that comes up very often but is quite tricky to work out for yourself.

So, to start with, we’ve got something hitting a wall. We know its velocity before it hits the wall and we want to know what its velocity becomes after it hits the wall. 

When an object bounces off a wall, it travels at the same angle from the wall as it went in at, but the other way round. I stated that in terms of angles, but that’s tricky to get into code because, while people always know to write an angle as 90° anti-clockwise instead of 270° clockwise, and how to do stuff like reflections properly, it isn’t so simple when you’re just dealing with numbers in a computer. For this example, there are four choices of escape angle that you could produce if you’re not careful, but it’s hard to say which one is the correct one.

So instead, consider as a cartesian vector – that is, an x-component and a y-component. We could also think of it as having a component moving parallel to the wall, and one moving perpendicular to it.

In the above image, is the component of the vector which is perpendicular to the wall. If didn’t bounce off the wall but instead kept travelling as it was before, travelling backwards along from the end of would get you back on the line:

And if you move back in the direction of one more time, you’ll end up pointing exactly where you want to be: the angle of escape is the same as the angle of entry.

So that’s the theory – we need to work out and , and the object’s velocity after hitting the wall will be .

is easy – you might already have it in vector form, or if not, you can use and . is the projection of onto the wall’s normal vector. (I’m planning on writing a post about the various vector operations later, but this one takes just a couple of lines of code to work out and considerably more writing to explain, so I won’t.)

And the great thing about this method is that you don’t need to check which side of the wall the object is hitting, or which way round the normal is pointing – it all works out correctly anyway.

Local vx#,vy#		'V, the velocity of the object before it hits the wall
Local wallangle#	'the angle of the wall

'now work out the normal vector to the wall - it's just at right angles
Local nx#,ny#
nx = Cos(wallangle + 90)
ny = Sin(wallangle + 90)

'p is the projection of V onto the normal
Local px#,py#
Local dotproduct# = vx*nx+vy*ny
px = dotproduct*nx
py = dotproduct*ny

'the velocity after hitting the wall is V - 2p, so just subtract 2*p from V
vx = vx - 2*px
vy = vx - 2*py

'done!

I hope that was helpful.

I’m trying to tweak my blur shaders a bit, and I decided to try a gaussian blur. I separate the blur into two passes which means I can get a 9×9 kernel with 18 samples instead of 81, and it also means I need a 1d kernel. The only algorithm I managed to find was for a 2d kernel, and had a couple of symbols I didn’t recognize anyway. (Always my problem.)

Could anyone point me to some code to calculate a 1D gaussian kernel of a variable size? As I say, I’m using a size of 9 right now, but that might change so I had better find the code rather than just a kernel someone created for me.

From a quick google for “gaussian kernel”, here’s the wikipedia page which has the 1d and 2d equations on it, and here’s a pdf which is very interesting to me and explains the maths behind it.

So, it’s just a matter of writing out the equation. The only bit of trouble I had was with picking the right sigma value, but the wikipedia page says

In practice, when computing a discrete approximation of the Gaussian function, pixels at a distance of more than 3*sigma are small enough to be considered effectively zero.

so that’s that solved. Finally, you need to rescale the values in the kernel a bit because there’s a slight error introduced by picking discrete values of the gaussian function, which is really a continuous integral.

Function GaussianKernel#[](radius#)
	width=Ceil(radius)	'kernel will have a middle cell, and width on either side
	Local matrix#[width*2+1]
	sigma# = radius/3		'apparently this is all you need to get a good approximation
	norm# = 1.0 / (Sqr(2*Pi) * sigma)		'normalisation constant makes sure total of matrix is 1
	coeff# = 2*sigma*sigma	'the bit you divide x^2 by in the exponential
	total#=0
	For x = -width To width	'fill in matrix!
		g# = norm * Exp( -x*x/coeff )
		matrix[x+width] = g
		total:+g
	Next
	For x=0 To 2*width	'rescale things to get a total of 1, because of discretisation error
		matrix[x]:/total
	Next
	Return matrix
End Function

By the way, for anyone else who’s wondering, the way to split the blur process into two passes is to apply the 1d kernel horizontally in the first pass, and then vertically in the second pass. This works because the gaussian function is linearly separable.

Given the lengths of c1 and c2 and angle alpha, what’s the simplest and fastest way to calculate the length of d (see the attached image)?

Looks tricky at first, but trying to do it the boring way ended up giving me a nice answer.

What we want is to have the line with angle alpha intersect the hypotenuse of the triangle. So, let’s write down the equations of the two lines:

The hypotenuse can be written using the normal straight line formula:

While the other line is in polar co-ordinates because we only know the angle alpha:

Substitute those into the first equation:

We want to find d, so collect all the terms with d together:

And finally divide by the stuff in the brackets:

Now let’s check that it works with some bmax code:

Graphics 600,600,0

c1#=300
c2#=400

an#=0

While Not (KeyHit(KEY_ESCAPE) Or AppTerminate())
	x#=300-c2/2
	y#=300-c1/2
	DrawLine x,y,x+c2,y
	DrawLine x,y,x,y+c1
	DrawLine x+c2,y,x,y+c1

	an = (an+1) Mod 90

	t#=an/90
	r#=c1/(Sin(an)+(c1/c2)*Cos(an))
	DrawLine x,y,x+Cos(an)*r,y+Sin(an)*r

	Flip
	Cls
Wend

Yep!

Hi, I need help aiming at moving targets for a program. I have the variables for the speed and direction of the enemies, but the targeting is still not accurate enough.

There’s a very simple solution if you don’t mind the bullets travelling at different speeds, but that can lead to bullets travelling very fast or very slow, so let’s say that we want every bullet to go the same speed. Here’s the solution:

Suppose you have a tower at a fixed position , and an enemy at initial position moving in the direction .

You want to shoot a bullet travelling at a certain velocity so that it collides with the enemy.

Let the direction of the bullet be .

If and , then the bullet will move in parallel with the enemy, always staying the same distance from it.

You can now consider that the enemy is not moving at all, relative to the bullet, and the difference in position between them is . The bullet can move along this line to collide with the bullet.

If the bullet takes frames to reach the bullet, we now get:

As we said that the bullet’s velocity is , we get

Which expands out to:

(I had to split that over a few lines so it would fit in the post column, sorry!)

Which is a quadratic equation! So set:

Then, using the quadratic formula:

You can now put that back into the equations for and , and you’re done!

Here’s the result, written in BlitzMax:

diffx:double=x2-x1
diffy:double=y2-y1
v:Double=3                'desired speed of bullet

a:Double=diffx*diffx+diffy*diffy
b:Double=2*(vx*diffx+vy*diffy)
c:Double=vx*vx+vy*vy-v*v

tInv#=(-b+Sqr(b*b-4*a*c))/(2*a)   ' solve 1/t
dx=diffx*tInv+vx
dy=diffy*tInv+vy

That’s it!