Sorry your browser is not supported!

if mn Client Connected(NET_INSTANCE,0)
  ` Get Packets, do stuff, etc
else
  iReasonCode = mn Disconnect Reason(NET_INSTANCE)
  SELECT iReasonCode
    CASE 0 : print "Server Timed Out" : ENDCASE
    CASE 1 : print "Server Ended" : ENDCASE
    CASE 2 : print "Connection Failure" : ENDCASE
    CASE 10 : print "Illegal Characters in Player Name" : ENDCASE
    CASE 11 : print "Kicked for Suspected Cheating" : ENDCASE
    ...
    CASE 99 : print "No Reason Given" : ENDCASE
  ENDSELECT
endif

// Returns true if the specified virtual key is down
bool KeyDown(int VirtualKey)
{
	SHORT iResult = GetAsyncKeyState(VirtualKey);
	BYTE hibyte = HIBYTE(iResult);

	if(hibyte == 128)
	{
		return(true);
	}
	else
	{
		return(false);
	}
}

void main()
{
	// Instructions
	cout << "Press and hold the left control button to gather input from a microphonen";
	cout << "This will be played out of your speakersnn";
	cout << "Press the right control button to exitnnn";

	// Create packet to store input data
	long long int Data = mnCreatePacket();

	// Startup sound with 1 input instance and 1 output instance
	mnStartSound(1,1);

	// Start input and output on each instance, allowing DarkNet to find a compatible device
	mnStartInput(0,WAVE_MAPPER);
	mnStartOutput(0,WAVE_MAPPER);

	// Main loop
	while(0==0)
	{
		// Use less CPU
		Sleep(1);

		// If right control key is pressed then exit
		if(KeyDown(VK_RCONTROL) == true)
		{
			break;
		}

		// If left control key is down then get input data
		if(KeyDown(VK_LCONTROL) == true)
		{
			// Unpause input
			if(mnGetInputUnpaused(0) == 0)
			{
				mnUnpauseInput(0);
				cout << "Input unpausedn";
			}
		}
		else
		{
			// Pause input
			if(mnGetInputUnpaused(0) == 1)
			{
				mnPauseInput(0);
				cout << "Input pausedn";
			}
		}

		// Get input data and play it
		int iReturn = mnGetInputData(0,Data);

		if(iReturn > 0)
		{
			cout << "Input data received of size " << mnGetUsedSize(Data) << ". There were " << iReturn << " packets in waiting.n";

			// Play input data
			mnPlayData(0,Data);
		}
	}

	// Cleanup input and output instance
	mnFinishOutput(0);
	mnFinishInput(0);

	// Cleanup sound
	mnFinishSound();

	// Exit
	cout << "nnCleanup complete, thanks for using this applicationn";
	system("PAUSE");
}

// Returns true if the specified virtual key is down
bool KeyDown(int VirtualKey)
{
	SHORT iResult = GetAsyncKeyState(VirtualKey);
	BYTE hibyte = HIBYTE(iResult);

	if(hibyte == 128)
	{
		return(true);
	}
	else
	{
		return(false);
	}
}

void main()
{
	// Startup sound with 1 input instance and 1 output instance
	mnStartSound(1,1);

	// Create packet to store input data
	long long int Data = mnCreatePacket();

	// Determine what sound quality to use
	cout << "Select a sound quality:n";
	cout << " 0: Lown";
	cout << " 1: Mediumn";
	cout << " 2: Highn";
	unsigned int Qual;
	cin >> Qual;
	cout << "nn";

	switch(Qual)
	{
		case(0):
			mnSetInputFormatLow(0);
			mnSetOutputFormatLow(0);
		break;

		case(1):
			mnSetInputFormatMedium(0);
			mnSetOutputFormatMedium(0);
		break;

		case(2):
			mnSetInputFormatHigh(0);
			mnSetOutputFormatHigh(0);
		break;
	}

	// Determine whether to set additional options
	cout << "Set additional options?:n";
	cout << " 0: Non";
	cout << " 1: Yesn";
	bool DoExtra;
	cin >> DoExtra;
	cout << "nn";

	if(DoExtra == true)
	{
		// Variables
		unsigned int MillisecondsOfStoredDataCap;
		unsigned int TimeSinceLastAddedCap;
		unsigned int NumberOfBuffers;
		unsigned int TimePerBuffer;

		// Get user input and explain options
		cout << "There are 4 options, 2 input and 2 output related.n";
		cout << "To leave an option as default set it to 0.nnn";
		
		cout << "1: (Output) Milliseconds of stored data cap.n";
		cout << "Default is 500ms (half a second)n";
		cout << "The output instance will wait until enough data is available to play for this length of time, before outputing sound data.n";
		cout << "Answer: ";	cin >> MillisecondsOfStoredDataCap; cout << "nn";

		cout << "2: (Output) Time since last added cap.n";
		cout << "Default is 300msn";
		cout << "If no data has been output and not enough data has filled the output queue for this length of time then sound data will be output regardless.n";
		cout << "This is necassary to prevent output data waiting for unreasonable lengths of time e.g. if someone has finished their sentence and doesn't speak again for a while.n";
		cout << "Answer: ";	cin >> TimeSinceLastAddedCap; cout << "nn";

		cout << "3: (Input) Number of buffers.n";
		cout << "Default is 2n";
		cout << "In order to ensure smooth recording, there should be at least one buffer waiting in line whilst another records data.n";
		cout << "This prevents a gap whilst a buffer finishes recording and is re-entered into the queue.n";
		cout << "Increasing the number of buffers can improve smoothness, especially where the next option is a low number.n";
		cout << "Answer: ";	cin >> NumberOfBuffers; cout << "nn";

		cout << "4: (Input) Time per buffer.n";
		cout << "Default is 250ms (a quatre of a second)n";
		cout << "This is the length of time that each buffer will be recording for.n";
		cout << "Reducing this number will increase responsiveness but may reduce smoothness.n";
		cout << "Answer: ";	cin >> TimePerBuffer; cout << "nn";

		cout << "The options you selected are as follows:n";
		cout << "1: (Output) Milliseconds of stored data cap: " << MillisecondsOfStoredDataCap << "n";
		cout << "2: (Output) Time since last added cap: " << TimeSinceLastAddedCap << "n";
		cout << "3: (Input) Number of buffers: " << NumberOfBuffers << "n";
		cout << "4: (Input) Time per buffer: " << TimePerBuffer << "nn";

		// Set options
		mnSetOutputSmoothValues(0, MillisecondsOfStoredDataCap, TimeSinceLastAddedCap);
		mnSetInputSmoothValues(0, NumberOfBuffers, TimePerBuffer);
	}

	// Start input and output on each instance, allowing DarkNet to find a compatible device
	mnStartInput(0,WAVE_MAPPER);
	mnStartOutput(0,WAVE_MAPPER);

	// Instructions
	cout << "Setup is complete, you can begin recording!n";
	cout << "Press and hold the left control button to gather input from a microphonen";
	cout << "This will be played out of your speakersnn";
	cout << "Press the right control button to exitnnn";
	cout << "nn";

	// Main loop
	while(0==0)
	{
		// Use less CPU
		Sleep(1);

		// If right control key is pressed then exit
		if(KeyDown(VK_RCONTROL) == true)
		{
			break;
		}

		// If left control key is down then get input data
		if(KeyDown(VK_LCONTROL) == true)
		{
			// Unpause input
			if(mnGetInputUnpaused(0) == 0)
			{
				mnUnpauseInput(0);
				cout << "Input unpausedn";
			}
		}
		else
		{
			// Pause input
			if(mnGetInputUnpaused(0) == 1)
			{
				mnPauseInput(0);
				cout << "Input pausedn";
			}
		}

		// Get input data and play it
		int iReturn = mnGetInputData(0,Data);

		if(iReturn > 0)
		{
			cout << "Input data received of size " << mnGetUsedSize(Data) << " bytes. There were " << iReturn << " packets in waiting.n";

			// Play input data
			mnPlayData(0,Data);
		}
	}

	// Delete packet
	mnDeletePacket(Data);

	// Cleanup input and output instance
	mnFinishOutput(0);
	mnFinishInput(0);

	// Cleanup sound instance
	mnFinishSound();

	// Exit
	cout << "nnCleanup complete, thanks for using this applicationn";
	system("PAUSE");
}

'----- this function is needed in case any lines get cut off because of buffer size
Function handleStreamText(Line$)
      Global trailing$
      Local partline$
 
      ' look for EOL
      crpos = Line.find(Chr(10))    
      While crpos <> -1
            partline = trailing + Line$[..crpos]
            trailing = ""
 
            If parseTextLine(partline$)
                  Print(partline$)
 
                  Line = Line[(crpos+1)..]
 
            End If
            crpos = Line.find(Chr(10))    
      Wend

      ' this is whatever is left over, and it hangs around for the next frame
      trailing$ = Line
End Function

// Startup sound with 1 input instance
mnStartSound(1,0);

// Startup input
mnStartInput(0,-1);
mnUnpauseInput(0);

// Create packet to store input data
long long int Data;
Data = mnCreatePacket();

// Create line box
clLineBox LineBox(50,200,50,200,5,dbRGB(0,0,0),dbRGB(255,0,0),dbRGB(255,255,255));

while(LoopGDK() == true)
{
	Sleep(1);
	dbWait(1);

	// Get input data
	int iReturn = mnGetInputData(0,Data);
	if(iReturn > 0)
	{
		// Update line box
		LineBox.AddData(Data,mnGetInputBitsPerSample(0));
		LineBox.UpdateDisplay();
	}
}

mnFinishInput(0);
mnFinishSound();
return;

#include "FullInclude.h"
#include <DarkGDK.h>
#include <sstream>
using namespace std;

double ForceRange(double NewRange, double ExistingRange, double Value);

// CLASSES
// Line points
class clLineBox
{
	// Dimensions of box
	unsigned int Y1;
	unsigned int Y2;
	unsigned int X1;
	unsigned int X2;

	unsigned int XRange;
	unsigned int YRange;
	unsigned int YCenter;
	unsigned int BorderThickness;

	unsigned int LineColour;
	unsigned int BorderColour;
	unsigned int BackgroundColour;


	// Array containing line points
	int * LinePoint;
public:
	// Constructor
	clLineBox(int pY1, int pY2, int pX1, int pX2, int pBorderThickness, unsigned int pLineColour, unsigned int pBorderColour, unsigned int pBackgroundColour)
	{
		Y1 = pY1;
		Y2 = pY2;
		X1 = pX1;
		X2 = pX2;
		BorderThickness = pBorderThickness;

		LineColour = pLineColour;
		BorderColour = pBorderColour;
		BackgroundColour = pBackgroundColour;

		YRange = Y2-Y1;
		XRange = X2-X1;
		YCenter = Y1+(YRange/2);

		LinePoint = new int[XRange];
		for(unsigned int n = 0;n<XRange;n++)
		{
			LinePoint[n] = YCenter;
		}
	}

	~clLineBox()
	{
		delete[] LinePoint;
	}

	// Update display
	void UpdateDisplay()
	{
		// Draw background
		dbInk(BackgroundColour, dbRGB(0,0,0));
		dbBox(X1, Y1, X2, Y2);

		// Draw border
		dbInk(BorderColour, dbRGB(0,0,0));
		dbBox(X1-BorderThickness, Y1, X1, Y2+BorderThickness); // Left vertical line
		dbBox(X1-BorderThickness, Y1-BorderThickness, X2+BorderThickness, Y1); // Top horizontal line
		dbBox(X1, Y2, X2, Y2+BorderThickness); // Bottom horizontal line
		dbBox(X2, Y1, X2+BorderThickness, Y2+BorderThickness); // Right vertical line

		// Draw lines
		dbInk(LineColour, dbRGB(0,0,0));
		for(unsigned int n = 0;n<XRange;n++)
		{
			// Calclulate where line should start and end
			int iYa;
			int iXa;
			if(n == 0)
			{
				iXa = X1;

				// Center of box
				iYa = YCenter;
			}
			else
			{
				iXa = (n-1)+X1;
				iYa = LinePoint[n-1];
			}
	
			// Draw line
			dbLine(iXa,iYa,n+X1,LinePoint[n]);
		}
	}


	// Adds a packet of sound data to the end of LinePoint
	void AddData(long long int SoundData, unsigned short BitsPerSample)
	{
		// Amount of data
		unsigned int Size = mnGetUsedSize(SoundData);

		// Ensure that we do not go out of bounds
		if(Size > XRange)
		{
			Size = XRange;
		}

		// 16 bits = 2 bytes
		if(BitsPerSample == 16)
		{
			Size = Size/2;
		}

		// Shift bytes down to make new space
		for(unsigned int n = 0;n<XRange, n+Size < XRange;n++)
		{
			LinePoint[n] = LinePoint[n+Size];
		}

		// Add new data to freed space
		mnSetCursor(SoundData,0);
		for(unsigned int n = XRange-Size; n<XRange; n++)
		{
			if(BitsPerSample == 8)
			{
				// Get sound data
				LinePoint[n] = mnGetUnsignedByte(SoundData);

				// The following will ensure that values are kept within the box and scaled appropriately

				// Convert to double for calculation
				double dNewRange = YRange;
				double dValue = LinePoint[n];

				double Calculation = ForceRange(dNewRange, UCHAR_MAX, dValue);
				LinePoint[n] = static_cast<int>(Calculation);
			}
			else
			{
				// Get sound data
				LinePoint[n] = mnGetShortInt(SoundData);

				// Make wave positive
				int iLinePoint = LinePoint[n] += SHRT_MAX;

				// The following will ensure that values are kept within the box and scaled appropriately

				// Convert to double for calculation
				double dNewRange = YRange;
				double dValue = iLinePoint;

				double Calculation = ForceRange(dNewRange, USHRT_MAX, dValue);
				LinePoint[n] = static_cast<int>(Calculation);
			}

			// Ensure line is far enough down the screen
			LinePoint[n] += Y1;
		}
	}
};

// Volume box information
class clVolumeBox
{
	int X1;
	int Y1;
	int X2;
	int Y2;
	int BoxWidth;
	int BoxHeight;
	int BorderThickness;
	
	int BarLevel;
	static const int i8Sensitivity = 3;
	static const int i16Sensitivity = 2;

	unsigned int BarColour;
	unsigned int BorderColour;
	unsigned int BackgroundColour;

public:
	// Constructor
	clVolumeBox(int pY1, int pY2, int pX1, int pX2, int pBorderThickness, unsigned int pBarColour, unsigned int pBorderColour, unsigned int pBackgroundColour)
	{
		Y1 = pY1;
		Y2 = pY2;
		X1 = pX1;
		X2 = pX2;
		BorderThickness = pBorderThickness;
		
		BoxWidth = X2 - X1;
		BoxHeight = Y2 - Y1;

		BarColour = pBarColour;
		BorderColour = pBorderColour;
		BackgroundColour = pBackgroundColour;
	}

	// Set display
	void SetLevel(long long int SoundData, unsigned short BitsPerSample)
	{
		// Get average volume of sound
		int SoundVolume = mnGetSoundVolume(BitsPerSample,SoundData);

		// Convert to double for calculation
		double dNewRange = BoxHeight;
		double dValue = SoundVolume;

		// Determine height of bar
		double dHeight;
		if(BitsPerSample == 8)
		{
			dHeight = ForceRange(dNewRange,UCHAR_MAX/i8Sensitivity,dValue);
		}
		else
		{
			// Determine height of bar
			dHeight = ForceRange(dNewRange, SHRT_MAX/i16Sensitivity, dValue);
		}

		BarLevel = static_cast<int>(dHeight);		
	}

	// Update display
	void UpdateDisplay()
	{
		// Background
		dbInk(BackgroundColour,dbRGB(0,0,0));
		dbBox(X1, Y1, X2, Y2);

		// Border
		dbInk(BorderColour,dbRGB(0,0,0));
		dbBox(X1-BorderThickness, Y1, X1, Y2+BorderThickness); // Left vertical line
		dbBox(X1-BorderThickness, Y1-BorderThickness, X2+BorderThickness, Y1); // Top horizontal line
		dbBox(X1, Y2, X2, Y2+BorderThickness); // Bottom horizontal line
		dbBox(X2, Y1, X2+BorderThickness, Y2+BorderThickness); // Right vertical line		

		// Bar
		int DrawLevel;
		if(BarLevel > BoxHeight)
		{
			DrawLevel = BoxHeight;
		}
		else
		{
			DrawLevel = BarLevel;
		}

		dbInk(BarColour,dbRGB(0,0,0));
		dbBox(X1,Y1+(BoxHeight-DrawLevel),X2,Y2);
	}
};


// GLOBAL VARIABLES
const unsigned int ScreenWidth = 800, ScreenHeight = 600;

// Border is the width of the line surrounding objects
// Padding is the distance from the edge of the screen
const unsigned int Border = 3, Padding = 5, FullOffset = Border+Padding, BottomSize = 25*6;

// Line box
const unsigned int LineBoxTitleX = 95+Padding, LineBoxTitleY = Padding;
char * LineBoxTitleText = "VISUAL REPRESENTATION OF SOUND WAVE";
clLineBox BaseLineBox(20+FullOffset, ScreenHeight-FullOffset-BottomSize, 100, ScreenWidth-FullOffset, Border, dbRGB(255, 0, 0), dbRGB(255,255,255), dbRGB(64, 0, 64));

// Volume box
const unsigned int VolumeBoxTitleX = Padding, VolumeBoxTitleY = Padding;
char * VolumeBoxTitleText = "VOLUME";
clVolumeBox VolumeBox(20+FullOffset, ScreenHeight-FullOffset-BottomSize, FullOffset, 65+FullOffset, Border, dbRGB(0, 255, 64), dbRGB(255,255,255), dbRGB(64, 0, 64));

// Text at bottom of window
const unsigned int BottomX = FullOffset, BottomY = ScreenHeight-BottomSize;

// FUNCTIONS
// Converts Value so that it fits within NewRange
double ForceRange(double NewRange, double ExistingRange, double Value)
{
	double Calculation = (NewRange / ExistingRange) * Value;
	return(Calculation);
}


// dbInput returning an unsigned integer
unsigned int dbInputUI()
{
	char * strInput = dbInput(); // Get user input
	unsigned int iReturn = atoi(strInput); // Convert string into integer
	delete[] strInput; // Deallocate memory
	return(iReturn);
}

// dbInput returning boolean
bool dbInputB()
{
	bool bReturn = false;

	// Get user input
	char * strInput = dbInput();

	// Avoid going out of bounds
	if (strlen(strInput) > 0)
	{
		// If first character is 1 then return true
		if(strInput[0] == '1')
		{
			bReturn = true;
		}
		else
		{
			bReturn = false;
		}
	}

	// Deallocate memory
	delete[] strInput;

	// Return
	return(bReturn);
}


// Returns the ID of an input device selected by user
unsigned int SelectInputDevice()
{
	unsigned int iReturn;

	// Number of available input devices on system
	unsigned int iInputDevices = mnGetNumInputDevices();
	dbPrintC("Number of input devices: ");
	dbPrint((LONGLONG)iInputDevices);

	// Information about each input device
	dbPrint("input device information:");
	for(unsigned int n = 0;n<iInputDevices;n++)
	{
		dbPrint();

		// Device ID
		dbPrintC("Device ");
		dbPrint((LONGLONG)n);

		// Information
		dbPrintC("Name: ");
		dbPrint((char*)mnGetDeviceName(n,false));

		dbPrintC("Manufacturer ID: ");
		dbPrint((LONGLONG)mnGetDeviceManuID(n,false));

		dbPrintC("Product ID: ");
		dbPrint((LONGLONG)mnGetDeviceProductID(n,false));

		dbPrintC("Driver major version: ");
		dbPrint((LONGLONG)mnGetDeviceDriverMajorVersion(n,false));

		dbPrintC("Driver minor version: ");
		dbPrint((LONGLONG)mnGetDeviceDriverMinorVersion(n,false));

		dbPrintC("Max channels: ");
		dbPrint((LONGLONG)mnGetDeviceMaxChannels(n,false));

		// Wait for a key to be pressed to avoid going off the screen
		dbPrint("Press a key to see the next device...");
		dbWaitKey();
	}

	// Select a device
	dbPrint();
	dbPrintC("Select an input device from the list above: ");
	iReturn = dbInputUI();
	dbPrint();

	// Return selected device ID
	return(iReturn);
}



// Returns the ID of an output device selected by user
unsigned int SelectOutputDevice()
{
	unsigned int iReturn;

	// Number of available output devices on system
	unsigned int iOutputDevices = mnGetNumOutputDevices();
	dbPrintC("Number of output devices: ");
	dbPrint((LONGLONG)iOutputDevices);

	// Information about each output device
	dbPrint("Output device information:");
	for(unsigned int n = 0;n<iOutputDevices;n++)
	{
		dbPrint();

		// Device ID
		dbPrintC("Device ");
		dbPrint((LONGLONG)n);

		// Information
		dbPrintC("Name: ");
		dbPrint((char*)mnGetDeviceName(n,true));

		dbPrintC("Manufacturer ID: ");
		dbPrint((LONGLONG)mnGetDeviceManuID(n,true));

		dbPrintC("Product ID: ");
		dbPrint((LONGLONG)mnGetDeviceProductID(n,true));

		dbPrintC("Driver major version: ");
		dbPrint((LONGLONG)mnGetDeviceDriverMajorVersion(n,true));

		dbPrintC("Driver minor version: ");
		dbPrint((LONGLONG)mnGetDeviceDriverMinorVersion(n,true));

		dbPrintC("Max channels: ");
		dbPrint((LONGLONG)mnGetDeviceMaxChannels(n,true));

		// Wait for a key to be pressed to avoid going off the screen
		dbPrint("Press a key to see the next device...");
		dbWaitKey();
	}

	// Select a device
	dbPrint();
	dbPrintC("Select an output device from the list above: ");
	iReturn = dbInputUI();
	dbPrint();

	// Return selected device ID
	return(iReturn);
}

// Sets additional options based on user input
void SetAdditionalOptions()
{
	// Variables
	unsigned int MillisecondsOfStoredDataCap;
	unsigned int TimeSinceLastAddedCap;
	unsigned int NumberOfBuffers;
	unsigned int TimePerBuffer;

	// Get user input and explain options
	dbPrint("There are 4 options, 2 input and 2 output related.");
	dbPrint("To leave an option as default set it to 0.");
	dbPrint();
	dbPrint();

	dbPrint("1: (Output) Milliseconds of stored data cap.");
	dbPrint("Default is 300ms");
	dbPrint("The output instance will wait until enough data is available to play for this length of time, before outputing sound data.");
	dbPrintC("Answer: ");
	MillisecondsOfStoredDataCap = dbInputUI();
	dbPrint();

	dbPrint("2: (Output) Time since last added cap.");
	dbPrint("Default is 100ms");
	dbPrint("If no data has been output and not enough data has filled the output queue for this length of time then sound data will be output regardless.");
	dbPrint("This is necassary to prevent output data waiting for unreasonable lengths of time e.g. if someone has finished their sentence and doesn't speak again for a while.");
	dbPrintC("Answer: ");
	TimeSinceLastAddedCap = dbInputUI();
	dbPrint();

	dbPrint("3: (Input) Number of buffers.");
	dbPrint("Default is 4");
	dbPrint("In order to ensure smooth recording, there should be at least one buffer waiting in line whilst another records data.");
	dbPrint("This prevents a gap whilst a buffer finishes recording and is re-entered into the queue.");
	dbPrint("Increasing the number of buffers can improve smoothness, especially where the next option is a low number.");
	dbPrintC("Answer: ");
	NumberOfBuffers = dbInputUI();
	dbPrint();

	dbPrint("4: (Input) Time per buffer.");
	dbPrint("Default is 150ms");
	dbPrint("This is the length of time that each buffer will be recording for.");
	dbPrint("Reducing this number will increase responsiveness but may reduce smoothness.");
	dbPrintC("Answer: ");
	TimePerBuffer = dbInputUI();
	dbPrint();

	dbPrint("The options you selected are as follows:");
	
	dbPrintC("1: (Output) Milliseconds of stored data cap: ");
	dbPrint((LONGLONG)MillisecondsOfStoredDataCap);
	
	dbPrintC("2: (Output) Time since last added cap: ");
	dbPrint((LONGLONG)TimeSinceLastAddedCap);
	
	dbPrintC("3: (Input) Number of buffers: ");
	dbPrint((LONGLONG)NumberOfBuffers);
	
	dbPrintC("4: (Input) Time per buffer: ");
	dbPrint((LONGLONG)TimePerBuffer);

	// Set options
	mnSetOutputSmoothValues(0, MillisecondsOfStoredDataCap, TimeSinceLastAddedCap);
	mnSetInputSmoothValues(0, NumberOfBuffers, TimePerBuffer);

	// Wait for key
	dbPrint("Press any key to continue...");
	dbWaitKey();
}

void DarkGDK()
{
	// SETUP
	// Variables
	unsigned int iInputDeviceID;
	unsigned int iOutputDeviceID;
	int Value = 0;
	bool bFixVolume = false;

	// Setup window and font
	dbSetDisplayMode(ScreenWidth,ScreenHeight,32);
	dbSetTextSize(20);
	dbSetTextFont("Arial");

	// Startup sound with 1 input instance and 1 output instance
	mnStartSound(1,1);

	// Adjust defaults
	// because we want smaller buffers so that data is displayed in real time
	// Note: parameters set to 0 will not be changed i.e. will be left at original value
	mnSetOutputSmoothValues(0, 300, 100);
	mnSetInputSmoothValues(0, 4, 150);

	// Create packet to store input data
	long long int Data;
	Data = mnCreatePacket();

	// Choose manual or automatic input device selection
	dbPrint("Manually select an input device?");
	dbPrint("If you answer no then DarkNet will find an input device for you automatically"); 
	dbPrint(" 0: No");
	dbPrint(" 1: Yes");
	dbPrintC("Answer: ");
	bool ManInput = dbInputB();
	dbPrint();

	if(ManInput == true)
	{
		// Manually select input device
		iInputDeviceID = SelectInputDevice();
	}
	else
	{
		// Automatically select input device
		iInputDeviceID = -1;
	}

	// Clear screen
	dbCLS();

	// Choose manual or automatic output device selection
	dbPrint("Manually select an output device?");
	dbPrint("If you answer no then DarkNet will find an output device for you automatically"); 
	dbPrint(" 0: No");
	dbPrint(" 1: Yes");
	dbPrintC("Answer: ");
	bool ManOutput = dbInputB();
	dbPrint();

	if(ManOutput == true)
	{
		// Manually select input device
		iOutputDeviceID = SelectInputDevice();
	}
	else
	{
		// Automatically select input device
		iOutputDeviceID = -1;
	}

	// Clear screen
	dbCLS();

	// Determine what sound quality to use
	dbPrint("Select a sound quality:");
	dbPrint(" 0: Low");
	dbPrint(" 1: Medium");
	dbPrint(" 2: High");
	unsigned int Qual;
	Qual = dbInputUI();
	dbPrint();

	switch(Qual)
	{
		case(0):
			mnSetInputFormatLow(0);
			mnSetOutputFormatLow(0);
		break;

		case(1):
			mnSetInputFormatMedium(0);
			mnSetOutputFormatMedium(0);
		break;

		case(2):
			mnSetInputFormatHigh(0);
			mnSetOutputFormatHigh(0);
		break;
	}

	// Clear screen
	dbCLS();

	// Determine whether to set additional options
	dbPrint("Set additional options?:");
	dbPrint(" 0: No");
	dbPrint(" 1: Yes");
	bool DoExtra = dbInputB();
	dbPrint();

	if(DoExtra == true)
	{
		SetAdditionalOptions();
	}

	// Start input and output
	mnStartInput(0,iInputDeviceID);
	mnStartOutput(0,iOutputDeviceID);

	// MAIN LOOP
	while(LoopGDK() == true)
	{
		// Use less CPU
		Sleep(1);
		dbWait(1);

		// If right control key is pressed then exit
		if(dbKeyState(157) == 1)
		{
			break;
		}

		// If left control key is down then get input data
		if(dbKeyState(29) == 1)
		{
			// Unpause input
			if(mnGetInputUnpaused(0) == 0)
			{
				mnUnpauseInput(0);
			}
		}
		else
		{
			// Pause input
			if(mnGetInputUnpaused(0) == 1)
			{
				mnPauseInput(0);
			}
		}

		// If right shift is pressed increase value
		if(dbKeyState(54) == 1)
		{
			Value += 10;

			// Wait for key to be lifted
			while(dbKeyState(54) == 1)
			{
				Sleep(1);
			}
		}

		// If left shift is pressed decrease value
		if(dbKeyState(42) == 1)
		{
			Value -= 10;

			// Wait for key to be lifted
			while(dbKeyState(42) == 1)
			{
				Sleep(1);
			}
		}

		// If C key is pressed toggle volume fixing
		if(dbKeyState(15) == 1)
		{
			if(bFixVolume == true)
			{
				bFixVolume = false;
				Value = 0;
			}
			else
			{
				bFixVolume = true;
				Value = 10;
			}

			while(dbKeyState(15) == 1)
			{
				Sleep(1);
			}
		}


		// Get input data
		int iReturn = mnGetInputData(0,Data);

		// Deal with input data
		if(iReturn > 0)
		{
			// Get sound volume
			int SoundVolume = mnGetSoundVolume(mnGetInputBitsPerSample(0),Data);

			// Keep volume at cap	
			if(bFixVolume == true)
			{
				// When volume cap is at this point it has reached full volume
				// Note: full volume may be displayed by volume bars before
				// this point is reached due to volume bars' sensitivity adjustment
				// which ensures that smaller fluctuations in volume are better represented
				const double Sensitivity = 500;

				// Convert integers to double for increased accuracy
				double TempChange;
				double dSoundVolume = SoundVolume;
				double dVolumeCap = Value;

				// Avoid division by zero
				if(dSoundVolume != 0)
				{
					// Calculate percentage change necassary to adjust volume to required level
					double dRealVolumeCap;
					if(mnGetInputBitsPerSample(0) == 8)
					{
						dRealVolumeCap = ForceRange(UCHAR_MAX, Sensitivity, dVolumeCap);
					}
					else
					{
						dRealVolumeCap = ForceRange(USHRT_MAX, Sensitivity, dVolumeCap);
					}
					TempChange = ((dRealVolumeCap/dSoundVolume)*100)-100;
				}
				else
				{
					TempChange = 0.0;
				}

				// Adjust volume by calculated percentage
				mnChangeSoundVolume(mnGetInputBitsPerSample(0),Data,static_cast<int>(TempChange));
			}
			else
			{
				// Adjust sound volume by specified percentage
				mnChangeSoundVolume(mnGetInputBitsPerSample(0),Data,Value);
			}

			// Update line display array
			BaseLineBox.AddData(Data,mnGetInputBitsPerSample(0));
			VolumeBox.SetLevel(Data,mnGetInputBitsPerSample(0));

			// Play input data
			mnPlayData(0,Data);
		}


		// UPDATE DISPLAY
		// Refresh screen
		dbCLS();

		// Line box title
		dbInk(dbRGB(255,255,255),dbRGB(0,0,0));
		dbText(LineBoxTitleX, LineBoxTitleY, LineBoxTitleText);

		// Line box display
		BaseLineBox.UpdateDisplay();
		
		// Volume box title
		dbInk(dbRGB(255,255,255),dbRGB(0,0,0));
		dbText(VolumeBoxTitleX, VolumeBoxTitleY, VolumeBoxTitleText);
		
		// Volume box display
		VolumeBox.UpdateDisplay();

		// Text at bottom of screen
		// Information about the status of things such as options
		stringstream ssStatus;

		if(bFixVolume == true)
		{
			ssStatus << "Fixing volume at " << abs(Value);
		}
		else
		{
			if(Value > 0)
			{			
				ssStatus << "Increasing volume by " << Value << "%";
			}
			else
			{
				if(Value == 0)
				{
					ssStatus << "No volume increase or decrease";
				}
				else
				{
					ssStatus << "Decreasing volume by " << abs(Value) << "%";
				}
			}
		}

		if(mnGetInputPaused(0) == 0)
		{
			ssStatus << ". Input is unpaused.";
		}
		else
		{
			ssStatus << ". Input is paused.";
		}
		
		dbInk(dbRGB(255,255,255),dbRGB(0,0,0));
		dbText(BottomX, BottomY, (char*)ssStatus.str().c_str());

		// Instructions
		stringstream ssInstructions;
		ssInstructions << "nnINSTRUCTIONS nLCTRL = Gather input nRCTRL = Exit nTab = Switch between fixing/adjusting volume nLSHIFT/RSHIFT = Increase/Decrease value to fix/adjust volume by";

		dbInk(dbRGB(128, 128, 128),dbRGB(0,0,0));
		dbText(BottomX, BottomY, (char*)ssInstructions.str().c_str());
	}

	// CLEANUP
	// Delete packet
	mnDeletePacket(Data);

	// Cleanup input and output instance
	mnFinishOutput(0);
	mnFinishInput(0);

	// Cleanup sound instance
	mnFinishSound();

	// Exit
	dbInk(dbRGB(255,255,255),dbRGB(0,0,0));
	dbCLS();
	dbPrint("Cleanup complete, thanks for using this application");
	dbPrint("Press any key to exit...");
	while(dbScanCode() != 0)
	{
		Sleep(1);
	}
	dbWaitKey();
}

#include <MikeNet.h>
#include <iostream>
using namespace std;



// Entry point
void main()
{
	// MESSAGE BOX MODE
	// Enabled by default
	cout << "nMessage box moden";
	mnDNS("ERROR"); // Cause error (mnStart needs to be used before mnDNS)




	// SAVE MODE
	cout << "nSave moden";
	system("PAUSE");
	mnToggleErrorMode(EM_MESSAGE_BOX); // Disable error message boxes
	mnToggleErrorMode(EM_SAVE); // Enable save mode
	
	mnDNS("ERROR"); // Cause error

	// mnGetErrorFlag or the return value can be used
	// to determine if an error has occurred. mnGetErrorFlag
	// overcomes the problem that some commands return different
	// values upon error
	if(mnGetErrorFlag() == true)
	{
		cout << "An error occurred whilst " << mnGetErrorOperation() << 'n';
	}
	


	// EXCEPTION MODE
	cout << "nException moden";
	mnToggleErrorMode(EM_SAVE); // Disable save mode
	mnToggleErrorMode(EM_EXCEPTION); // Enable exception mode

	try
	{
		mnDNS("ERROR"); // Cause error
	}
	catch(clError & Error)
	{
		cout << "An error occurred whilst " << Error.sOperation << 'n';
	}



	// MULTIPLE MODES
	// In this case: exception and message box
	// Note: exception mode is already on
	cout << "nException and message box mode (at the same time)n";
	mnToggleErrorMode(EM_MESSAGE_BOX); // Enable message box mode

	try
	{
		mnDNS("ERROR"); // Cause error
	}
	catch(clError & Error)
	{
		cout << "An error occurred whilst " << Error.sOperation << 'n';
	}
	
	cout << "nn";
	system("PAUSE");
	return;
}

bool mnGetErrorFlag();
void mnSetErrorFlag();
void mnClearErrorFlag();
int mnToggleErrorMode(int Mode);
int mnGetErrorMode(int Mode);

struct clError
{
	bool bGenerated; // Indicates whether object is completely filled with info about an error

	char * sFullMessage;
	const char * sOperation;
	const char * sCommand;
	long long int iErrorCode; // Large data type to ensure compatibility with all possible return types (e.g. including UINT)
	int iLine;
	const char * sFile;

	// Helper functions
	void _CheckGenerated(); // Error if bGenerated is not true
	void _Copy(const clError & CopyMe); // Fills object with contents of CopyMe
	void _DefaultVars(); // Sets variables to default

	// Constructor, copy constructors and destructor
	clError();
	clError(const clError & CopyMe);
	clError & operator= (const clError & CopyMe);
	~clError();

	// Manipulate variables
	void Clear(); // Reset variables
	void SetCore(const char * Operation, long long int ErrorCode, int LineNo, const char * CodeFile); // Set everything except command
	void SetCommand(const char * Command); // Set command
	void SetFull(const char * Command, const char * Operation, long long int ErrorCode, int LineNo, const char * CodeFile); // Set everything
	
	// Generate full message based on information set by SetCore, SetCommand and SetFull
	void Generate();

	// Generate message and display message box
	void GenMessageBox(const char * Command);
	void GenMessageBox(const char * Command, const char * Operation, long long int ErrorCode, int LineNo, const char * CodeFile);

	// Generate message and decide what to do based on error mode
	void GenEvent(const char * Command);
	void GenEvent(const char * Command, const char * Operation, long long int ErrorCode, int LineNo, const char * CodeFile);

	// Generate message and throw exception
	void GenRethrow(const char * Command);
	void GenRethrow(const char * Command, const char * Operation, long long int ErrorCode, int LineNo, const char * CodeFile);

	// Below must be used AFTER full message is generated
	void DoMessageBox(); // Display message box
	void DoSave();	// Save message to be returned by mnGetError commands
	void DoRethrow(); // Throw clError exception
	void DoEvent(); // Decides what action to take based on error mode
};

int mnErase(long long int Packet, unsigned int StartPos, unsigned int Amount);
int mnInsert(long long int Packet, unsigned int Amount);
long long int mnCreatePacketFromPacket(long long int FromPacket);
long long int mnCreatePacketFromString(char * String);
int mnComparePacketString(long long int Packet, char * String);
int mnChangeMemorySize(long long int Packet, unsigned int Size);
int mnEqualPacketString(long long int Destination, char * From);

nt mnFlushRecvTCP(int Instance, int Client);
int mnFlushRecvUDP(int Instance, int Client);
int mnChangeBufferSizeTCP(int Instance, int Client, unsigned int iSize);
int mnSetAutoResizeTCP(int Instance, int Client, bool bAutoResize);
unsigned int mnGetTCPRecvSizeB(int Instance, int Client);
unsigned int mnGetTCPBytes(int Instance, int Client);

int mnDisableTCPHandshake(int Instance);
int mnGetTCPHandshakeEnabled(int Instance);

char mnGetTCPMode(int Instance);
int mnSetTCPMode(int Instance, char iTCPMode);

int mnShutdownClient(int Instance, int Client);
int mnEnableGracefulDisconnect(int Instance);
int mnGetGracefulDisconnectEnabled(int Instance);

unsigned int mnGetSendTimeout(int Instance);
int mnSetSendTimeout(int Instance, unsigned int iTimeout);

unsigned int mnGetTCPStoreAmount(int Instance, int Client);
unsigned int mnGetUDPStoreAmount(int Instance, int Client);

int mnSetTCPPostfix(int Instance, long long int Packet);
int mnSetTCPPostfix(int Instance, clPacket & Packet);
int mnGetTCPPostfix(int Instance, long long int Packet);
int mnGetTCPPostfix(int Instance, clPacket & Packet);

int mnGetNagleEnabled(int Instance);
int mnDisableNagle(int Instance);

int mnStartFirewall();
int mnFinishFirewall();
int mnUpdateFirewall();

unsigned int mnGetCurrentProfile();
int mnResetFirewall();
int mnIsPortAllowedA(char * FileName, long PortNumber, int Protocol, char * LocalAddress, int IPVersion);
int mnIsPortAllowedB(long PortNumber, int Protocol);
int mnIsTypeAllowedICMPA(unsigned char Type, char * LocalAddress, int IPVersion);
int mnIsTypeAllowedICMPB(unsigned char Type, int IPVersion);

const char * mnGetServiceName(unsigned int ProfileID, unsigned int ServiceID);
int mnGetServiceType(unsigned int ProfileID, unsigned int ServiceID);
int mnGetServiceCustomized(unsigned int ProfileID, unsigned int ServiceID);
int mnGetServiceIPVersion(unsigned int ProfileID, unsigned int ServiceID);
int mnGetServiceScope(unsigned int ProfileID, unsigned int ServiceID);
const char * mnGetServiceRemoteAddresses(unsigned int ProfileID, unsigned int ServiceID);
int mnGetServiceEnabled(unsigned int ProfileID, unsigned int ServiceID);

int mnSetServiceIPVersion(unsigned int ProfileID, unsigned int ServiceID, int IPVersion);
int mnSetServiceScope(unsigned int ProfileID, unsigned int ServiceID, int Scope);
int mnSetServiceRemoteAddresses(unsigned int ProfileID, unsigned int ServiceID, char * RemoteAddresses);
int mnSetServiceEnabled(unsigned int ProfileID, unsigned int ServiceID, bool Enabled);
int mnAddServicePort(unsigned int ProfileID, unsigned int ServiceID, char * Name, int IPVersion, int Protocol, long PortNumber, int Scope, char * RemoteAddresses, bool Enabled);
int mnDeleteServicePortA(unsigned int ProfileID, unsigned int ServiceID, long PortNumber, int Protocol);
int mnDeleteServicePortB(unsigned int ProfileID, unsigned int ServiceID, unsigned int PortID);
unsigned int mnFindServicePort(unsigned int ProfileID, unsigned int ServiceID, long PortNumber, int Protocol);
int mnServicePortExist(unsigned int ProfileID, unsigned int ServiceID, long PortNumber, int Protocol);
unsigned int mnGetServicePortAmount(unsigned int ProfileID, unsigned int ServiceID);

int mnGetFirewallEnabled(unsigned int ProfileID);
int mnGetExceptionsAllowed(unsigned int ProfileID);
int mnGetNotificationsEnabled(unsigned int ProfileID);
int mnGetUnicastToMulticastEnabled(unsigned int ProfileID);
int mnGetRemoteAdminIPVersion(unsigned int ProfileID);
int mnGetRemoteAdminScope(unsigned int ProfileID);
const char * mnGetRemoteAdminAddresses(unsigned int ProfileID);
int mnGetRemoteAdminEnabled(unsigned int ProfileID);
int mnGetICMPAllowOutboundDestinationUnreachable(unsigned int ProfileID);
int mnGetICMPAllowRedirect(unsigned int ProfileID);
int mnGetICMPAllowInboundEchoRequest(unsigned int ProfileID);
int mnGetICMPAllowOutboundTimeExceeded(unsigned int ProfileID);
int mnGetICMPAllowOutboundParameterProblem(unsigned int ProfileID);
int mnGetICMPAllowOutboundSourceQuench(unsigned int ProfileID);
int mnGetICMPAllowInboundRouterRequest(unsigned int ProfileID);
int mnGetICMPAllowInboundTimestampRequest(unsigned int ProfileID);
int mnGetICMPAllowInboundMaskRequest(unsigned int ProfileID);
int mnGetICMPAllowOutboundPacketTooBig(unsigned int ProfileID);

int mnSetFirewallEnabled(unsigned int ProfileID, bool Boolean);
int mnSetExceptionsAllowed(unsigned int ProfileID, bool Boolean);
int mnSetNotificationsEnabled(unsigned int ProfileID, bool Boolean);
int mnSetUnicastToMulticastEnabled(unsigned int ProfileID, bool Boolean);
int mnSetRemoteAdminIPVersion(unsigned int ProfileID, int IPVersion);
int mnSetRemoteAdminScope(unsigned int ProfileID, int Scope);
int mnSetRemoteAdminAddresses(unsigned int ProfileID, char * Addresses);
int mnSetRemoteAdminEnabled(unsigned int ProfileID, bool Boolean);
int mnSetICMPAllowOutboundDestinationUnreachable(unsigned int ProfileID, bool Boolean);
int mnSetICMPAllowRedirect(unsigned int ProfileID, bool Boolean);
int mnSetICMPAllowInboundEchoRequest(unsigned int ProfileID, bool Boolean);
int mnSetICMPAllowOutboundTimeExceeded(unsigned int ProfileID, bool Boolean);
int mnSetICMPAllowOutboundParameterProblem(unsigned int ProfileID, bool Boolean);
int mnSetICMPAllowOutboundSourceQuench(unsigned int ProfileID, bool Boolean);
int mnSetICMPAllowInboundRouterRequest(unsigned int ProfileID, bool Boolean);
int mnSetICMPAllowInboundTimestampRequest(unsigned int ProfileID, bool Boolean);
int mnSetICMPAllowInboundMaskRequest(unsigned int ProfileID, bool Boolean);
int mnSetICMPAllowOutboundPacketTooBig(unsigned int ProfileID, bool Boolean);

unsigned int mnGetApplicationAmount(unsigned int ProfileID);
int mnAddApplication(unsigned int ProfileID, char * Name, char * FileName, int IPVersion, int Scope, char * RemoteAddresses, bool Enabled);
int mnDeleteApplicationA(unsigned int ProfileID, char * FileName);
int mnDeleteApplicationB(unsigned int ProfileID, unsigned int ApplicationID);
unsigned int mnFindApplication(unsigned int ProfileID, char * FileName);
int mnApplicationExist(unsigned int ProfileID, char * FileName);

unsigned int mnGetServiceAmount(unsigned int ProfileID);

int mnAddPort(unsigned int ProfileID, char * Name, int IPVersion, int Protocol, long PortNumber, int Scope, char * RemoteAddresses, bool Enabled);
int mnDeletePortA(unsigned int ProfileID, long PortNumber, int Protocol);
int mnDeletePortB(unsigned int ProfileID, unsigned int PortID);
unsigned int mnFindPort(unsigned int ProfileID, long PortNumber, int Protocol);
int mnPortExist(unsigned int ProfileID, long PortNumber, int Protocol);
unsigned int mnGetPortAmount(unsigned int ProfileID);

const char * mnGetApplicationName(unsigned int ProfileID, unsigned int ApplicationID);
const char * mnGetApplicationFileName(unsigned int ProfileID, unsigned int ApplicationID);
int mnGetApplicationIPVersion(unsigned int ProfileID, unsigned int ApplicationID);
int mnGetApplicationScope(unsigned int ProfileID, unsigned int ApplicationID);
const char * mnGetApplicationRemoteAddresses(unsigned int ProfileID, unsigned int ApplicationID);
int mnGetApplicationEnabled(unsigned int ProfileID, unsigned int ApplicationID);
int mnSetApplicationName(unsigned int ProfileID, unsigned int ApplicationID, char * Name);
int mnSetApplicationFileName(unsigned int ProfileID, unsigned int ApplicationID, char * FileName);
int mnSetApplicationIPVersion(unsigned int ProfileID, unsigned int ApplicationID, int IPVersion);
int mnSetApplicationScope(unsigned int ProfileID, unsigned int ApplicationID, int Scope);
int mnSetApplicationRemoteAddresses(unsigned int ProfileID, unsigned int ApplicationID, char * RemoteAddresses);
int mnSetApplicationEnabled(unsigned int ProfileID, unsigned int ApplicationID, bool Enabled);

int mnStartSound(int NoInputInstances, int NoOutputInstances);
int mnFinishSound();
int mnGetNumInputInstances();
int mnGetNumOutputInstances();

int mnStartOutput(int InstanceID, unsigned int OutputDevice);
int mnFinishOutput(int InstanceID);
int mnPlayData(int InstanceID, long long int Packet);
int mnSetOutputSmoothValues(int InstanceID, unsigned int MillisecondsOfStoredDataCap, unsigned int TimeSinceLastAddedCap);
int mnSetOutputFormat(int InstanceID, unsigned short Channels, unsigned int SamplesPerSec, unsigned short BitsPerSample);
int mnSetOutputFormatHigh(int InstanceID);
int mnSetOutputFormatMedium(int InstanceID);
int mnSetOutputFormatLow(int InstanceID);
int mnSetDataVolume(unsigned short BitsPerSample, long long int Packet, int PercentageChange);
int mnGetDataVolume(unsigned short BitsPerSample, long long int Packet);

unsigned short mnGetOutputChannels(int InstanceID);
unsigned int mnGetOutputSamplesPerSec(int InstanceID);
unsigned short mnGetOutputBitsPerSample(int InstanceID);
unsigned int mnGetOutputStoredDataCap(int InstanceID);
unsigned int mnGetOutputLastAddedCap(int InstanceID);

double mnGetHardwarePlaybackRate(int InstanceID);
double mnGetHardwarePitch(int InstanceID);
unsigned short mnGetHardwareVolumeLeft(int InstanceID);
unsigned short mnGetHardwareVolumeRight(int InstanceID);
int mnSetHardwarePlaybackRate(int InstanceID, double Rate);
int mnSetHardwarePitch(int InstanceID, double Pitch);
int mnSetHardwareVolume(int InstanceID, unsigned short Left, unsigned short Right);

int mnStartInput(int InstanceID, unsigned int InputDevice);
int mnFinishInput(int InstanceID);
int mnPauseInput(int InstanceID);
int mnUnpauseInput(int InstanceID);
int mnGetInputData(int InstanceID, long long int Packet);
int mnGetInputUnpaused(int InstanceID);
int mnGetInputPaused(int InstanceID);
int mnSetInputSmoothValues(int InstanceID, unsigned int NoBuffers, unsigned int TimePerBuffer);
int mnSetInputFormat(int InstanceID, unsigned short Channels, unsigned int SamplesPerSec, unsigned short BitsPerSample);
int mnSetInputFormatHigh(int InstanceID);
int mnSetInputFormatMedium(int InstanceID);
int mnSetInputFormatLow(int InstanceID);

unsigned short mnGetInputChannels(int InstanceID);
unsigned int mnGetInputSamplesPerSec(int InstanceID);
unsigned short mnGetInputBitsPerSample(int InstanceID);
unsigned int mnGetInputNoBuffers(int InstanceID);
unsigned int mnGetInputTimePerBuffer(int InstanceID);


unsigned int mnGetNumInputDevices();
unsigned int mnGetNumOutputDevices();
unsigned short mnGetDeviceManuID(unsigned int DeviceID, bool Output);
unsigned short mnGetDeviceProductID(unsigned int DeviceID, bool Output);
unsigned char mnGetDeviceDriverMinorVersion(unsigned int DeviceID, bool Output);
unsigned char mnGetDeviceDriverMajorVersion(unsigned int DeviceID, bool Output);
const char * mnGetDeviceName(unsigned int DeviceID, bool Output);
unsigned int mnGetDeviceFormatSupport(unsigned int DeviceID, bool Output);
int mnReadDeviceFormatSupport(unsigned int SupportInfo, unsigned char KHZ, unsigned char Channels, unsigned char Bits);
unsigned short mnGetDeviceMaxChannels(unsigned int DeviceID, bool Output);
int mnGetDeviceHardwareSupport(unsigned int OutputDeviceID, unsigned int Feature);

#include "MikeNet.h"
#include <DarkGDK.h>

#include <DarkGDK.h>
#include "MikeNet.h"

if newMsg$ <> ""
   for x = 1 to 49
      Chat(x) = Chat(x+1)
   next x
   Chat(50) = newMsg$
endif

if ChatPositionY = (screen height()-200)
   set cursor 0, (screen height()-200+TextHeight)
   for x = 45 to 50
      print Chat(x)
   next x
endif

if ChatPositionY = (screen height()-500)
   set cursor 0, (screen height()-500+TextHeight)
   for x = 1 to 50
      print Chat(x)
   next x
endif