I'm very pleased to showcase the new functionality I've incorporated allowing the user to select many Simulin at once.
This feature was always on the back-burner because there were more pressing things to address.  I'll quickly go through the technique I used.

But first, please watch the following videos!  

I created a two faced plane where the opposite corners are defined by the vertices obtained from the right-click down and up events.  Then raycaste to the planet twice and I have all four corners for the plane.  After that I normalized the vertices and then raycaste from the position of every visible Simulin to the center of the planet.

It's not 100% perfect, because the perspective camera obscures things a bit and the box that is drawn is an html element.  For this reason Simulin along the edges of the selection box will sometimes not be selected.  But really?  big deal...

Once the target Simulin are identified the user selects the destination.  This is where the scripted behaviour of the Simulins movement comes in.  Rather than having all the Simulin converge on a single point I created a move-able plane whose vertices are defined in a spiral 

initilizingFunction.definePositionPlane = function( unitScale ){ 

	var geometry = new THREE.Geometry();
	var material = new THREE.MeshLambertMaterial( { side: THREE.DoubleSide } );

  	// 'qv(0,0,0)' is short form of 'new THREE.Vector3( 0,0,0 )'
	geometry.vertices.push( qv( 0 , 0 , 0 ) );
  
  	/* the following function creates an 11 x 11 grid of vertices.
  	* the first vertices is located at the center of the grid.
  	* if we were to number the vertices 1 through 121 left from right, up to down
  	* then the first vertices defined would be at the position of the 61st spot in the grid.
  	* as the function cycle through 'i', two 'n' loops of 'l' length add move the location 
  	* of the next declared vertices 'l' left/right depending and 'l' up/down depending.
  	* at the end of both 'n' loops l is incremented and the directions toggle.
  	*/
  
	for( var i=0, j=61, k=61, l=1, q=-1, p=1, b=15; i<121; i+=0 ){
		if( l < 11){

			for( var n=0; n<l; n++ ){
				j += q;
				geometry.vertices.push( qv( ( j - 61 ) * u * b , 0 , ( k - 61 ) * u * b ) );
				i++;
			}
			for( var n=0; n<l; n++ ){
				k += p;
				geometry.vertices.push( qv( ( j - 61 ) * u * b , 0 , ( k - 61 ) * u * b ) );
				i++;
			}
			q*=-1;
			p*=-1;
		
			l++;
		} else {
			for( var n=0; n<10; n++ ){
				j += q;
				geometry.vertices.push( qv( ( j - 61 ) * u * b , 0 , ( k - 61 ) * u * b ) );
				i++;
			}
			i = 121;
		}
	}

	var face = new THREE.Face3( 0 , 10 , 120 );
	geometry.faces.push( f );

	face = new THREE.Face3( 0 , 120 , 110 );
	geometry.faces.push( f );

	geometry.computeFaceNormals();

	var mesh = new THREE.Mesh( geometry , material );
	mesh.visible = true;

	return mesh;

};

The plane is moved and then oriented over the point the user chose.  Each Simulin requesting a path is given an incremental vertices obtained from the selection plane. A raycaste call is done from that vertices location once the vertices is extrapolated to its global position.  From there I get the sphere position and that become the unique goal for the Simulin in question. 

I think the effect looks awesome.  

Right now you draw the selection box by holding down the right mouse button and then when you release it the calculations are done.

I'm also thinking that in the future I can program a custom routine and color for the direction in which you draw the selection box.   If you go left to right, up to down then maybe you select every Simulin.  right to left, up to down then maybe you select only hunters or some such idea.

Let me know what you think....