//===========================================================================
//                                FLOCKING BEHAVIORS SONIFIED - November 2006
// Beep() will stop programming action until it completes its sound
//      and it plays through the system speaker, not the amplifier
// PlaySound() will stop playing when another PlaySound is activated
//      consequently, long .wav files may have a chance to play out
// Midi will play notes when they are called
//      be careful of some instruments whose notes will sustain forever
//===========================================================================

//---------------------------------------------------------------------------

#include <vcl.h>
#include <math.h>
#pragma hdrstop

#include "Unit1.h"
// The following two lines are needed to enable the randomizer
#include "stdlib.h"
#include "time.h"
#include <mmsystem.h>

//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
   : TForm(Owner)
{
   // Double buffering eliminates some screen flicker...
   DoubleBuffered = true;
}
//---------------------------------------------------------------------------

//===========================================================================
//                                                           GLOBAL VARIABLES
//===========================================================================

// ------------------------------------------------- your program begins here

int midiport = 0;
HMIDIOUT device;

union {
	public:
	unsigned long word;
	unsigned char data[4];
} message;

int soundType = 0;
int instrument;
int note;

TShape *shape[24] = {0};                        // sets up an array of shapes

class anAgent {
   public:
      float velocity;
      double direction;
      double newDirection;
      double newDistance;
      double lastDistance;
      float x;
      float y;
} agent[24];

int increment = 5;

bool stop = true;
bool wasStopped = false;
int iterations;
int i;
int chosenAgent;
int shapeDownX, shapeDownY;
bool agentWasJustChosen = false;

//===========================================================================
//                                                                  FUNCTIONS
//===========================================================================

//---------------------------------------------------------------- color ramp
int colorRamp(int range, int value)
    {
    int pixelDistanceAlongPath = (value * 1792) / range;
    int red, green, blue;
    // Which edge of the color cube are we on?
    if (pixelDistanceAlongPath < 256) {
        // Edge 1 from BLACK to BLUE
        red=0; green=0; blue=pixelDistanceAlongPath;
    }
    else if (pixelDistanceAlongPath < 512) {
        // Edge 2 from BLUE to CYAN
        red =0; green=pixelDistanceAlongPath-256; blue=255;
    }
    else if (pixelDistanceAlongPath < 768) {
        // Edge 3 from CYAN to GREEN
        red =0; green =255; blue= 255-(pixelDistanceAlongPath-512);
    }
    else if (pixelDistanceAlongPath < 1024) {
        // Edge 4 from GREEN to YELLOW
        red= (pixelDistanceAlongPath-768); green =255; blue =0;
    }
    else if (pixelDistanceAlongPath <1280) {
        // Edge 5 from YELLOW to RED
        red =255; green=255-(pixelDistanceAlongPath-1024); blue =0;
    }
    else if (pixelDistanceAlongPath < 1536) {
        // Edge 6 from RED to MAGENTA
        red =255; green=0; blue=pixelDistanceAlongPath -1280;
    }
    else {
        // Edge 7 from MAGENTA to WHITE
        red =255; green=pixelDistanceAlongPath-1536; blue =255;
    }
    return (RGB(red, green, blue));
}

//------------------------------------------------------------------- shuffle
void shuffle (void) {
   for (int i = 0; i < 24; i++) {
	  agent[i].x = random(400) + 30;
	  shape[i]->Left = agent[i].x - shape[i]->Width / 2;
	  agent[i].y = random(400) + 30;
	  shape[i]->Top = agent[i].y - shape[i]->Height / 2;
	  agent[i].direction = (float(random(1000)) / 500) * M_PI;
      agent[i].velocity = float(random(1000)) / 1500 + .1;
   }
}

//--------------------------------------------------------------------- reset
void reset (void) {
   iterations = 0;
   Form1->EditIterations->Text = iterations;
   shuffle();
}

//-------------------------------------------------------------------- circle
void circle (void) {
   for (int i = 0; i < 24; i++) {
	  agent[i].x = 200 + 180 * cos(i * (2 * M_PI / 24)) + 30;
	  agent[i].y = 200 + 180 * sin(i * (2 * M_PI / 24)) + 30;
	  shape[i]->Left = agent[i].x - shape[i]->Width / 2;
	  shape[i]->Top = agent[i].y - shape[i]->Height / 2;
   }
}

