TeslaRel410/CODE/RP/MUNGA_L4/L4CTRL.TCP

//==========================================================================//
// File:	lbe4ctrl.tst                                                       //
// Project: MUNGA           Brick: LBE4 controls module                     //
// Contents: Test code for vector classes                                   //
//--------------------------------------------------------------------------//
//   Date    Who  Modification                                              //
// --------  ---  ----------------------------------------------------------//
// 12/26/94  CPB  Initial coding.                                           //
//--------------------------------------------------------------------------//
// Copyright (C) 1994, Virtual World Entertainment, Inc.                    //
// All Rights reserved worldwide                                            //
// This unpublished sourcecode is PROPRIETARY and CONFIDENTIAL              //
//==========================================================================//

#include <stdio.h>
#include <l4ctrl.thp>

//###########################################################################
//############################# TestReceiver ################################
//###########################################################################

#if 0
Derivation
	TestControlsReceiver::ClassDerivations(
		Receiver::ClassDerivations,"TestControlsReceiver"
	);

TestControlsReceiver::SharedData
	TestControlsReceiver::DefaultData(
		TestControlsReceiver::ClassDerivations,
		TestControlsReceiver::MessageHandlers
	);

TestControlsReceiver::TestControlsReceiver(
	TestControlsReceiver::ClassID class_ID,
	TestControlsReceiver::SharedData &shared_data
):
	Receiver(class_ID, shared_data)
{
	Check_Pointer(this);
	keyValue = 0;
	buttonValue = 0;
	scalarValue = 0.0f;
	joystickValue.x = 0.0f;
	joystickValue.y = 0.0f;
	mouseValue.x = 0;
	mouseValue.y = 0;
}

TestControlsReceiver::~TestControlsReceiver()
{
	Check(this);
}

void
TestControlsReceiver::KeyboardMessageHandler(
	ReceiverDataMessageOf<ControlsKey> *message
)
{
	Check(this);
	Check_Pointer(message);
	keyValue = message->dataContents;
}

void
TestControlsReceiver::ScalarMessageHandler(
	ReceiverDataMessageOf<Scalar> *message
)
{
	Check(this);
   Check_Pointer(message);
	scalarValue = message->dataContents;
}

void
TestControlsReceiver::JoystickMessageHandler(
	ReceiverDataMessageOf<ControlsJoystick> *message
)
{
	Check(this);
   Check_Pointer(message);
	joystickValue = message->dataContents;
}

void
TestControlsReceiver::ButtonMessageHandler(
	ReceiverDataMessageOf<ControlsButton> *message
)
{
	Check(this);
	Check_Pointer(message);
	buttonValue = message->dataContents;
}

void
TestControlsReceiver::MouseMessageHandler(
	ReceiverDataMessageOf<ControlsMouse> *message
)
{
	Check(this);
	Check_Pointer(message);
	mouseValue += message->dataContents;
}

const Receiver::HandlerEntry
	TestControlsReceiver::MessageHandlerEntries[]=
{
	{TestControlsReceiver::KeyboardMessageID,
		(Receiver::Handler)&TestControlsReceiver::KeyboardMessageHandler},
	{TestControlsReceiver::ScalarMessageID,
		(Receiver::Handler)&TestControlsReceiver::ScalarMessageHandler},
	{TestControlsReceiver::JoystickMessageID,
		(Receiver::Handler)&TestControlsReceiver::JoystickMessageHandler},
	{TestControlsReceiver::ButtonMessageID,
		(Receiver::Handler)&TestControlsReceiver::ButtonMessageHandler},
	{TestControlsReceiver::MouseMessageID,
		(Receiver::Handler)&TestControlsReceiver::MouseMessageHandler}
};

Receiver::MessageHandlerSet
	TestControlsReceiver::MessageHandlers(
		ELEMENTS(TestControlsReceiver::MessageHandlerEntries),
		TestControlsReceiver::MessageHandlerEntries,
		Receiver::MessageHandlers
	);
#endif

