Hey! I'm in the process of creating a game engine (who isn't, amirite) for top-down sprite 2d games with alot of units. (such as moba's and RTS games, diablo and scbw was made this way more or less).

So one of the last things i need in my physics subsystem/subengine is pathfinding, where i plan to use the A* algorithm which requires a grid(?).
I plan on using a tilemap for static obstacles (some kind of map loaded from a picture, showing which parts of the map are walkable, possibly using a quadtree)
And my already existing collision detection grid for semi dynamic obstacles (such as buildings, trees, craters, etc)

As mentioned, I use a variable size grid for collision detection. I initialize the grid field size to a size that is atleast the size of the largest units collision box.

Q: Which leads me to my first question, wouldn't this kind of grid be too big to also use for pathfinding? (maps will be much larger than a screen)
Q: Also with the size of the grid fields being variable from game to game, wouldn't that result in different and sometimes bad behavior?

1. Option would be to split the grid i already have into smaller fields.

Q: But with dynamic size grids, how would i go about partitioning it?

Alternatively, if the existing grid isn't usable i see two other options:

2. Create a new grid for pathfinding with fields always of the same size. (a pretty decent chunk of memory would be required)
3. Try an approach where i dynamically build fields/nodes based on coordinates. The objects could be pulled from a pool to improve performance.

Q: Is option 2 actually feasable? or am i missing something essential from A* that makes it unreasonable.
Q: Would option 1 actually be worthwhile despite the memory cost, due to being easier/simpler/faster?

Any advice, tips or experiences are welcomed Posted Image

A* doesn't require a grid, per se. It requires a connected graph of nodes. Those nodes can be a grid or they can be anything arbitrary. As long as you know the edge length between them (or they are all the same), then A* works.

As for the map being too big, you can easily path through 1000x1000 grids with not too much trouble. However, that said, hierarchical approaches tend to work good for trimming the search space. You get to keep your granularity but speed up long-distance searches.

This link helped me out when I was doing mine. There's information there on pathfinding in non-square search areas and also using waypoints instead of a grid

http://www.policyalmanac.org/games/aStarTutorial.htm

Here's my implementation

http://www.gamedev.net/blog/1110/entry-2250116-pathfinding/