//----------------------------------------------------------------- circulate
// The code for this function is bad
/*
void circulate (void) {
   for (int j = 0; j < 100; j++) {
      for (int i = 0; i < 23; i++) {
         agent[i].newDistance = sqrt(
            pow(agent[i+1].x - agent[i].x, 2) +
            pow(agent[i+1].y - agent[i].y, 2));
         if (agent[i+1].x - agent[i].x == 0) {
            agent[i].newDirection = atan(0);
         }
         else agent[i].newDirection = atan(
            agent[i+1].y - agent[i].y /
            agent[i+1].x - agent[i].x);
      }
      agent[23].newDistance = sqrt(
         pow(agent[23].x - agent[0].x, 2) +
         pow(agent[23].y - agent[0].y, 2));
      agent[23].newDirection = atan(
         agent[0].y - agent[23].y /
         agent[0].x - agent[23].x);
      agent[i].x += agent[i].newDistance * cos(agent[i].newDirection);
      agent[i].y += agent[i].newDistance * sin(agent[i].newDirection);
      shape[i]->Left = agent[i].x;
      shape[i]->Top =  agent[i].y;
   }
}
*/

//---------------------------------------------------------- nearest neighbor
int nearestNeighbor (int me) {
	int myNeighbor;
	double x, y, z;
	int dist = 10000;
	for (int i = 0; i < 24; i++) {
		if (i == me) continue;
		x = agent[i].x - agent[me].x;
		y = agent[i].y - agent[me].y;
		z = sqrt(x * x + y * y);
		if (z < dist) {
			dist = z;
			myNeighbor = i;
		}
	}
	return myNeighbor;
}

