I wouldn't mind doing any beta testing when you release it.

Well there was a topic on this around here, which said what classes to keep. But even when I didn't touch the classes it still never worked.
But I would love to know which settings, because I really want to shrink my game when its out.

Oh I see bounding box might be what I want.
Er don't need to do anything with the mesh.
Zones will just hold a list of names of people currently in them.

Also I could just use an arraylist and just create zones when needed. How do other people divide there map into zones?

In my unfinished and buggy project FLierMatch, the server manages the position and direccion of a spaceship and for each movement it transfer it to each client and each client upgrades the position and direction of the ship inside the client game.

Thats what I did first. But caused a lot of warp back.
The server currently will still send the position if its totally out of sync. What I have now does what I want, though I will make it a little smarter later.

Try looking on here, has all the free ones: http://www.clickherefree.com/
Including ones without ads. There are some good ones like huge diskspace, no ads and mysql/php which are free.

Hm.. Yea my approach is hard to understand, thats because I don't really know how to do this right  . The server only holds x,y,z and y rotation. It doesn't hold the objects themselves or the matrix. The client sends the x,y to sync.
Let me try draw what I was explaining before:

                 G
                   /
                  / 
                 /   
           CC /     |N
               /      |
              /        |
________/______|
            OP      CS

Horrible pic heh.
At OP both server and client was sync then they go out of sync after that, so the client is at CC and the server is at CS. So I'm trying to get them back into sync or as much as possible. So we guess the next value which is G.
You see CS is going towards G as close as possible to the new position N.
The Y axis gets ignored since the player doesn't change that, only gravity does.
And its really late here, so looks like I'll work with this tomorrow.

I'm a totally stuck on the maths trying to sync the movement on the server with the client. Before this I had it so the client sync with the server but that caused annoying warp backs, so I'm trying to make it so the server syncs to the client.
Hopefully I'm too confusing trying to explain this.

The server holds the current client position(CC), current server position (CS), old client position(OC).
The server on every cycle sync as much as it can to the client.

This is done by creating a guess position(G) which the CS goes towards that direction to N (The new position).
G is worked out by the angle of OC and CC, then translate CC with this new angle.
N is worked out by the angle of CS and G, then translate CS with this new angle.

This is my current code but doesn't work as expected, just moves in one direction. Hopefully someone understands this and able to tell me whats wrong.

float differenceAngle = oldrotation - rotation; //has the player turned since last cycle.

final Object3D guessPos = new Object3D(0), charObj = new Object3D(0), newPos = new Object3D(0);

guessPos.translate(clientX, y, clientZ);
guessPos.rotateY(calcAngle(new SimpleVector(oldClientX,y,oldClientZ),new SimpleVector(clientX,y,clientZ)) + differenceAngle);

charObj.translate(x, y, z);
charObj.rotateY(rotation);

final SimpleVector charPos = charObj.getTranslation();

SimpleVector a = guessPos.getZAxis();
a.scalarMul(xSpeed);

newPos.translate(x, y, z);
newPos.rotateY(calcAngle(new SimpleVector(charPos.x,charPos.y,charPos.z),new SimpleVector(a.x,a.y,a.z)));

clientX = a.x;
clientZ = a.y;
clientRotation = a.z;

a = newPos.getZAxis();
a.scalarMul(xSpeed);

               a = m.getWorld().checkCollisionEllipsoid(charPos, a, Zone.ELLIPSOID_RADIUS, 2);

charObj.translate(a);
a = charObj.getTranslation();

x = a.x;
y = a.y;
z = a.z;

oldClientX = clientX;
oldClientZ = clientZ;
oldClientRotation = clientRotation;
oldrotation = rotation;