//
//###########################################################################
//###########################################################################
//
Logical
	LBE4ControlsManager::TestClass()
{
	Tell("Starting LBE4ControlsManager test...\n");

#if 0
	unsigned int fakeOwnerID(1);

	Check(application);
	LBE4ControlsManager *controlsManager(
		(LBE4ControlsManager *) application->GetControlsManager()
	);
	Check(controlsManager);

	ControlsJoystick	vector1;
	Check(&vector1);

	TestControlsReceiver *my_receiver;

	my_receiver = new TestControlsReceiver();
	Check(my_receiver);
	Register_Object(my_receiver);

	ControlsKey	directKey = 0;

	//
	//-------------------------------------------------------------------
	// Keyboard test
	//-------------------------------------------------------------------
	//
	controlsManager->
		keyboardGroup[LBE4ControlsManager::KeyboardPC].
			Add(
					fakeOwnerID,
					&directKey
				);

	controlsManager->
		keyboardGroup[LBE4ControlsManager::KeyboardPC].
			Add(
					fakeOwnerID,
					my_receiver,
					TestControlsReceiver::KeyboardMessageID
				);
	cout << "Key test: Press any PC keyboard key" <<
			" or ENTER to move to next test.\n";
	while (my_receiver->keyValue != 0x0D)
	{
		controlsManager->Execute();				// 'manually' call update
		application->ProcessAllEvents();			// 'manually' process events

		if (my_receiver->keyValue != 0)
		{
			cout << my_receiver->keyValue << "\n";
			Test(directKey == my_receiver->keyValue);

			if (my_receiver->keyValue != 0x0D)
			{
				my_receiver->keyValue = 0;
			}
		}
	}
	//
	//-------------------------------------------------------------------
	// Joystick test
	//-------------------------------------------------------------------
	//
	controlsManager->
		joystickGroup[LBE4ControlsManager::JoystickPhysical].
			Add(
					fakeOwnerID,
					my_receiver,
					TestControlsReceiver::JoystickMessageID
				);

	cout << "Joystick test: Press ENTER to end.\n";
	cout << "Verify left is positive, backward is positive.\n";
	my_receiver->keyValue = 0;
	while (my_receiver->keyValue != 0x0D)
	{
		char	buffer[40];

		controlsManager->Execute();				// 'manually' call update
		application->ProcessAllEvents();			// 'manually' process events

		sprintf(buffer, "(%-6.5f, %-6.5f)\r", 
					my_receiver->joystickValue.x,
					my_receiver->joystickValue.y
				);
		cout << buffer;
	}
	cout << "\n";
	cout << "Joystick centering test: 'swizzle' the stick to its limits,\n";
	cout << "then center the joystick and press ENTER.\n";

	controlsManager->BeginAlignJoystick();

	my_receiver->keyValue = 0;
	while (my_receiver->keyValue != 0x0D)
	{
		controlsManager->Execute();				// 'manually' call update
		application->ProcessAllEvents();			// 'manually' process events
	}

	controlsManager->EndAlignJoystick();

	cout << "\n";
	cout << "Joystick centering test: verify centered, then press ENTER.\n";

	my_receiver->keyValue = 0;
	while (my_receiver->keyValue != 0x0D)
	{
		char	buffer[40];

		controlsManager->Execute();				// 'manually' call update
		application->ProcessAllEvents();			// 'manually' process events

		sprintf(buffer, "(%-6.5f, %-6.5f)\r", 
					my_receiver->joystickValue.x,
					my_receiver->joystickValue.y
				);
		cout << buffer;
	}
	cout << "\n";

	//
	//-------------------------------------------------------------------
	// Scalar test
	//-------------------------------------------------------------------
	//
	controlsManager->
		scalarGroup[LBE4ControlsManager::ScalarJoystickX].
			Add(
					fakeOwnerID,
					my_receiver,
					TestControlsReceiver::ScalarMessageID
				);

	cout << "Scalar test: Press ENTER to end.\n";
	cout << "Value displayed is joystick X axis.\n";
	my_receiver->keyValue = 0;
	while (my_receiver->keyValue != 0x0D)
	{
		char	buffer[40];

		controlsManager->Execute();				// 'manually' call update
		application->ProcessAllEvents();			// 'manually' process events

		sprintf(buffer, "(%-6.5f)\r", my_receiver->scalarValue);
		cout << buffer;
	}
	cout << "\n";
	//
	//-------------------------------------------------------------------
	// Mouse test
	//-------------------------------------------------------------------
	//
	controlsManager->
		mouseGroup[0].
			Add(
					fakeOwnerID,
					my_receiver,
					TestControlsReceiver::MouseMessageID
				);

	cout << "Mouse test: Press ENTER to end.\n";
	my_receiver->keyValue = 0;
	while (my_receiver->keyValue != 0x0D)
	{
		char	buffer[40];

		controlsManager->Execute();				// 'manually' call update
		application->ProcessAllEvents();			// 'manually' process events

		sprintf(buffer, "(%-06d, %-06d)\r", 
					my_receiver->mouseValue.x,
					my_receiver->mouseValue.y
				);
		cout << buffer;
	}
	cout << "\n";
	//
	//-------------------------------------------------------------------
	// "Virtual" (mouse-driven) joystick test
	//-------------------------------------------------------------------
	//
	ControlsJoystick	fakeJoystick;

	controlsManager->
		joystickGroup[LBE4ControlsManager::JoystickVirtual].
			Add(
					fakeOwnerID,
					&fakeJoystick
				);

	cout << "Virtual (mouse) joystick test: Press ENTER to end.\n";
	cout << "Verify left is positive, backward is positive.\n";
	my_receiver->keyValue = 0;
	while (my_receiver->keyValue != 0x0D)
	{
		char	buffer[40];

		controlsManager->Execute();				// 'manually' call update
		application->ProcessAllEvents();			// 'manually' process events

		sprintf(buffer, "(%-6.5f, %-6.5f)\r", 
					fakeJoystick.x,
					fakeJoystick.y
				);
		cout << buffer;
	}
	cout << "\n";
	//
	//-------------------------------------------------------------------
	// Button test
	//-------------------------------------------------------------------
	//
	controlsManager->
		buttonGroup[LBE4ControlsManager::ButtonJoystickHatUp].
			Add(
					fakeOwnerID,
					my_receiver,
					TestControlsReceiver::ButtonMessageID
				);
	controlsManager->
		buttonGroup[LBE4ControlsManager::ButtonJoystickHatDown].
			Add(
					fakeOwnerID,
					my_receiver,
					TestControlsReceiver::ButtonMessageID
				);

	controlsManager->
		buttonGroup[LBE4ControlsManager::ButtonJoystickHatLeft].
			Add(
					fakeOwnerID,
					my_receiver,
					TestControlsReceiver::ButtonMessageID
				);
	controlsManager->
		buttonGroup[LBE4ControlsManager::ButtonJoystickHatRight].
			Add(
					fakeOwnerID,
					my_receiver,
					TestControlsReceiver::ButtonMessageID
				);
	controlsManager->
		buttonGroup[LBE4ControlsManager::ButtonJoystickTrigger].
			Add(
					fakeOwnerID,
					my_receiver,
					TestControlsReceiver::ButtonMessageID
				);
	controlsManager->
		buttonGroup[LBE4ControlsManager::ButtonJoystickThumbHigh].
			Add(
					fakeOwnerID,
					my_receiver,
					TestControlsReceiver::ButtonMessageID
				);

	controlsManager->
		buttonGroup[LBE4ControlsManager::ButtonJoystickThumbLow].
			Add(
					fakeOwnerID,
					my_receiver,
					TestControlsReceiver::ButtonMessageID
				);
	controlsManager->
		buttonGroup[LBE4ControlsManager::ButtonJoystickPinky].
			Add(
					fakeOwnerID,
					my_receiver,
					TestControlsReceiver::ButtonMessageID
				);

	cout << "Button test: Operate joystick buttons. Press ENTER to end.\n";
	my_receiver->keyValue = 0;
	while (my_receiver->keyValue != 0x0D)
	{
		controlsManager->Execute();				// 'manually' call update
		application->ProcessAllEvents();			// 'manually' process events

		if (my_receiver->buttonValue)
		{
			switch(my_receiver->buttonValue)
			{
			case ButtonJoystickHatUp:	   cout << "Press hat up\n"; break;
			case -ButtonJoystickHatUp:	   cout << "Release hat up\n"; break;
			case ButtonJoystickHatDown:	cout << "Press hat down\n"; break;
			case -ButtonJoystickHatDown:	cout << "Release hat down\n"; break;
			case ButtonJoystickHatLeft:	cout << "Press hat left\n"; break;
			case -ButtonJoystickHatLeft:	cout << "Release hat left\n"; break;
			case ButtonJoystickHatRight:	cout << "Press hat right\n"; break;
 			case -ButtonJoystickHatRight:	cout << "Release hat right\n"; break;
			case ButtonJoystickTrigger:	cout << "Press trigger\n"; break;
			case -ButtonJoystickTrigger:	cout << "Release trigger\n"; break;
			case ButtonJoystickThumbHigh:	cout << "Press thumb high\n"; break;
			case -ButtonJoystickThumbHigh:cout << "Release thumb high\n"; break;
			case ButtonJoystickThumbLow:	cout << "Press thumb low\n"; break;
			case -ButtonJoystickThumbLow:	cout << "Release thumb low\n"; break;
			case ButtonJoystickPinky:	   cout << "Press pinky\n"; break;
			case -ButtonJoystickPinky:	   cout << "Release pinky\n"; break;
			}
			my_receiver->buttonValue = 0;
		}
   }

	controlsManager->Remove(fakeOwnerID);

	Unregister_Object(my_receiver);
	delete my_receiver;
#endif

	return True;
}