//---------------------------------------------------------------------- step
void step (void) {

   iterations++;
   Form1->EditIterations->Text = iterations;
   increment = Form1->TrackBarIncrement->Position;
   for (i = 0; i < 24; i++) {

	  // calculate agent's new position based on velocity and direction
	  agent[i].x += agent[i].velocity * cos(agent[i].direction) * increment;
	  agent[i].y += agent[i].velocity * sin(agent[i].direction) * increment;

	  // move the visualization on the screen accordingly
	  shape[i]->Left = agent[i].x - shape[i]->Width / 2;
	  shape[i]->Top =  agent[i].y - shape[i]->Height / 2;

	  ///////////////////////////////////////////////////////////////////////
	  ///////////////////// FLOCKING BEHAVIORS BELOW ////////////////////////
	  ///////////////////////////////////////////////////////////////////////

	  // adopt nearest neighbor's direction (problematic with BOUNCE)
	  if (Form1->RadioGroupFlockingBehavior->ItemIndex == 1) {
			agent[i].direction = agent[nearestNeighbor(i)].direction;
	  }

	  // increment direction by 1/50 your nearest neighbor's
	  if (Form1->RadioGroupFlockingBehavior->ItemIndex == 2) {
			agent[i].direction += agent[nearestNeighbor(i)].direction / 50;
			if (agent[i].direction > 2 * M_PI) {      // modulo divide
				  agent[i].direction = agent[i].direction - 2 * M_PI;
			}
	  }

	  // decrement direction by 1/100 your nearest neighbor's
	  if (Form1->RadioGroupFlockingBehavior->ItemIndex == 3) {
			agent[i].direction -= agent[nearestNeighbor(i)].direction / 100;
			if (agent[i].direction > 2 * M_PI) {      // modulo divide
				  agent[i].direction = agent[i].direction - 2 * M_PI;
			}
	  }

	  // adopt nearest neighbor's velocity
	  if (Form1->RadioGroupFlockingBehavior->ItemIndex == 4) {
			agent[i].velocity = agent[nearestNeighbor(i)].velocity;
	  }

	  // increment by half nearest neighbor's velocity
	  if (Form1->RadioGroupFlockingBehavior->ItemIndex == 5) {
			agent[i].velocity += agent[nearestNeighbor(i)].velocity / 50;
	  }

	  // adopt nearest neighbor's direction and speed
	  if (Form1->RadioGroupFlockingBehavior->ItemIndex == 6) {
			agent[i].velocity = agent[nearestNeighbor(i)].velocity;
            agent[i].direction = agent[nearestNeighbor(i)].direction;
	  }

	  ///////////////////////////////////////////////////////////////////////
	  ///////////////////// FLOCKING BEHAVIORS ABOVE  ///////////////////////
	  ///////////////////////////////////////////////////////////////////////

	  //////////////////////////////////////////////////////////////// BOUNCE
	  if (Form1->RadioGroupBoundary->ItemIndex == 0) {

		  if (agent[i].x > 430) {
			 agent[i].direction = M_PI - agent[i].direction;

			 if (soundType == 1) Beep(196, 50);
			 if (soundType == 2) {
				PlaySound
					("C:\\WINDOWS\\Media\\Windows XP Balloon.wav",
						"", SND_ASYNC);
			 }
			 if (soundType == 3) {
				PlaySound
					("C:\\Program Files\\Windows NT\\Pinball\\SOUND181.wav",
						"", SND_ASYNC);
			 }
			 if (soundType == 4) {
				message.data[0] = 0x90;
				message.data[1] = 55;
				message.data[2] = 100;
				message.data[3] = 0;
				midiOutShortMsg(device, message.word);
			 }

		  }

		  if (agent[i].y > 430) {
			 agent[i].direction = 2 * M_PI - agent[i].direction;

			 if (soundType == 1) Beep(261, 50);
			 if (soundType == 2) {
				PlaySound
					("C:\\WINDOWS\\Media\\Windows XP pop-up blocked.wav",
						"", SND_ASYNC);
			 }
			 if (soundType == 3) {
				PlaySound
					("C:\\Program Files\\Windows NT\\Pinball\\SOUND243.wav",
						"", SND_ASYNC);
			 }
			 if (soundType == 4) {
				message.data[0] = 0x90;
				message.data[1] = 60;
				message.data[2] = 100;
				message.data[3] = 0;
				midiOutShortMsg(device, message.word);
			 }

		  }

		  if (agent[i].x < 30) {
			 agent[i].direction = M_PI - agent[i].direction;

			 if (soundType == 1) Beep(330, 50);
			 if (soundType == 2) {
				PlaySound
					("C:\\WINDOWS\\Media\\Windows XP Balloon.wav",
						"", SND_ASYNC);
			 }
			 if (soundType == 3) {
				PlaySound
					("C:\\Program Files\\Windows NT\\Pinball\\SOUND713.wav",
						"", SND_ASYNC);
			 }
			 if (soundType == 4) {
				message.data[0] = 0x90;
				message.data[1] = 64;
				message.data[2] = 100;
				message.data[3] = 0;
				midiOutShortMsg(device, message.word);
			 }

		  }

		  if (agent[i].y < 30) {
			 agent[i].direction = 2 * M_PI - agent[i].direction;

			 if (soundType == 1) Beep(392, 50);
			 if (soundType == 2) {
				PlaySound
					("C:\\WINDOWS\\Media\\Windows XP pop-up blocked.wav",
						"", SND_ASYNC);
			 }
			 if (soundType == 3) {
				PlaySound
					("C:\\Program Files\\Windows NT\\Pinball\\SOUND735.wav",
						"", SND_ASYNC);
			 }
			 if (soundType == 4) {
				message.data[0] = 0x90;
				message.data[1] = 67;
				message.data[2] = 100;
				message.data[3] = 0;
				midiOutShortMsg(device, message.word);
			 }

		  }

		  // modular divide direction by one rotation
		  if (agent[i].direction > 2 * M_PI) {
			 agent[i].direction = agent[i].direction - 2 * M_PI;
		  }
		  if (agent[i].direction < 0) {
			 agent[i].direction = agent[i].direction + 2 * M_PI;
		  }

	  }

	  ///////////////////////////////////////////////////////////////// WRAP
	  else	{
		  if (agent[i].x > 430) {
			agent[i].x = 30;
			shape[i]->Left = agent[i].x - shape[i]->Width / 2;

			 if (soundType == 1) Beep(196, 50);
			 if (soundType == 2) {
				PlaySound
					("C:\\WINDOWS\\Media\\Windows XP Balloon.wav",
						"", SND_ASYNC);
			 }
			 if (soundType == 3) {
				PlaySound
					("C:\\Program Files\\Windows NT\\Pinball\\SOUND181.wav",
						"", SND_ASYNC);
			 }
			 if (soundType == 4) {
				message.data[0] = 0x90;
				message.data[1] = 55;
				message.data[2] = 100;
				message.data[3] = 0;
				midiOutShortMsg(device, message.word);
			 }

		  }
		  if (agent[i].x < 30) {
			agent[i].x = 430;
			shape[i]->Left = agent[i].x - shape[i]->Width / 2;

			 if (soundType == 1) Beep(261, 50);
			 if (soundType == 2) {
				PlaySound
					("C:\\WINDOWS\\Media\\Windows XP pop-up blocked.wav",
						"", SND_ASYNC);
			 }
			 if (soundType == 3) {
				PlaySound
					("C:\\Program Files\\Windows NT\\Pinball\\SOUND243.wav",
						"", SND_ASYNC);
			 }
			 if (soundType == 4) {
				message.data[0] = 0x90;
				message.data[1] = 60;
				message.data[2] = 100;
				message.data[3] = 0;
				midiOutShortMsg(device, message.word);
			 }

		  }
		  if (agent[i].y > 430) {
			agent[i].y = 30;
			shape[i]->Top = agent[i].y - shape[i]->Height / 2;

			 if (soundType == 1) Beep(330, 50);
			 if (soundType == 2) {
				PlaySound
					("C:\\WINDOWS\\Media\\Windows XP Balloon.wav",
						"", SND_ASYNC);
			 }
			 if (soundType == 3) {
				PlaySound
					("C:\\Program Files\\Windows NT\\Pinball\\SOUND713.wav",
						"", SND_ASYNC);
			 }
			 if (soundType == 4) {
				message.data[0] = 0x90;
				message.data[1] = 64;
				message.data[2] = 100;
				message.data[3] = 0;
				midiOutShortMsg(device, message.word);
			 }

		  }
		  if (agent[i].y < 30) {
			agent[i].y = 430;
			shape[i]->Top = agent[i].y - shape[i]->Height / 2;

			 if (soundType == 1) Beep(392, 50);
			 if (soundType == 2) {
				PlaySound
					("C:\\WINDOWS\\Media\\Windows XP pop-up blocked.wav",
						"", SND_ASYNC);
			 }
			 if (soundType == 3) {
				PlaySound
					("C:\\Program Files\\Windows NT\\Pinball\\SOUND735.wav",
						"", SND_ASYNC);
			 }
			 if (soundType == 4) {
				message.data[0] = 0x90;
				message.data[1] = 67;
				message.data[2] = 100;
				message.data[3] = 0;
				midiOutShortMsg(device, message.word);
			 }

		  }
	  }
   }
}

