Hi Not sure if this should be in the beginners section but here goes anyway. I am continuing the development of my 3D Aeroplane game in Visual c++ 7 and DirectX 9. I am researching how I should handle shooting from my on screen aeroplane to an enemy plane. Both aeroplanes have their own simple bounding boxes around them. I have implemented some basic collision detection so that if the boxes touch a collision is registered. However, I now need to be able to shoot at the other aircraft and register any hits that they receive. I have a small gun sight on screen which will indicate where the bullets will go. I think that having a small bullet being seen to move across the screen would be pointless as it should move too fast to be seen. Also, I am not concerned about physics of bullets in this game. I just need find out how to get a straight line from my aeroplane to the enemy in my gun sights, to simulate that I have fired a shot and that the enemy bounding box has been hit. I have heard of ray casting but I have little information on it. Is this the direction I should be pursuing? If you need anything clarifying then just give me a shout. Thanks Dave

Quote:Original post by Red_Dash

I think that having a small bullet being seen to move across the screen would be pointless as it should move too fast to be seen

I think you should use moving bullets, because I'd think you would want your bullets to be tracers, to see where your shots are going.

Ray casting/Ray tracing is the technique you need to accomplish this. A ray is basically a vector with an origin. The origin is the position of the gun and the vector is the direction the gun is facing. There are a number of ray/object intersection techniques you can implement. It happens to be easy to implement ray/object intersection with quadric surfaces because they are defined implicitly so you may want to use bounding spheres for hit detection. However, using bounding boxes is still acceptable. The position of the ray at any time t is origin + t * direction. Set this equation equal to the equation of your quadric and solve for t. If t is positive, then you intersected. If t is negative, then you intersected but the object is behind you. If t has no solutions or is complex, then you did not intersect.

One problem that always comes up with bounding volume intersection is misses being regarded as hits because the volume doesn't match the object exactly. if your model is low-poly, you could test for bounding volumes first, then if successful, test each polygon individually. If your models are high poly, you could consider using bounding boxes with an octree representation of the bounding boxes to cut down on the number of individual polygon intersection tests. All of these techniques require some bit of overhead, but they will give you a more accurate feel.

Hope this helps.

Quote:Original post by stroma
taking bullet's collision detection is not easy, i mean bullet is very fast thing and you should code a vector based coll. detection system for them(not position based) (i know lots of games whose walls are passable for player at high FPSs)
can't it be right that:
make a line from camera(or player) to map(which is the line that the bullet will go on)(do not have to scale the line), and when the player fires, just detect collisions on that line. bullet will go to closest collision area. this line will always be in front of the player and defines the bullets' path.

am i wrong? are there any games using this (or similar) technic?

why not have the bullet moving, and between its position and next position check whatever infront of it for a certain distance, so you dont miss any collisions

Hi Guys

Thanks for all the replies :-)

I have gone with a simple technique to start with. When the user presses a key to fire, a new bullet object is created and it is given a start position from the aircraft. Its trajectory is then calculated by using the lengths of the x, y and z axis to determine the size of steps the bullet will need to take to reach its destination (the center of the gun sight). It's destination x and y point is the center of the gun sight and the destination z point is just a #define MAX_DISTANCE that I have set that the bullet will go to, unless it meets anything, before it is destroyed.

So, what happens is that the bullet has its position incremented by the steps calculated earlier, on each frame. Once the bullet has moved, the bounding box of each enemy aircraft is checked to see if the bullet is inside it. If it is, then the collision routine is run, otherwise the bullet is moved and checked each frame until it reaches its maximum distance. Then it is destroyed.

I can see some disadvantages with this, including the fact that if the bullet moves fast (in large steps) then bounding boxes could be missed. At the moment this seems to work fine... but I have not tried it with lots of bullets firing at once yet or done any real testing to it. If I have problems then I will look into this ray casting method that has been mentioned.

Can anyone else see any flaws with the technique I have used, and are there any more suggestions?

Thanks again (I am sure there will be more questions soon!)
Dave

[Edited by - Red_Dash on December 31, 2004 7:03:19 AM]