private bool HandleHttp(Socket socket)
        {
            var buf = new byte[8192];
            var bufLen = 0;
            var recvBuf = new byte[8192];
            var bodyStart = -1;

            while(bodyStart == -1)
            {
                var recvLen = socket.Receive(recvBuf);
                if(recvLen == 0)
                {
                    return true;
                }

                Buffer.BlockCopy(recvBuf, 0, buf, bufLen, recvLen);
                bufLen += recvLen;

                bodyStart = FindBodyStart(buf, bufLen);
            }

            var headers = Encoding.UTF8.GetString(buf, 0, bodyStart - 2).Replace("\r", "").Split('\n');

            var main = headers[0].Split(' ');
            var reqMethod = ParseRequestMethod(main[0]);
            if (reqMethod == RequestMethod.Invalid)
            {
                SendResponse(400, socket);
                return true;
            }

            // receive POST body
            var body = string.Empty;
            if(reqMethod == RequestMethod.Post)
            {
                body = ReceiveBody(buf, bufLen, headers, bodyStart, socket);
                if(body == null)
                {
                    return true;
                }
            }

            var path = main[1];
            if(path == "/")
            {
                path = "/index.html";
            }

            // try to serve by a file
            if(File.Exists(_docRoot + path))
            {
                var content = File.ReadAllBytes(_docRoot + path);
                if (reqMethod == RequestMethod.Head)
                {
                    content = null;
                }

                SendResponse(200, socket, content, GuessMime(path));

                return true;
            }

            // try to serve by a handle
            foreach(var handler in _handlers)
            {
                if(handler.Match(reqMethod, path))
                {
                    if (handler.Async)
                    {
                        _jobs.Enqueue(() =>
                        {
                            RunHandler(socket, path, body, handler);
                            socket.Shutdown(SocketShutdown.Both);
                            socket.Close();
                        });
                        return false;
                    }
                    else
                    {
                        RunHandler(socket, path, body, handler);
                        return true;
                    }
                }
            }

            // nothing found :-(
            var msg = "File not found " + path
                      + "\ndoc root " + _docRoot
                      + "\ncurrent dir " + Directory.GetCurrentDirectory();
            SendResponse(404, socket, Encoding.UTF8.GetBytes(msg));
            return true;
        }

public string ListMatches(string method, string path)
        {
            var sb = new StringBuilder();
            sb.Append("[\n");

            foreach (var match in _matches.Values)
            {
                sb.Append("{id:\"" + match.GameId + "\""
                          + ", www:" + match.Tool.Port
                          + "},\n"
                );
            }

            sb.Append("]");
            return sb.ToString();
        }

{
    enums: {
        "HostilityLayer": {
            1: "PlayerTeam1",
            2: "PlayerTeam2",
            3: "NeutralShootable",
        }
    },
    components: {
        Transform: {
            name: 'Transform',
            fields: {
                Angle: {type: "float"},
                Position: {type: "Vector2"},
            },
        },
        TransformExact: {
            name: 'TransformExact',
            fields: {
                Angle: {type: "float"},
                Position: {type: "Vector2"},
            }
		}
    },
    tables: {
        Transform: {
            name: 'Transform',
            component: 'Transform',
        },
        TransformExact: {
            name: 'TransformExact',
            component: 'TransformExact',
            hint: "Copy of Transform for these entities that need full precision when sent over network",
        }
    }
}

var rulebook = {};
var worldstate = {};
var physics = {};

var update_dynamic_physics;

var camera, scene, renderer;
var controls;
function init3D () {
	camera = new THREE.PerspectiveCamera(60, window.innerWidth / window.innerHeight, 1, 1000);
	camera.up.set(0,0,1);

	scene = new THREE.Scene();

	scene.add( new THREE.AmbientLight( 0x404040 ) );

	var light = new THREE.DirectionalLight( 0xFFFFFF, 1 );
	light.position.set(-11, -23, 45);
	scene.add( light );

	renderer = new THREE.WebGLRenderer();
	renderer.setPixelRatio( window.devicePixelRatio );
	renderer.setSize( window.innerWidth, window.innerHeight );
	document.body.appendChild( renderer.domElement );

	controls = new THREE.OrbitControls( camera, renderer.domElement );

	var cam = localStorage.getObject('gv_camera');
	if (cam) {
		camera.matrix.fromArray(cam.matrix);
		camera.matrix.decompose(camera.position, camera.quaternion, camera.scale);

		controls.target.set(cam.target.x, cam.target.y, cam.target.z);
	} else {
		camera.position.x = 40;
		camera.position.y = 40;
		camera.position.z = 50;
		controls.target.set(0, 0, 0);
	}

	window.addEventListener( 'resize', onWindowResize, false );
}

init3D();

function handle_recv_dynamic (r)
{
	eval('physics = ' + r + ';');

	update_dynamic_physics();

	sleep(10)
		.then(() => ajax("GET", "/physics/dynamic/"))
		.then(handle_recv_dynamic);
}

(function init_dynamic_physics () {
	var colour = 0x4B5440;
	var material = new THREE.MeshLambertMaterial({color: colour, flatShading: true});

	var meshes = {};

	update_dynamic_physics = function () {
		var i, p, mesh;
		var to_del = {};
		for (i in meshes) to_del[i] = true;

		for (i in physics) {
			p = physics[i];
			mesh = meshes[p.id];
			if (!mesh) {
				mesh = create_shapes(worldstate, 'Dynamic', p, material, layers.dynamic_collider);
				meshes[p.id] = mesh;
			}
			mesh.position.x = p.pos[0];
			mesh.position.y = p.pos[1];
			delete to_del[p.id];
		}

		for (i in to_del) {
			mesh = meshes[i];
			scene.remove(mesh);
			delete meshes[i];
		}
	}
})();