I'm still working on that aspect. However, for player-world collision I'd recommend reading "Improved collision detection and response" by Kasper Fauerby. It provides a very interesting system using ellipsoids.

I have implemented a few different systems (capsule, cylinder, swept-AABB and swept-sphere). Some advice:

* Use some form of swept method, either sweeping a primitive (sphere, ellipsoid, box etc) against your geometry or expanding your geometry quake-style and doing line segment queries. Trying to use a discrete method introduces a lot of problems and will almost certainly have robustness issues

* Use simplified collision geometry, done either manually or via preprocess. This is not only for the collision detection or performance, but also for the collision response - it is very easy for arbitrary geometry to stick sliding code unnecessarily (assuming you want to slide on contact)

* Be wary of float precision, this applies not only to the detection but also the response, where it is important to try to keep yourself some minimum distance away (depending on your world units) from the geometry rather than right up next to it

That said, swept-spheres are quite widely used and probably a good method to start with, the ellipsoid version mentioned above is an extension of this.

Quote:I can't say I am really too familiar with sweeping algorithms. Would anyone happen to have any favorite links handy?

Too lazy to track down the links at the moment, but the aforementioned paper by Kasper Fauerby is good. Also, check out the collision detection articles here on gamedev - there's one that covers swept circles/spheres and swept AABBs.

Most swept tests are based on one or a combination of the following three techniques:

* The dynamic version of the Separating Axis Theorem (google this, dynamic version is sometimes abbreviated to DSAT). The basic version of SAT applies to static objects but it can be extended for objects undergoing translational motion

* "Reversing" the test to ask the same question the other way round - for example, testing a swept sphere against a box is equivalent to testing a line segment against the box "expanded" by the sphere. Often the equivalent is easier to work out

* Decomposing the original test into a number of simpler tests. This is often used with the technique above. For example, testing a swept sphere vs triangle can be reversed to testing a line segment vs the triangle expanded by the sphere. This can be decomposed into testing the line segment vs 3 "fat" edges and vs 3 spheres and picking the closest intersection (some of the tests can be optimised away in certain situations but you get the idea)

Some links in addition to the Fauerby one: (err don't know how to do links here :P)

http://www.gamasutra.com/features/20000330/bobic_01.htm
A bit of intro to some collision detection issues

http://sourceforge.net/mailarchive/forum.php?forum=gdalgorithms-list
The archives of the Game Development Algorithms mailing list, collision has been discussed a lot

http://www.realtimerendering.com/int
A big list of static and dynamic intersection tests

http://www.gamasutra.com/features/19991018/Gomez_1.htm
A number of static and dynamic intersection tests

http://www.gamasutra.com/features/20010324/melax_01.htm
This describes the cylinder-based method used for avatar collision in MDK2

Also looking through the player collision routines in the quake 2 source might be helpful.

Hope some of that helps!

Oops sorry that was me, forgot to log in :)