void run (void) {
   stop = false;
   message.data[0] = 0xC0;
   message.data[1] = 6;
   message.data[2] = 100;
   message.data[3] = 0;
   midiOutShortMsg(device, message.word);   
   while (stop == false) {
	  step();
	  Application->ProcessMessages();
   }
}

//===========================================================================
//                                                             EVENT HANDLERS
//===========================================================================

//------------------------------------------------------------ On Form Create
void __fastcall TForm1::FormCreate(TObject *Sender)
{
   midiOutOpen(&device, midiport, 0, 0, CALLBACK_NULL);

   randomize();

   // defines an array of shapes with properties and events
   for (int i = 0; i < 24; i++) {
      shape[i] = new TShape(this);
      shape[i]->Parent = Form1;
      shape[i]->Visible = true;
	  shape[i]->OnMouseDown = ShapeMouseDown;
	  shape[i]->OnMouseUp = ShapeMouseUp;
	  shape[i]->OnMouseMove = ShapeMouseMove;
	  shape[i]->Height = 50;
	  shape[i]->Width = 50;
	  shape[i]->Left = 0;
	  shape[i]->Top = 0;
	  shape[i]->Shape = stCircle;
      shape[i]->Tag = i;
      shape[i]->Pen->Width = 2;
      shape[i]->Pen->Color =
         static_cast<TColor>(colorRamp(25, 24 - shape[i]->Tag));
      shape[i]->Brush->Color =
         static_cast<TColor>(colorRamp(25, shape[i]->Tag));
   }
   shuffle();
}

