Having read this thread I don't think that the possibility of a repeater network has been taken seriously. If every light has another light in a N meter radius, (where N is an acceptable distance for a cheap data transmission system) you could just implement a very simple routing algorithm where signal has to hop from one light to the nearest one until destination is reached.

As you probably only need one master, you could take a tree layout network with a practical adress space.

For example master has adress (0,0). the first num is branch index, the second is branch host in branch index.

The data frame could contain :
- original sender
- last repeater
- destination
- data
- crc

With a routing algorithm like :

signed char compare_addr(aX,aY,bX,bY)
{
if(aX < bX)
return -1;
if(ax > bX )
return 1;
if(aY < bY )
return -1;
if(aY > bY)
return 1
return 0;
}

my_addr =( X,Y) // defined for each controller


unsigned char route(packet P)
{
signed char comp_dest = compare_addr(my_addr,packet->dest);
signed char comp_hop = compare_addr (my_addr,packet->last_repeater);
signed char comp = comp_dest+comp_host;
if ( comp == -2 || comp == 2)
{
reemit(P); //change the last_repeater to self
return 0;
}
if ( ! comp_dest )
return 1;
}

typedef struct addr__
{
ADDR_TYPE X;
ADDR TYPE Y;
} addr;
typedef struct packet__
{
addr dest, last_repater, from;
unsigned char length;
unsigned char crc;
} frame;
typedef frame * packet;

////
frame current;
packet P;
main()
{
P = & current;

while(1)
{
wait_packet(P); //Packet is received
if (!check_integrity(P))
continue;
if (route(P))
treat(P);
}
}

This is just a draft : feel free to comment.

Best regards
Benjamin

Ps : adress attribution should ensure that adresses are unique,
and that a lower(mother) tree branch always have a smaller branch ids on it.
This system is far from beeing 'armor piecing bullet proof'...