Aiming Accurately at Moving Targets

BlitzMax Forums/BlitzMax Programming/Aiming Accurately at Moving Targets

SpaceTW

(Posted 2009) [#1]

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. Here is an example of the code I need corrected:

'This is a siplified version to run without pictures
'The targeting is off since there is no foward targeting.

Graphics 640,480
AutoMidHandle True
Global masterlist:TList = CreateList()


enemy:tenemy=New tenemy
enemy.y=200'Set enemy Y
enemy.x=200'Set enemy X
enemy.speedx=2'Set Enemy Speed x
enemy.speedy=1'Set Enemy speed y
masterlist.addfirst(enemy)

tower:ttower=New ttower
tower.x=300'set tower x
tower.y=300'set tower y


While Not KeyHit(27)
	enemy.updateself
	tower.updateself
	For b:tbullet=EachIn masterlist
		b.move
	Next
	Flip
	Cls
Wend



Type tenemy
	Field x:Float
	Field y:Float
	Field speedx:Float
	Field speedy:Float
	
	Method updateself()
		SetColor(0,0,255)
		For b:tbullet=EachIn masterlist'Simple collision detector
			If b.x<x+15 And b.x>x-15 Then
				If b.y<y+15 And b.y>y-15 Then
					SetColor(255,0,0)
					masterlist.remove(b)
				EndIf
			EndIf
		Next
		DrawOval(x,y,30,30)'Draw
		x=x+speedx'Move
		y=y+speedy
		If x>655 Then x=-15'Loop
		If y>495 Then y=-15
		SetColor(255,255,255)
	End Method
	
	
End Type

Type ttower
	Field x:Float
	Field y:Float
	Field pause:Int
	
	Method updateself()
		SetColor(0,255,0)
		For e:tenemy=EachIn masterlist
			Local dist:Double = Sqr(((e.x)-(x))^2+((e.y)-(y))^2)
			Local xneg:Int=1
			Local yneg:Int=1
			
			Local dx:Double = e.x-x
			If dx<0 Then xneg=-1 Else xneg=1
			Local dy:Double = e.y-y
			If dy<0 Then yneg=-1 Else yneg=1
			Local ratio:Double=Abs(dx/dy)'Sets bullet movement to 5 pixels
			
			
			
			
			Local ftargetX:Double=0'This is the formula missing with it the bullets should always hit.
			Local ftargetY:Double=0
			
			'WRONG CODE
			ftargetX=(dist/5)*e.speedx
			ftargety=(dist/5)*e.speedy
			'End Wrong Code
			
			dx=dx+ftargetX
			dy=dy+ftargetY
			
			
			If dx<0 Then xneg=-1 Else xneg=1
			If dy<0 Then yneg=-1 Else yneg=1
			ratio=Abs(dx/dy)'Sets bullet movement to 5 pixels
			dy=5/(ratio+1)
			dx=5-dy
			dy=dy*yneg
			dx=dx*xneg
			If pause<0 Then
				createbullet(x+15,y+15,dx,dy)
				pause=10
			EndIf
			pause=pause-1
		Next
		DrawRect(x,y,30,30)'Draw
		SetColor(255,255,255)
	End Method
	
EndType

Type tbullet
	Field x:Double
	Field y:Double
	Field dx:Double
	Field dy:Double
	
	Method move()
		x=x+dx
		y=y+dy
		SetColor(255,0,0)
		DrawRect(x,y,5,1)'Bullet
		If x<0 Or x>640 Then masterlist.remove(Self)
		If y<0 Or y>480 Then masterlist.remove(Self)
	EndMethod
	
EndType

Function createbullet(x:Double,y:Double,dx:Double,dy:Double)
	b:tbullet=New tbullet
	b.x=x
	b.y=y
	b.dy=dy
	b.dx=dx
	masterlist.addlast(b)
EndFunction

The ftargetx and y need to properly aim ahead of the enemy so a collision is inevitable for all X and Y speeds. Thanks for any help.

Grey Alien

(Posted 2009) [#2]

You need to use a quadratic equation. Google it :-) I used one for a shoot em up I made years ago in DOS.

Warpy

(Posted 2009) [#3]

OK! This one took a lot of thinking, and beware that there is a lot of maths involved, but you can just use the formula at the end without too much worry.

Suppose you have a tower at a fixed position (x0,y0), and an enemy at initial position (x1,y1) moving in the direction (vx,vy).

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

Let the direction of the bullet be (dx,dy).

If dx=vx and dy=vy, 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 distance between them is (x1-x0,y1-y0). The bullet can move along this line to collide with the bullet.

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

dx = (x1-x0)/t + vx
dy = (y1-y0)/t + vy

As we said that the bullet's velocity is V, we get

dx^2 + dy^2 = V^2

Which expands out to:

(1/t)^2 * ( (x1-x0)^2 + (y1-y0)^2 ) + (1/t) * 2 * ( vx*(x1-x0) + vy*(y1-y0) ) + vx^2 + vy^2 - V^2 = 0

Which is a quadratic equation! So set:

a = (x1-x0)^2 + (y1-y0)^2
b = 2 * ( vx*(x1-x0) + vy*(y1-y0) )
c = vx^2 + vy^2 - V^2

Then:

1/t = (-b + sqr( b*2 - 4*a*c)) / (2*a)

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

In bmax code:

				dx=e.x-x
				dy=e.y-y
				a:Double=dx*dx+dy*dy
				b:Double=2*(e.speedx*dx+e.speedy*dy)
				v:Double=3
				c:Double=e.speedx*e.speedx+e.speedy*e.speedy-v*v
				tInv#=(-b+Sqr(b*b-4*a*c))/(2*a)
				dx=dx*tInv+e.speedx
				dy=dy*tInv+e.speedy

Hope this helps!

By the way, instead of creating a bullet at (x+15,y+15) and drawing the rectangle at (x,y), you should create a bullet at (x,y) and draw the rectangle at (x-15,y-15), so that (x,y) is always at the centre of your tower, which helps with the aiming.

ImaginaryHuman

(Posted 2009) [#4]

Cripes. Seems overly complex. Can't you just monitor and measure the player's current speed and trajectory, extrapolate it to where the player is expected to be at a certain time in the future based on distance to the player, and shoot at that angle? I know that's probably what you're doing but it seems quite complex in the math department.

marksibly

(Posted 2009) [#5]

I used to:

1) Calculate x,y velocity for bullet.

2) Add x,y velocity of player.

3) Done!

*	(Posted 2009) [#6]

trust mark to give a overly simple version that works ROFL :)

Warpy

(Posted 2009) [#7]

ImaginaryHuman: that "certain time" is the tricky bit. If the bullet is going at a certain speed, then there will be only two times at which its path can intesect that of the enemy. That's what the quadratic's about.

Mark's solution doesn't have every bullet going at the same speed, I don't think.

Grey Alien

(Posted 2009) [#8]

Quadratic is best :-p and as Warpy has laid it out in BMax code, no reason not to use it :-)

GW	(Posted 2009) [#9]

Quadratic is best :-p and as Warpy has laid it out in BMax code, no reason not to use it :-)

plus, what Mark said makes no sense.

Nate the Great

(Posted 2009) [#10]

@GW - what mark says makes perfect sense but it will lead to the bullets traveling at different speeds

mark - is this what you are trying to say?

(x0,y0) = tower position
(x1,y1) = enemy position
(vx,vy) = enemy direction/speed vector
(bx,by) = bullet x and y velocities

dist# = sqr((x0-x1)^2 + (y0-y1)^2)
bx = (x1-x0)/dist + vx
by = (y1-y0)/dist + vy

marksibly

(Posted 2009) [#11]

> mark - is this what you are trying to say?

Yep - it basically just puts the bullets into the enemy's 'frame of reference'. You may also want to scale bx/by a bit (before adding vx,vy) to make bullets go a bit faster.

The downside is it can make for very fast bullets depending on how fast the enemy can move, but this may be better than bullets fired at a very steep angle that take forever to get there!

Jesse

(Posted 2009) [#12]

Warpy, Thanks! That helped me out also.
I think it belongs in the code archives so it won't get lost. :)

Vilu	(Posted 2009) [#13]

Warpy, you're a lifesaver. :)

I adapted your snippet for a bit more complex scenario where both the shooter and the target are moving. Also, this one allows the "business end" of the gun to be somewhere else than the center of the rotating shooter.

' offsets indicate the position of the weapon barrel on the shooter
Local xOff:Float = 10
Local yOff:Float = 35
Local myRot:Float = self.GetRot()

' dx and dy represent bullet movement vector
Local dx:Double = target.GetX() - self.GetX() - yOff * Cos(myRot) - xOff * Sin(myRot)
Local dy:Double = target.GetY() - self.GetY() - yOff * Sin(myRot) + xOff * Cos(myRot)
 
' relative velocity of the moving combatants
Local relXVel:Double = target.GetXVel() - self.GetXVel()
Local relYVel:Double = target.GetYVel() - self.GetYVel()

' quadratic equation
Local a:Double = dx * dx + dy * dy
Local b:Double = 2.0 * (relXVel * dx + relYVel * dy)
Local v:Double = GetBulletVelocity()
Local c:Double = relXVel * relXVel + relYVel * relYVel - v * v
Local tInv:Double = (- b + Sqr(b * b - 4.0 * a * c)) / (2.0 * a)
dx = dx * tInv + relXVel
dy = dy * tInv + relYVel

aimDirection = ATan2(dy, dx)

Now those buggers seem to be dead accurate.