I'd probably use potential fields. Create a grid over the playing area, put a large value at the point of each projectile based on the amount of damage it does, then draw a line of decreasing values along the projectile's path (with how much each step decreases in 'badness' based on the speed of the projectile - slower projectiles decrease in value faster). If the paths of multiple projectiles cross, add the values together. Then make a new field based on the sum of values close together in the original field (so if the AI is 10 units in radius, each square in the new field is the sum of all squares in a 10 unit radius). Finally, move towards the lowest values you can reach this frame.

If you have many AIs with identical characteristics, you can calculate the field only once and use it for all of them.

Also, you don't have to calculate the entire field, only the field around the AI based on its movement capabilities and size. If the AI is 10 units in radius and can move 20 units, you only need to calculate the field in a 30 unit circle around the agent. To do this, just project projectiles until they collide with the area of interest, then use that distance to decide how much to reduce the field impact of the projectile (just as if you had filled in the grid all the way from the projectile to the area of interest).

This has the benefit of taking global projectile distribution, time, and agent statistics into account. The steering or boids approach will typically only take local projectile distribution into account, and it takes more work to incorporate the fact that you only need to avoid the front of projectiles (using distance to a line or something like that).

Quote:Original post by Emergent
[...]But why a grid? Just choose some reasonable function that you can evaluate analytically and move down its gradient;[...]

Because it's easier to iterate over projectiles and draw lines from them than try to figure out an equivalent formula, and I'm not sure you could create an equivalent formula that didn't involve the same calculations as a grid. The influence of a projectile is conditional upon its eventual collision with a point, so you're still going to have to project them all forward in time to test for collision, then, if it would collide with a given position, calculate some value based on the distance into the future when it would collide combined with its damage.

The grid acts a very simple cache that allows evaluating each projectile only a single time regardless of the number of movement choices (or agents that need to make choices). You could use something more complicated (a fancy partitioning tree or graph) to cache collision information but I don't think it buys enough to be worth the extra work.

For example, if your movement choices are stay, right 1-10 units, or left 1-10 units, you'll need to know collisions for 21 possible locations. If you make a grid and fill it, you'll calculate each projectile's path once over a 21-square grid (since you only need to know the info for the places you can move) or, if you calculate each choice's weight independently, you might end up examining each projectile 21 times.

In my game, the way I did it was to have the ai project forward the trajectories of bullets, and also project forward the trajectories of itself following possible inputs.

It starts by testing the trajectory it would follow if it does nothing. If that results in a collision, it then starts testing more complicated patterns such as accelerate 50, wait 50 or wait 50, accelerate 50.

If there are no paths with fewer then N input changes, then it just gives up and resigns itself to taking damage.


Of course, my game has factors that may make it not applicable to your situation. For example, I have a strong gravity well, meaning that simply projecting straight lines doesn't work. It also makes it impossible to find a closed form solution for the equations of motion. So that pretty much forces a trial and error approach involving projecting the simulation forward in time.

Other factors in my game that make it a more viable approach are the fact that all bullets do the same damage (so that I just do a boolean test instead of trying to minimize total damage), and there are a small number of them at any given time.