I am looking to implement a 2D top-down collision system, and was hoping for some input as to the likely performance between a few different ideas. For reference I expect the number of moving collision objects to be in the dozens, and the static collision objects to be in the hundreds.
The first idea is border-line brute force (or maybe not so border-line). I would store two lists of collision objects in a collision system. One list would be dynamic objects, the other would include both dynamic and static objects (each dynamic would be in both lists). Each frame I would loop through the dynamic list and pass each object the larger list, so it could find anything it may run into. This will involve a lot of unnecessary calculations for any reasonably sized loaded area but I am using it as a sort of baseline because it would be very easy to implement.
The second idea is to have a single list of all collision objects, and a 2D array of either ints or floats representing the loaded area. Each element in the array would represent a physical location, and each object would have a size value. Each time an object moved, it would subtract its size value from its old location and add it to its new location. The objects would have to access elements in the array before they moved to make sure there was room in their new location, but that would be fairly simple to do. Besides the fact that I have a very public, very large array, I think it would perform fairly well. I could also implement with a boolean array, simply storing if a location is full or not, but I don’t see any advantage to this over the numeric storage.
The third I idea I had was less well formed. A month or two ago I read about a two dimensional, rectangle based data structure (may have been a tree, i don’t remember) that would be able to keep elements sorted by position. Then I would only have to pass the dynamic objects their small neighborhood of objects for update. I was wondering if anyone had any idea what this data structure might be, so I could look more into it, and if so, how the per-frame sorting of it would affect performance relative to the other methods.
Really I am just looking for ideas on how these would perform, and any pitfalls I am likely overlooking in any of these. I am not so much worried about the actual detection, as the most efficient way to make the objects talk to one another.
You’re not talking about a lot of objects in this case. Honestly, you could probably brute force it and probably be fine for your application, even in mobile game development. With that in mind, I’d recommend you keep it simple but throw a bit of optimization on top for gravy. Spatial hashing with a reasonable cell size is the way I’d go here — relatively reasonable memory use, decent speedup, and not that bad as far as complexity of implementation goes. More on that in a moment!
You haven’t said what the representation of your objects is, but in any case you’re likely going to end up with a typical “broad phase” and “narrow phase” (like a physics engine) — the “broad phase” consisting of a false-positives “what could be intersecting?” query and the “narrow phase” brute forcing out the resulting potential intersections. Unless you’re using things like binary space partitioning trees for polygonal shapes, you’re not going to end up with a one-phase solution.
As mentioned above, for the broad phase I’d use spatial hashing. Basically, you establish a grid and mark down what’s in touch with each grid. (It doesn’t have to be perfect — it could be what axis-aligned bounding boxes are in each grid, even.) Then, later you go through the relevant cells of the grid and check if everything in each relevant cell is actually intersecting with anything else in the cell.
Trick is, instead of having an array, either have a hash table for every cell grid. That way you’re only taking up space for grids that actually have something in them. (This is not a substitution for badly sized grids — you want your grid to be coarse enough to not have an object in a ridiculous amount of cells because that takes memory, but you want it to be fine enough to not have all objects in a few cells because that doesn’t save much time.) Chances are by visual inspection, you’ll be able to figure out what a good grid size is.
One additional step to spatial hashing… if you want to save memory, throw away the indices that you’d normally verify in a hash table. False positives only cost CPU time, and if you’re hashing correctly, it’s not going to turn out to be much, but it can save you a lot of memory.
So:
When you update objects, update which grids they’re probably in. (Again, it’s good enough to just use a bounding box — e.g. a square or rectangle around the object.) Add the object to the hash table for each cell it’s in. (E.g. If you’re in cell 5,4, that hashes to the 17th entry of the hash table. Add it to that entry of the hash table and throw away the 5,4 data.) Then, to test collisions, go through the relevant cells in the hash table (e.g. the entire screen’s worth of cells if that’s what you’re interested in) and see what objects inside of each cell collide with other objects inside of each cell.
Compared to the solutions above:
Implementation note:
Each node in the spatial hash table will ultimately be a linked list. I recommend writing your own linked list with careful allocations. Each node need take up more than 8 bytes (if you’re using C/C++) and should a pooled allocation scheme so you’re almost never allocating or freeing memory. Relying on the built-in allocator will likely cripple performance.