ecmascript:

function alwaysPrint (text)
{
	Browser.println ('[BuoyCommunicationsGrid]' + text);
}
function tracePrint (text)
{
	if (traceEnabled) Browser.println ('[BuoyCommunicationsGrid]' + text);
}
function set_senderPosition (value, timestamp)
{
	senderPosition = value;
}
function set_receiverPosition (value, timestamp)
{
	receiverPosition = value;
}
function set_textMessage (value, timestamp)
{
	textMessage = value;
}
function distance (p1, p2) // inputs:  SFVec3f, output: float
{
	// square root of sum of sum of squares
	dx = (p1.x - p2.x);
	dy = (p1.y - p2.y);
	dz = (p1.z - p2.z);
	d = Math.sqrt (dx*dx + dy*dy + dz*dz);
//	tracePrint ('distance (' + p1 + ',' + p2 + ') =' + d);
	return d;
}
function timeSoundTravels (distance) // input: float meters, output: float seconds
{
	// speed of sound in water = 1500 m/s
	timeInterval = distance / 1500;
	tracePrint ('sound travels' + Math.round(distance) + ' meters in' +
	'timeInterval=' + Math.round(timeInterval*1000)/1000 + ' seconds');
	return timeInterval;
}
function routingTableIndex (senderNodeIndex, destinationNodeIndex)
{
	if ((     senderNodeIndex < 0) || (     senderNodeIndex >= buoyArray.length) ||
	    (destinationNodeIndex < 0) || (destinationNodeIndex >= buoyArray.length))
	   alwaysPrint ('routingTableIndex () error, input index out of bounds:  senderNodeIndex=' + senderNodeIndex +
	', destinationNodeIndex=' + destinationNodeIndex);
	newIndex = buoyArray.length*senderNodeIndex  + destinationNodeIndex;
	return newIndex;
}
function findClosestBuoyIndex (position)
{
	closestBuoyIndex = 0;  // initialize
	closestDistance  = distance (position, buoyArray[0].position);
//	tracePrint ('distance(position, buoyArray[0].position)=' + Math.round(closestDistance));
	if (buoyArray.length == 1) return closestBuoyIndex;

	for (i=1; i < buoyArray.length; i++) // start comparison loop at second buoy
	{
		d = distance (position, buoyArray[i].position);
	//	tracePrint ('distance(position, buoyArray[' + i + '].position)=' + d);
		if (d < closestDistance)
		{
			closestBuoyIndex = i;
			closestDistance  = d;
		//	tracePrint ('  closestBuoyIndex=' + closestBuoyIndex);
		}
	}
	tracePrint ('closest distance(position, buoyArray[' + closestBuoyIndex + '].position)=' + Math.round(closestDistance));
	return closestBuoyIndex;
}
function initialize ()
{
	n = buoyArray.length;
	tracePrint ('initialize() buoyArray.length=' + buoyArray.length);
	tracePrint ('initialize() buoyCommunicationsRoutingTable=' + buoyCommunicationsRoutingTable);
	tracePrint ('initialize() buoyCommunicationsRoutingTable.length=' + buoyCommunicationsRoutingTable.length);

	// check that routing table is a properly sized square array
	if (buoyCommunicationsRoutingTable.length != n*n)
	{
		alwaysPrint ('initialize() invalid buoyCommunicationsRoutingTable.length=' + buoyCommunicationsRoutingTable.length +
			   ', should = (' + n + '*' + n + ') =' + (n*n));
	}
	tracePrint ('initialize() square table check complete');
	// check for routing table loop from node to itself
	for (i=0; i < n; i++)
	{
	//	tracePrint ('initialize() buoyCommunicationsRoutingTable[routingTableIndex(' + i + ',' + i + ')]=' + buoyCommunicationsRoutingTable[routingTableIndex(i,i)] );
		if (buoyCommunicationsRoutingTable[routingTableIndex(i,i)] != -1)
		alwaysPrint ('initialize() invalid buoyCommunicationsRoutingTable[' + i + ']=' +
			             buoyCommunicationsRoutingTable[i] +
		' rather than -1, since node (' + i +
		') cannot route to itself');
	}
	tracePrint ('initialize() self route check complete');
	// check routing table values are legal
	for (i=0; i < n; i++)
	{
		for (j=0; j < n; j++)
		{
			k = buoyCommunicationsRoutingTable[routingTableIndex (i, j)];
		//	tracePrint ('initialize() routingTableIndex (' + i + ',' + j + ') =' + k);
			if ((buoyCommunicationsRoutingTable[k] < -1) ||
			    (buoyCommunicationsRoutingTable[k] >= buoyCommunicationsRoutingTable.length))
				alwaysPrint ('initialize() *** invalid buoyCommunicationsRoutingTable[' + i + ',' + j + ']=' +
				     buoyCommunicationsRoutingTable[k]);
		}
	}
	// TODO:  check for other routing table loops?

	tracePrint ('initialize() complete');
}
function sendMessage (value, timestamp)
{
	if (value != true)
	{
		if (value != false) tracePrint ('sendMessage() exiting, passed value=' + value);
		return;
	}
	// run-time setup happens here!   execution of all buoys occurs upon returning.
	// prepare the scene graph for a message sequence, then start it.

	// first find shortest distances and thus closest buoys to sender and receiver
	senderNodeIndex      = findClosestBuoyIndex(senderPosition);
	destinationNodeIndex = findClosestBuoyIndex(receiverPosition);
	tracePrint ('     senderNodeIndex=' +      senderNodeIndex + ' (' + senderPosition   + ')');
	tracePrint ('destinationNodeIndex=' + destinationNodeIndex + ' (' + receiverPosition + ')');

	// TODO:  sound beam from sender to senderNode or receiver (whichever is closest)

	if (senderNodeIndex == destinationNodeIndex)
	{
		tracePrint ('senderNode and destinationNode are the same, no message sent');
		tracePrint ('=============================================');
		return;
	}
	transmissionDuration  = 1;
	tracePrint ('transmissionDuration=' + transmissionDuration);

	// compute path (sequence of buoy IDs) from closest buoy to SeaWeb buoy
	// compute full buoy-to-buoy routing paths for current sender-receiver combination

	hopCount = 0;
	maxHopCount = buoyArray.length - 1;
	nextNodeIndex = -2;
	nodePath = new MFInt32();
	nodePath[nodePath.length] = senderNodeIndex;
	nodePathString ='sender, buoys' + senderNodeIndex;
	currentNodeIndex = senderNodeIndex;

	d  = distance (senderPosition, buoyArray[senderNodeIndex].position);
	dt = timeSoundTravels (d);
	accumulatedRange = d;
	accumulatedDelay = 2 * (dt + transmissionDuration);
	tracePrint ('distance=' + Math.round(d) + ', accumulatedRange=' + Math.round(accumulatedRange)
		+ ', accumulatedDelay=' + Math.round(accumulatedDelay*1000)/1000);

	while ((nextNodeIndex != -1) && (hopCount <= maxHopCount))
	{
		tracePrint ('=====');
		tableIndex = routingTableIndex (currentNodeIndex, destinationNodeIndex);
		nextNodeIndex = buoyCommunicationsRoutingTable[tableIndex];
		tracePrint ('currentNodeIndex=' + currentNodeIndex + ', nextNodeIndex=' + nextNodeIndex + ', tableIndex=' + tableIndex);

		// check if dead end - incomplete communication path
		if (nextNodeIndex < 0)
		{
			alwaysPrint ('*** hit a dead end! no further routing possible.');
			return nextNodeIndex;
			// consider not animating any buoys, i.e. whether or not partial routing allowed
		}
		hopCount++;
	//	tracePrint ('hopCount=' + hopCount + ', maxHopCount=' + maxHopCount);

		// communicate from currentNodeIndex buoy to nextNodeIndex buoy
		// by sending initialization values to each buoy in path:
		// message, target buoy ID/position, and then compute distance/time to travel
		// to set time delay of each buoy prior to start of each transmission.

		buoyArray[currentNodeIndex].textMessage = textMessage;
		buoyArray[currentNodeIndex].targetIdNumber = nextNodeIndex;
		buoyArray[currentNodeIndex].targetPosition = buoyArray[nextNodeIndex].position;
		d  = distance (	buoyArray[currentNodeIndex].position, buoyArray[nextNodeIndex].position);
		dt = timeSoundTravels (d);
		accumulatedRange += d;
		accumulatedDelay += 2 * (dt + transmissionDuration);
		buoyArray[currentNodeIndex].range  = d;
		buoyArray[currentNodeIndex].transmissionDuration  = transmissionDuration;
		buoyArray[currentNodeIndex].transmissionTimeDelay = accumulatedDelay;
		buoyArray[currentNodeIndex].set_activated = true;

		// set up for next time through loop:
		currentNodeIndex = nextNodeIndex;
		nodePath[nodePath.length] = nextNodeIndex;
		nodePathString +=',' + nextNodeIndex;
		tracePrint ('distance=' + Math.round(d) + ', accumulatedRange=' + Math.round(accumulatedRange)
			+ ', accumulatedDelay=' + Math.round(accumulatedDelay*1000)/1000);

		if (nextNodeIndex == destinationNodeIndex) break;
	}
	tracePrint ('====='); // last node to destination follows
	tracePrint ('destinationNodeIndex=' + destinationNodeIndex + ' to receiver');
	buoyArray[currentNodeIndex].textMessage = textMessage;
	buoyArray[currentNodeIndex].targetIdNumber = -2;
	buoyArray[currentNodeIndex].targetPosition = receiverPosition;
	d  = distance (	buoyArray[destinationNodeIndex].position, receiverPosition);
	dt = timeSoundTravels (d);
	accumulatedRange += d;
	accumulatedDelay += 2 * (dt + transmissionDuration);
	buoyArray[currentNodeIndex].range  = d;
	buoyArray[currentNodeIndex].transmissionDuration  = transmissionDuration;
	buoyArray[destinationNodeIndex].transmissionTimeDelay = accumulatedDelay ;
	buoyArray[destinationNodeIndex].set_activated = true;

	tracePrint ('distance=' + Math.round(d) + ', accumulatedRange=' + Math.round(accumulatedRange)
		+ ', accumulatedDelay=' + Math.round(accumulatedDelay*1000)/1000);

	tracePrint ('=====');
	tracePrint ('path destination found, buoy hopCount=' + hopCount + ', nodePath=' + nodePathString + ', receiver');
	for (i=0; i < nodePath.length; i++)
	{
		j = nodePath[i];
		tracePrint ('node=' + nodePath[i]
			+ ', buoyArray[' + nodePath[i] + '].transmissionTimeDelay=' + Math.round(buoyArray[nodePath[i]].transmissionTimeDelay*1000)/1000);
	}
	tracePrint ('=============================================');

	// TODO: do we need to trigger the RACOM radio at this point?
}