/* basic flies source in C by Alex Vulliamy - http://www.alxvy.org */
/*
/*	You are welcome to do whatever you wish with this code, as long
/*	as Jeff Cragg and I (Alex Vulliamy) are given a credit.


#include <stdlib.h>

#define FLYS 90
/* number of flies */
#define VX 2
/* array element that represents x-velocity */
#define VY 3
/* array element .. y-veloctiy */
#define NN 5
/* velocity for bouncing off walls */
#define X 0
/* array element ... x position */
#define Y 1
/* array element ... y position */
#define ZZ 30
/* maximum x or y speed */

int fly [FLYS][4],width,nf,rendomindx;
/* rendomindx is the number of fly whose turn it is to have a neighbour randomised */
int neighbour [FLYS][2];
/* each fly has two nearest neighbours */

int random(int range)
{
 	int rdm;
 	if (range==0) return 0;
 	rdm=rand() % range;
	return (int) rdm;
}

/* randomises flies neighbours */
void rendombit()
{
extern int neighbour[FLYS][2],nf;
auto int indx;
for (indx=0;indx<nf-1;indx++)
	{
	neighbour [indx][0]=random(nf);
	neighbour [indx][1]=random(nf);
	}
}

void setup ()
{
auto int indx;
extern int neighbour [FLYS][2];
extern int fly [FLYS][4],nf;

for (indx=0;indx<(FLYS-1);indx++)
	{
	neighbour [indx][0]=random(nf);
	neighbour [indx][1]=random(nf);
	}

for (indx=0; indx<(FLYS-1); indx++)
	{
	fly [indx][X]=2;
	fly [indx][Y]=2;
	fly [indx][VX]=random(11)-5;
	fly [indx][VY]=random(11)-5;
	}
SetUpWindow();
}

/* main loop */
void refresh (void)
{
auto int tick;
extern int fly [FLYS][4];
extern int nf,rendomindx;
for ( tick=0; tick<nf-1; tick++)
	{
/* erase flies old position */	
	DrawFly (fly [tick][X],fly [tick][Y],0);
	proxes (tick);
	fly[tick][X]=fly[tick][X]+fly[tick][VX]/3;
	fly[tick][Y]=fly[tick][Y]+fly[tick][VY]/3;
	edges (tick);
/* Draw new flies position */
	DrawFly (fly [tick][X],fly [tick][Y],1);
	}
for ( tick=0; tick<nf-1; tick++)
	{
	proxes(tick);
	}
for ( tick=0; tick<nf-1; tick++)
	{
	proxes(tick);
	}

/* jumble a neighbour to bring in new flies as neighbours */
	if (rendomindx>=nf) rendomindx=0;
	neighbour [rendomindx++][0]=random(nf);
/* randomise flies neighbours every so often */
	if (rand()<100)
	rendombit();
}

void edges (int tick)
{
extern int fly [FLYS][4];
if (fly [tick][X]<1)
	fly [tick][VX]=random(NN);
if (fly [tick][X]>295)
	fly [tick][VX]=-random(NN);
if (fly [tick][Y]<1)
	fly [tick][VY]=random(NN);
if (fly [tick][Y]>295)
	fly [tick][VY]=-random(NN);
}

void proxes (int tick)
{
extern int fly [FLYS][4];
extern int neighbour [FLYS][2];
auto int proxi,i,j,n[2],temp1,temp2,tempa,tempb,ni;
n[0]=neighbour[tick][0];
n[1]=neighbour[tick][1];
/* this bit compares the nearest neighbours to the nearest neighbours of the nearest neighbours
	and sees if the latter are closer than the former, if they are then they replace the former */   
for (i=0;i<2;i++)
	{
	ni=n[i];
	proxi=distance(ni,tick);
	for (j=0;j<2;j++)
		{
		
		tempb=neighbour[ni][j];
		if (	proxi<distance(tick,tempb)
				&& tempb!=tick 
				&& tempb!=n[1]
				&& tempb!=n[0]	)
		neighbour[tick][i]=neighbour[ni][j];
		}
	temp1=fly[(ni)][X]-fly[tick][X];
	temp2=fly[(ni)][Y]-fly[tick][Y];
	tempa=1;
/* check to see if closer than eight pixels, if so then repulse instead of attract */	
	if (abs(temp1)<10 && abs(temp2)<10) tempa=-1;
	if (temp1!=0)
		fly[tick][VX]=fly[tick][VX]+tempa*(abs(temp1)/temp1);			
	if (fly[tick][VX]>ZZ) fly[tick][VX]=ZZ;
	if (fly[tick][VX]<-ZZ) fly[tick][VX]=-ZZ;
	if (temp2!=0)
		fly[tick][VY]=fly[tick][VY]+tempa*(abs(temp2)/temp2);
	if (fly[tick][VY]>ZZ) fly[tick][VY]=ZZ;
	if (fly[tick][VY]<-ZZ) fly[tick][VY]=-ZZ;
	}
}

int distance (int zero,int one)
{
auto int x,a,b;
extern int fly [FLYS][4];
a= fly [zero][X]-fly[one][X];
b= fly [zero][Y]-fly[one][Y];
x=(a*a)+(b*b);
return x;
}

main ()
{
int nf;
nf=FLYS;
setup ();
for (;;)
{refresh ();}

}