Well, for a sphere, you can simply check how close the centres of the two spheres are. If this is less than the sum of their radii, then they are overlapping.
Code:
typedef struct point {
int x, y, z;
}point;
typedef struct sphere {
point c;
int radius;
}sphere;
int spheres_overlapping(sphere* a, sphere* b)
{
int pyth = 0, radsum = 0;
pyth = (a->c.x - b->c.x) * (a->c.x - b->c.x) + (a->c.y - b->c.y) * (a->c.y + b->c.y) + (a->c.z - b->c.z) * (a->c.z - b->c.z);
radsum = a->radius * a->radius + b->radius * b->radius;
return (pyth < radsum);
}
This function returns non-zero if the two spheres are overlapping. It simply uses 3D pythagoras to determine the distance of the two spheres (actually the square of the distance, since square root is expensive), and compares it with the sum of the radii (again, the square of the sum of the radii, since an integer multiplication is much quicker than a square root).
Presumably you will need to use floating point code, but you can just substitute `int' with `float'.
For cylinder detection, assuming the cylinders are all facing vertically up (which is probably what you want for bounding box collisions -- anyway, it is too difficult otherwise!):
typedef struct cylinder {
point c;
int radius;
int bottom, top;
}cylinder;
int cylinders_overlapping(cylinder* a, cylinder* b)
{
int pyth = 0, radsum = 0;
if(a->bottom > b->top

Or is it a bug in the UBB? You will have to replace `OR' with the symbol for logical OR, below.
typedef struct cylinder {
point c;
int radius;
int bottom, top;
}cylinder;
int cylinders_overlapping(cylinder* a, cylinder* b)
{
int pyth = 0, radsum = 0;
if(a->bottom > b->top OR b->bottom > a->top) return 0;
pyth = (a->c.x - b->c.x) * (a->c.x - b->c.x) + (a->c.y - b->c.y) * (a->c.y + b->c.y);
radsum = a->radius * a->radius + b->radius * b->radius;
return (pyth < radsum);
}
This time, we check that the two cylinders overlap in height (which I assume to be `z'); if they don't, then we return 0, and if they do, this simply becomes the problem of two circles overlapping. I use a 2d version of the problem above.
The code for two boxes overlapping is a little more complicated, but only because you have to explicitly check several conditions. All you have to do is check if any vertex of box A lies inside box B. If this is true, then you can assume the boxes overlap:
typedef struct box {
point corner;
int w, d, h; /* x, y, z dimensions */
}box;
int point_is_in_box(box* b, point p)
{
if(p->x < b->x OR p->x >= (b->x + b->w) OR p->y < b->y OR p->y >= (b->y + b->d) OR p->z < b->z OR p->z >= (b->z + b->h)) return 0;
return 1;
}
int boxes_overlap(box* a, box* b)
{
int i = 0;
point vtx[8];
for(i = 0; i < 8; i++) {
vtx[i] = b->corner;
if(i & 1) vtx[i].x += b->w;
if(i > 3) vtx[i].y += b->h;
if(i > 1 && i < 6) vtx[i].z += b->d;
}
return (point_is_in_box(a, vtx[0]) OR point_is_in_box(a, vtx[1]) OR point_is_in_box(a, vtx[2]) OR point_is_in_box(a, vtx[3]) OR point_is_in_box(a, vtx[4]) OR point_is_in_box(a, vtx[5]) OR point_is_in_box(a, vtx[6]) OR point_is_in_box(a, vtx[7]));
}
Actually, this doesn't check the case where box a lies entirely inside box b, but I'm sure you can add a simple check for that (you don't need to run the box check both ways; just write a quick check).
Anyway, I hope this helps you. I haven't tested it, so there may be bugs.

Damnit! I Pseudo-code is thashiat! I would much rather see an algorithm in pseudo-code, it's much easier to implement than trying to descipher normal code (unless it is commented on every line or so)

But that's just my opinion, and I'm sure my random babbling didn't help.