//------------------------------------------------------- On Shape Mouse Down
// An exception to the rule which says "Let Borland write event handlers."
// This one you must type in yourself in addition to a reference to it
// in Unit1.h (look at the source code in that unit).
void __fastcall TForm1::ShapeMouseDown(TObject *Sender,
	  TMouseButton Button, TShiftState Shift, int X, int Y)
{
   TShape *shape = dynamic_cast<TShape*>(Sender);
   // The following will be used for mouseMove and mouseUp events...
   // Captures the index number of the shape that was clicked
   chosenAgent = shape->Tag;
   // remembers is we were stopped or running
   wasStopped = stop;
   stop = true;
   if (Button == 0) {                              // Begin drag object
	   // Remembers that an shape was chosen for mouseMove and mouseUp
	   agentWasJustChosen = true;
	   // Remembers where on the shape the mouse was downed
	   shapeDownX = X;
	   shapeDownY = Y;
   }
   else {                                         // Show nearest neighbor
	   Form1->Canvas->MoveTo(agent[chosenAgent].x, agent[chosenAgent].y);
	   Form1->Canvas->LineTo(agent[nearestNeighbor(chosenAgent)].x,
			agent[nearestNeighbor(chosenAgent)].y);
   }
}

//------------------------------------------------------- On Shape Mouse Move
// An exception to the rule which says "Let Borland write event handlers."
// This one you must type in yourself in addition to a reference to it
// in Unit1.h (look at the source code in that unit).
void __fastcall TForm1::ShapeMouseMove(TObject *Sender,
	  TShiftState Shift, int X, int Y)
{
   TShape *shape = dynamic_cast<TShape*>(Sender);
   chosenAgent = shape->Tag;
   if (agentWasJustChosen) {
	  // this drags the shape along...
	  shape->Left = shape->Left + X - shapeDownX;
	  shape->Top = shape->Top + Y - shapeDownY;
	  agent[chosenAgent].x = shape->Left + shape->Width / 2;;
	  agent[chosenAgent].y = shape->Top + shape->Height / 2;;
   }
   // When the mouse moves over an shape its values are displayed
   EditAgent->Text = shape->Tag;
   EditX->Text = int(agent[chosenAgent].x);
   EditY->Text = int(agent[chosenAgent].y);
   EditDirection->Text = agent[shape->Tag].direction;
   EditVelocity->Text = agent[shape->Tag].velocity;
}

//--------------------------------------------------------- On Shape Mouse Up
// An exception to the rule which says "Let Borland write event handlers."
// This one you must type in yourself in addition to a reference to it
// in Unit1.h (look at the source code in that unit).
void __fastcall TForm1::ShapeMouseUp(TObject *Sender,
	  TMouseButton Button, TShiftState Shift, int X, int Y)
{
   TShape *shape = dynamic_cast<TShape*>(Sender);
   // this is the end of the drag...
   agentWasJustChosen = false;
   EditAgent->Text = shape->Tag;
   // When the mouse moves over an shape its values are displayed
   EditX->Text = int(agent[chosenAgent].x);
   EditY->Text = int(agent[chosenAgent].y);
   EditDirection->Text = agent[shape->Tag].direction;
   EditVelocity->Text = agent[shape->Tag].velocity;
   // if we were running before the drag, then run...
   Form1->Refresh();
   if (!wasStopped) {
	   run();
   }
}

//---------------------------------------------------------------- run button
void __fastcall TForm1::ButtonRunClick(TObject *Sender)
{
	run();
}

//--------------------------------------------------------------- step button
void __fastcall TForm1::ButtonStepClick(TObject *Sender)
{
   stop = true;
   step();
}

//--------------------------------------------------------------- stop button
void __fastcall TForm1::ButtonStopClick(TObject *Sender)
{
   stop = true;
}

//---------------------------------------------------------- randomize button
void __fastcall TForm1::ButtonResetClick(TObject *Sender)
{
   reset();
}

//------------------------------------------------------------- circle button
void __fastcall TForm1::ButtonCircleClick(TObject *Sender)
{
   circle();
}

//------------------------------------------------------ size change trackBar
void __fastcall TForm1::TrackBarSizeChange(TObject *Sender)
{
	int size = TrackBarSize->Position;
	for (int i = 0; i < 24; i++) {
		shape[i]->Height = size;
		shape[i]->Width = size;
	}
}

//----------------------------------------------------- sound type RadioGroup
void __fastcall TForm1::RadioGroupSonificationClick(TObject *Sender)
{
	soundType = RadioGroupSonification->ItemIndex;
}

//---------------------------------------------------------------------------