CWE-ou-minkata/MOULOpenSourceClientPlugin/Plasma20/Sources/Plasma/FeatureLib/pfConsole/pfConsole.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
//////////////////////////////////////////////////////////////////////////////
//																			//
//	pfConsole Functions														//
//																			//
//////////////////////////////////////////////////////////////////////////////

#include "pfConsole.h"
#include "pfConsoleEngine.h"
#include "plPipeline/plDebugText.h"
#include "plInputCore/plInputDevice.h"
#include "plInputCore/plInputInterface.h"
#include "plInputCore/plInputInterfaceMgr.h"
#include "pnInputCore/plKeyMap.h"
#include "pnInputCore/plKeyDef.h"
#include "plMessage/plInputEventMsg.h"
#include "plMessage/plConsoleMsg.h"
#include "plMessage/plInputIfaceMgrMsg.h"
#include "pnKeyedObject/plFixedKey.h"
#include "hsTimer.h"
#include "plgDispatch.h"
#include "plPipeline.h"
#include "hsConfig.h"

#include "pfPython/cyPythonInterface.h"
#include "plNetClient/plNetClientMgr.h"

#ifndef PLASMA_EXTERNAL_RELEASE
#include "pfGameMgr/pfGameMgr.h"
#endif // PLASMA_EXTERNAL_RELEASE


//// Static Class Stuff //////////////////////////////////////////////////////

pfConsole	*pfConsole::fTheConsole = nil;
UInt32		pfConsole::fConsoleTextColor = 0xff00ff00;
plPipeline	*pfConsole::fPipeline = nil;


//////////////////////////////////////////////////////////////////////////////
//// pfConsoleInputInterface - Input interface layer for the console /////////
//////////////////////////////////////////////////////////////////////////////

class pfConsoleInputInterface : public plInputInterface
{
	protected:

		pfConsole	*fConsole;


		virtual hsBool	IHandleCtrlCmd( plCtrlCmd *cmd )
		{
			if( cmd->fControlCode == B_SET_CONSOLE_MODE )
			{
				if( cmd->fControlActivated )
				{
					// Activate/deactivate
					switch( fConsole->fMode )
					{
						case pfConsole::kModeHidden:
							fConsole->ISetMode( pfConsole::kModeSingleLine );
							break;
						case pfConsole::kModeSingleLine:
							fConsole->ISetMode( pfConsole::kModeFull );
							break;
						case pfConsole::kModeFull:
							fConsole->ISetMode( pfConsole::kModeHidden );
							break;
					}
				}
				return true;
			}
			return false;
		}

	public:

		pfConsoleInputInterface( pfConsole *console ) 
		{
			fConsole = console; 
			SetEnabled( true );			// Always enabled

			// Add our control codes to our control map. Do NOT add the key bindings yet.
			// Note: HERE is where you specify the actions for each command, i.e. net propagate and so forth.
			// This part basically declares us master of the bindings for these commands.
			
			// IF YOU ARE LOOKING TO CHANGE THE DEFAULT KEY BINDINGS, DO NOT LOOK HERE. GO TO
			// RestoreDefaultKeyMappings()!!!!

#ifndef PLASMA_EXTERNAL_RELEASE
			fControlMap->AddCode( B_SET_CONSOLE_MODE, kControlFlagNormal | kControlFlagNoRepeat );
#endif

			// IF YOU ARE LOOKING TO CHANGE THE DEFAULT KEY BINDINGS, DO NOT LOOK HERE. GO TO
			// RestoreDefaultKeyMappings()!!!!
		}

		virtual UInt32	GetPriorityLevel( void ) const			{ return kConsolePriority; }
		virtual UInt32	GetCurrentCursorID( void ) const		{ return kCursorHidden; }
		virtual hsBool	HasInterestingCursorID( void ) const	{ return false; }

		virtual hsBool	InterpretInputEvent( plInputEventMsg *pMsg )
		{
			plKeyEventMsg	*keyMsg = plKeyEventMsg::ConvertNoRef( pMsg );

			// HACK for now to let runlock work always (until we can think of a more generic and good way of doing this)
			if( keyMsg != nil && keyMsg->GetKeyCode() != KEY_CAPSLOCK )
			{
				if( fConsole->fMode )
				{
					fConsole->IHandleKey( keyMsg );
					return true;
				}
			}

			return false;
		}

		virtual void	RefreshKeyMap( void )
		{
		}

		virtual void	RestoreDefaultKeyMappings( void )
		{
			if( fControlMap != nil )
			{
				fControlMap->UnmapAllBindings();
#ifndef PLASMA_EXTERNAL_RELEASE
				fControlMap->BindKey( KEY_TILDE, B_SET_CONSOLE_MODE );
#endif
			}
		}
};

//// Constructor & Destructor ////////////////////////////////////////////////

pfConsole::pfConsole()
{
	fNumDisplayLines = 32;
	fDisplayBuffer = nil;
	fTheConsole = this;
	fFXEnabled = true;
}

pfConsole::~pfConsole()
{
	if( fInputInterface != nil )
	{
		plInputIfaceMgrMsg *msg = TRACKED_NEW plInputIfaceMgrMsg( plInputIfaceMgrMsg::kRemoveInterface );
		msg->SetIFace( fInputInterface );
		plgDispatch::MsgSend( msg );

		hsRefCnt_SafeUnRef( fInputInterface );
		fInputInterface = nil;
	}

	if( fDisplayBuffer != nil )
	{
		delete [] fDisplayBuffer;
		fDisplayBuffer = nil;
	}

	fTheConsole = nil;

	plgDispatch::Dispatch()->UnRegisterForExactType( plConsoleMsg::Index(), GetKey() );
	plgDispatch::Dispatch()->UnRegisterForExactType( plControlEventMsg::Index(), GetKey() );

#ifndef PLASMA_EXTERNAL_RELEASE	
	pfGameMgr::GetInstance()->RemoveReceiver(GetKey());
#endif // PLASMA_EXTERNAL_RELEASE
}

pfConsole * pfConsole::GetInstance () {

	return fTheConsole;
}

//// Init ////////////////////////////////////////////////////////////////////

void	pfConsole::Init( pfConsoleEngine *engine )
{
	fDisplayBuffer = TRACKED_NEW char[ fNumDisplayLines * kMaxCharsWide ];
	memset( fDisplayBuffer, 0, fNumDisplayLines * kMaxCharsWide );

	memset( fWorkingLine, 0, sizeof( fWorkingLine ) );
	fWorkingCursor = 0;

	memset( fHistory, 0, sizeof( fHistory ) );
	fHistoryCursor = fHistoryRecallCursor = 0;

	fEffectCounter = 0;
	fMode = 0;
	fMsgTimeoutTimer = 0;
	fHelpMode = false;
	fPythonMode = false;
	fPythonFirstTime = true;
	fPythonMultiLines = 0;
	fHelpTimer = 0;
	fCursorTicks = 0;
	memset( fLastHelpMsg, 0, sizeof( fLastHelpMsg ) );
	fEngine = engine;

	fInputInterface = TRACKED_NEW pfConsoleInputInterface( this );
	plInputIfaceMgrMsg *msg = TRACKED_NEW plInputIfaceMgrMsg( plInputIfaceMgrMsg::kAddInterface );
	msg->SetIFace( fInputInterface );
	plgDispatch::MsgSend( msg );

	// Register for keyboard event messages
	plgDispatch::Dispatch()->RegisterForExactType( plConsoleMsg::Index(), GetKey() );
	plgDispatch::Dispatch()->RegisterForExactType( plControlEventMsg::Index(), GetKey() );

#ifndef PLASMA_EXTERNAL_RELEASE	
	pfGameMgr::GetInstance()->AddReceiver(GetKey());
#endif // PLASMA_EXTERNAL_RELEASE
}

//// ISetMode ////////////////////////////////////////////////////////////////

void	pfConsole::ISetMode( UInt8 mode )
{
	fMode = mode; 
	fEffectCounter = ( fFXEnabled ? kEffectDivisions : 0 ); 
	fMsgTimeoutTimer = 0; 
	fInputInterface->RefreshKeyMap();
}

//// MsgReceive //////////////////////////////////////////////////////////////

hsBool	pfConsole::MsgReceive( plMessage *msg )
{
	plControlEventMsg *ctrlMsg = plControlEventMsg::ConvertNoRef( msg );
	if( ctrlMsg != nil )
	{
		if( ctrlMsg->ControlActivated() && ctrlMsg->GetControlCode() == B_CONTROL_CONSOLE_COMMAND && plNetClientMgr::GetInstance()->GetFlagsBit(plNetClientMgr::kPlayingGame))
		{
			fEngine->RunCommand( ctrlMsg->GetCmdString(), IAddLineCallback );
			return true;
		}
		return false;
	}

	plConsoleMsg *cmd = plConsoleMsg::ConvertNoRef( msg );
	if( cmd != nil && cmd->GetString() != nil )
	{
		if( cmd->GetCmd() == plConsoleMsg::kExecuteFile )
		{
			if( !fEngine->ExecuteFile( (char *)cmd->GetString() ) )
			{
				// Change the following line once we have a better way of reporting
				// errors in the parsing
				static char	str[ 256 ];
				static char	msg[ 1024 ];

				sprintf( str, "Error parsing %s", cmd->GetString() );
				sprintf( msg, "%s:\n\nCommand: '%s'\n%s", fEngine->GetErrorMsg(), fEngine->GetLastErrorLine(),
#ifdef HS_DEBUGGING
						"" );

				hsAssert( false, msg );
#else
						"\nPress OK to continue parsing files." );

				hsMessageBox( msg, str, hsMessageBoxNormal );
#endif
			}
		}
		else if( cmd->GetCmd() == plConsoleMsg::kAddLine )
			IAddParagraph( (char *)cmd->GetString() );
		else if( cmd->GetCmd() == plConsoleMsg::kExecuteLine )
		{
			if( !fEngine->RunCommand( (char *)cmd->GetString(), IAddLineCallback ) )
			{
				// Change the following line once we have a better way of reporting
				// errors in the parsing
				static char	msg[ 1024 ];

				sprintf( msg, "%s:\n\nCommand: '%s'\n", fEngine->GetErrorMsg(), fEngine->GetLastErrorLine() );
				IAddLineCallback( msg ); 
			}
		}
			
		return true;
	}


	//========================================================================
	// pfGameMgrMsg
#ifndef PLASMA_EXTERNAL_RELEASE
	if (pfGameMgrMsg * gameMgrMsg = pfGameMgrMsg::ConvertNoRef(msg)) {

		switch (gameMgrMsg->netMsg->messageId) {

			//================================================================
			// InviteReceived			
			case kSrv2Cli_GameMgr_InviteReceived: {
				const Srv2Cli_GameMgr_InviteReceived & gmMsg = *(const Srv2Cli_GameMgr_InviteReceived *)gameMgrMsg->netMsg;
				const char * inviterName = plNetClientMgr::GetInstance()->GetPlayerNameById(gmMsg.inviterId);
				AddLineF("[GameMgr] Invite received: %S, %u. Inviter: %s", pfGameMgr::GetInstance()->GetGameNameByTypeId(gmMsg.gameTypeId), gmMsg.newGameId, inviterName ? inviterName : "<Unknown>");
			}
			return true;

			//================================================================
			// InviteRevoked			
			case kSrv2Cli_GameMgr_InviteRevoked: {
				const Srv2Cli_GameMgr_InviteRevoked & gmMsg = *(const Srv2Cli_GameMgr_InviteRevoked *)gameMgrMsg->netMsg;
				const char * inviterName = plNetClientMgr::GetInstance()->GetPlayerNameById(gmMsg.inviterId);
				AddLineF("[GameMgr] Invite revoked: %S, %u. Inviter: %s", pfGameMgr::GetInstance()->GetGameNameByTypeId(gmMsg.gameTypeId), gmMsg.newGameId, inviterName ? inviterName : "<Unknown>");
			}
			return true;
			
			DEFAULT_FATAL(gameMgrMsg->netMsg->messageId);
		};
	}
#endif // PLASMA_EXTERNAL_RELEASE
	//========================================================================
	
	//========================================================================
	// pfGameCliMsg
#ifndef PLASMA_EXTERNAL_RELEASE
	if (pfGameCliMsg * gameCliMsg = pfGameCliMsg::ConvertNoRef(msg)) {
	
		pfGameCli * cli = gameCliMsg->gameCli;
	
		//====================================================================
		// Handle pfGameCli msgs
		switch (gameCliMsg->netMsg->messageId) {
			//================================================================
			// PlayerJoined
			case kSrv2Cli_Game_PlayerJoined: {
				const Srv2Cli_Game_PlayerJoined & netMsg = *(const Srv2Cli_Game_PlayerJoined *)gameCliMsg->netMsg;
				AddLineF(
					"[Game %s:%u] Player joined: %s",
					cli->GetName(),
					cli->GetGameId(),
					netMsg.playerId
						? plNetClientMgr::GetInstance()->GetPlayerNameById(netMsg.playerId)
						: "Computer"
				);
			}
			return true;

			//================================================================
			// PlayerLeft
			case kSrv2Cli_Game_PlayerLeft: {
				const Srv2Cli_Game_PlayerLeft & netMsg = *(const Srv2Cli_Game_PlayerLeft *)gameCliMsg->netMsg;
				AddLineF(
					"[Game %s:%u] Player left: %s",
					cli->GetName(),
					cli->GetGameId(),
					netMsg.playerId
						? plNetClientMgr::GetInstance()->GetPlayerNameById(netMsg.playerId)
						: "Computer"
				);
			}
			return true;
			
			//================================================================
			// InviteFailed
			case kSrv2Cli_Game_InviteFailed: {
				const Srv2Cli_Game_InviteFailed & netMsg = *(const Srv2Cli_Game_InviteFailed *)gameCliMsg->netMsg;
				AddLineF(
					"[Game %s:%u] Invite failed for playerId %u, error %u",
					cli->GetName(),
					cli->GetGameId(),
					netMsg.inviteeId,
					netMsg.error
				);
			}
			return true;

			//================================================================
			// OwnerChange
			case kSrv2Cli_Game_OwnerChange: {
				const Srv2Cli_Game_OwnerChange & netMsg = *(const Srv2Cli_Game_OwnerChange *)gameCliMsg->netMsg;
				AddLineF(
					"[Game %s:%u] Owner changed to playerId %u",
					cli->GetName(),
					cli->GetGameId(),
					netMsg.ownerId
				);
			}
			return true;
		}

		//====================================================================
		// Handle Tic-Tac-Toe msgs
		if (gameCliMsg->gameCli->GetGameTypeId() == kGameTypeId_TicTacToe) {
		
			pfGmTicTacToe * ttt = pfGmTicTacToe::ConvertNoRef(cli);
			ASSERT(ttt);
			
			switch (gameCliMsg->netMsg->messageId) {
				//============================================================
				// GameStarted
				case kSrv2Cli_TTT_GameStarted: {
					const Srv2Cli_TTT_GameStarted & netMsg = *(const Srv2Cli_TTT_GameStarted *)gameCliMsg->netMsg;
					if (netMsg.yourTurn)
						AddLineF(
							"[Game %s:%u] Game started. You are X's. You go first.",
							cli->GetName(),
							cli->GetGameId()
						);
					else
						AddLineF(
							"[Game %s:%u] Game started. You are O's. Other player goes first.",
							cli->GetName(),
							cli->GetGameId()
						);
					ttt->ShowBoard();
				}
				return true;

				//============================================================
				// GameOver
				case kSrv2Cli_TTT_GameOver: {
					const Srv2Cli_TTT_GameOver & netMsg = *(const Srv2Cli_TTT_GameOver *)gameCliMsg->netMsg;
					switch (netMsg.result) {
						case kTTTGameResultWinner:
							if (netMsg.winnerId == NetCommGetPlayer()->playerInt)
								AddLineF(
									"[Game %s:%u] Game over. You won!",
									cli->GetName(),
									cli->GetGameId()
								);
							else
								AddLineF(
									"[Game %s:%u] Game over. You lost.",
									cli->GetName(),
									cli->GetGameId()
								);
						break;
						
						case kTTTGameResultTied:
							AddLineF(
								"[Game %s:%u] Game over. You tied.",
								cli->GetName(),
								cli->GetGameId()
							);
						break;
						
						case kTTTGameResultGave:
							AddLineF(
								"[Game %s:%u] Game over. You win by default.",
								cli->GetName(),
								cli->GetGameId()
							);
						break;
							
						default:
							AddLineF(
								"[Game %s:%u] Game over. Server-side error %u.",
								cli->GetName(),
								cli->GetGameId(),
								netMsg.result
							);
						break;
					}
				}
				return true;
				
				//============================================================
				// MoveMade
				case kSrv2Cli_TTT_MoveMade: {
					const Srv2Cli_TTT_MoveMade & netMsg = *(const Srv2Cli_TTT_MoveMade *)gameCliMsg->netMsg;
					const char * playerName
						= netMsg.playerId
							? plNetClientMgr::GetInstance()->GetPlayerNameById(netMsg.playerId)
							: "Computer";
					AddLineF(
						"[Game %s:%u] %s moved:",
						cli->GetName(),
						cli->GetGameId(),
						playerName
					);
					ttt->ShowBoard();
				}
				return true;
				
				DEFAULT_FATAL(gameCliMsg->netMsg->messageId);
			}
		}
		else {
			FATAL("Unknown game type");
		}
		
		return true;
	}
#endif // PLASMA_EXTERNAL_RELEASE
	//========================================================================
	
	return hsKeyedObject::MsgReceive(msg);
}

//// IHandleKey //////////////////////////////////////////////////////////////

void	pfConsole::IHandleKey( plKeyEventMsg *msg )
{
	char			*c, key;
	int				i,eol;
	static hsBool	findAgain = false;
	static UInt32	findCounter = 0;


	if( !msg->GetKeyDown() )
		return;

	if( msg->GetKeyCode() == KEY_ESCAPE )
	{
		fWorkingLine[ fWorkingCursor = 0 ] = 0;
		findAgain = false;
		findCounter = 0;
		fHelpMode = false;
		fPythonMode = false;
		fPythonMultiLines = 0;
		IUpdateTooltip();
	}
	else if( msg->GetKeyCode() == KEY_TAB )
	{
		if ( fPythonMode )
		{
			// if we are in Python mode, then just add two spaces, tab over, sorta
			if ( strlen(fWorkingLine) < kWorkingLineSize+2 )
			{
				strcat(&fWorkingLine[fWorkingCursor], "  ");
				fWorkingCursor += 2;
			}
		}
		else
		{
			static char		lastSearch[ kMaxCharsWide ];
			char			search[ kMaxCharsWide ];

			if( !findAgain && findCounter == 0 )
				strcpy( lastSearch, fWorkingLine );
			strcpy( search, lastSearch );

			if( findCounter > 0 )
			{
				// Not found the normal way; try using an unrestricted search
				if( fEngine->FindNestedPartialCmd( search, findCounter, true ) )
				{
					strcpy( fWorkingLine, search );
					findCounter++;
				}
				else
				{
					/// Try starting over...?
					findCounter = 0;
					if( fEngine->FindNestedPartialCmd( search, findCounter, true ) )
					{ 
						strcpy( fWorkingLine, search );
						findCounter++;
					}
				}
			}
			else if( fEngine->FindPartialCmd( search, findAgain, true ) )
			{
				strcpy( fWorkingLine, search );
				findAgain = true;
			}
			else if( findAgain )
			{
				/// Try starting over
				strcpy( search, lastSearch );
				if( fEngine->FindPartialCmd( search, findAgain = false, true ) )
				{
					strcpy( fWorkingLine, search );
					findAgain = true;
				}
			}

			else
			{
				// Not found the normal way; start an unrestricted search
				if( fEngine->FindNestedPartialCmd( search, findCounter, true ) )
				{
					strcpy( fWorkingLine, search );
					findCounter++;
				}
			}

			fWorkingCursor = strlen( fWorkingLine );
			IUpdateTooltip();
		}
	}
	else if( msg->GetKeyCode() == KEY_UP )
	{
		i = ( fHistoryRecallCursor > 0 ) ? fHistoryRecallCursor - 1 : kNumHistoryItems - 1;
		if( fHistory[ i ][ 0 ] != 0 )
		{
			fHistoryRecallCursor = i;
			strcpy( fWorkingLine, fHistory[ fHistoryRecallCursor ] );
			findAgain = false;
			findCounter = 0;
			fWorkingCursor = strlen( fWorkingLine );
			IUpdateTooltip();
		}
	}
	else if( msg->GetKeyCode() == KEY_DOWN )
	{
		if( fHistoryRecallCursor != fHistoryCursor )
		{
			i = ( fHistoryRecallCursor < kNumHistoryItems - 1 ) ? fHistoryRecallCursor + 1 : 0;
			if( i != fHistoryCursor )
			{
				fHistoryRecallCursor = i;
				strcpy( fWorkingLine, fHistory[ fHistoryRecallCursor ] );
			}
			else
			{
				memset( fWorkingLine, 0, sizeof( fWorkingLine ) );
				fHistoryRecallCursor = fHistoryCursor;
			}
			findAgain = false;
			findCounter = 0;
			fWorkingCursor = strlen( fWorkingLine );
			IUpdateTooltip();
		}
	}
	else if( msg->GetKeyCode() == KEY_LEFT )
	{
		if( fWorkingCursor > 0 )
			fWorkingCursor--;
	}
	else if( msg->GetKeyCode() == KEY_RIGHT )
	{
		if( fWorkingCursor < strlen( fWorkingLine ) )
			fWorkingCursor++;
	}
	else if( msg->GetKeyCode() == KEY_BACKSPACE )
	{
		if( fWorkingCursor > 0 )
		{
			fWorkingCursor--;

			c = &fWorkingLine[ fWorkingCursor ];
			do
			{
				*c = *( c + 1 );
				c++;
			} while( *c != 0 );

			findAgain = false;
			findCounter = 0;
		}
		else if( fHelpMode )
			fHelpMode = false;

		IUpdateTooltip();
	}
	else if( msg->GetKeyCode() == KEY_DELETE )
	{
		c = &fWorkingLine[ fWorkingCursor ];
		do
		{
			*c = *( c + 1 );
			c++;
		} while( *c != 0 );

		findAgain = false;
		findCounter = 0;
		IUpdateTooltip();
	}
	else if( msg->GetKeyCode() == KEY_ENTER )
	{
		// leave leading space for Python multi lines (need the indents!)
		if ( fPythonMultiLines == 0 )
		{
			// Clean up working line by removing any leading whitespace
			for( c = fWorkingLine; *c == ' ' || *c == '\t'; c++ );
			for( i = 0; *c != 0; i++, c++ )
				fWorkingLine[ i ] = *c;
			fWorkingLine[ i ] = 0;
			eol = i;
		}

		if( fWorkingLine[ 0 ] == 0 && !fHelpMode && !fPythonMode )
		{
			// Blank line--just print a blank line to the console and skip
			IAddLine( "" );
			return;
		}

		// only save history line if there is something there
		if( fWorkingLine[ 0 ] != 0 )
		{
			// Save to history
			strcpy( fHistory[ fHistoryCursor ], fWorkingLine );
			fHistoryCursor = ( fHistoryCursor < kNumHistoryItems - 1 ) ? fHistoryCursor + 1 : 0;
			fHistoryRecallCursor = fHistoryCursor;
		}

		// EXECUTE!!! (warning: DESTROYS fWorkingLine)
		if( fHelpMode )
		{
			if( fWorkingLine[ 0 ] == 0 )
				IPrintSomeHelp();
			else if( stricmp( fWorkingLine, "commands" ) == 0 )
				fEngine->PrintCmdHelp( "", IAddLineCallback );
			else if( !fEngine->PrintCmdHelp( fWorkingLine, IAddLineCallback ) )
			{
				c = (char *)fEngine->GetErrorMsg();
				AddLine( c );
			}

			fHelpMode = false;
		}
		// are we in Python mode?
		else if ( fPythonMode )
		{
			// are we in Python multi-line mode?
			if ( fPythonMultiLines > 0 )
			{
				// if there was a line then bump num lines
				if ( fWorkingLine[0] != 0 )
				{
					char displine[300];
					sprintf(displine,"... %s",fWorkingLine);
					AddLine( displine );
					fPythonMultiLines++;
				}

				// is it time to evaluate all the multi lines that are saved?
				if ( fWorkingLine[0] == 0 || fPythonMultiLines >= kNumHistoryItems )
				{
					if ( fPythonMultiLines >= kNumHistoryItems )
						AddLine("Python Multi-line buffer full!");
					// get the lines and stuff them in our buffer
					char biglines[kNumHistoryItems*(kMaxCharsWide+1)];
					biglines[0] = 0;
					for ( i=fPythonMultiLines; i>0 ; i--)
					{
						// reach back in the history and find this line and paste it in here
						int recall = fHistoryCursor - i;
						if ( recall < 0 )
							recall += kNumHistoryItems;
						strcat(biglines,fHistory[ recall ]);
						strcat(biglines,"\n");
					}
					// now evaluate this mess they made
					PyObject* mymod = PythonInterface::FindModule("__main__");
					PythonInterface::RunStringInteractive(biglines,mymod);
					std::string output;
					// get the messages
					PythonInterface::getOutputAndReset(&output);
					AddLine( output.c_str() );
					// all done doing multi lines...
					fPythonMultiLines = 0;
				}
			}
			// else we are just doing single lines
			else
			{
				// was there actually anything in the input buffer?
				if ( fWorkingLine[0] != 0 )
				{
					char displine[300];
					sprintf(displine,">>> %s",fWorkingLine);
					AddLine( displine );
					// check to see if this is going to be a multi line mode ( a ':' at the end)
					if ( fWorkingLine[eol-1] == ':' )
					{
						fPythonMultiLines = 1;
					}
					else
					// else if not the start of a multi-line then execute it
					{
						PyObject* mymod = PythonInterface::FindModule("__main__");
						PythonInterface::RunStringInteractive(fWorkingLine,mymod);
						std::string output;
						// get the messages
						PythonInterface::getOutputAndReset(&output);
						AddLine( output.c_str() );
					}
				}
				else
					AddLine( ">>> " );
			}
			// find the end of the line
			for( c = fWorkingLine, eol = 0; *c != 0; eol++, c++ );
		}
		else
		{
			if( !fEngine->RunCommand( fWorkingLine, IAddLineCallback ) )
			{
				c = (char *)fEngine->GetErrorMsg();
				if( c[ 0 ] != 0 )
					AddLine( c );
			}
		}

		// Clear
		fWorkingLine[ fWorkingCursor = 0 ] = 0;
		findAgain = false;
		findCounter = 0;
		IUpdateTooltip();
	}
	else if( msg->GetKeyCode() == KEY_END )
	{
		fWorkingCursor = strlen( fWorkingLine );
	}
	else if( msg->GetKeyCode() == KEY_HOME )
	{
		fWorkingCursor = 0;
	}
	else 
	{
		key = plKeyboardDevice::KeyEventToChar( msg );
		// do they want to go into help mode?
		if( !fPythonMode && key == '?' && fWorkingCursor == 0 )
		{
			/// Go into help mode
			fHelpMode = true;
		}
		// do they want to go into Python mode?
		else if( !fHelpMode && key == '\\' && fWorkingCursor == 0 )
		{
			// toggle Python mode
			fPythonMode = fPythonMode ? false:true;
			if ( fPythonMode )
			{
				if ( fPythonFirstTime )
				{
					IAddLine( "" );		// add a blank line
					PyObject* mymod = PythonInterface::FindModule("__main__");
					PythonInterface::RunStringInteractive("import sys;print 'Python',sys.version",mymod);
					std::string output;
					// get the messages
					PythonInterface::getOutputAndReset(&output);
					AddLine( output.c_str() );
					fPythonFirstTime = false;		// do this only once!
				}
			}
		}
		// or are they just typing in a working line
		else if( fWorkingCursor < kMaxCharsWide - 2 && key != 0 )
		{
			for( i = strlen( fWorkingLine ) + 1; i > fWorkingCursor; i-- )
				fWorkingLine[ i ] = fWorkingLine[ i - 1 ];

			fWorkingLine[ fWorkingCursor++ ] = key;

			findAgain = false;
			findCounter = 0;
			IUpdateTooltip();
		}
	}
}

//// IAddLineCallback ////////////////////////////////////////////////////////

void	pfConsole::IAddLineCallback( const char *string )
{
	fTheConsole->IAddParagraph( string, 0 );
}

//// IAddLine ////////////////////////////////////////////////////////////////

void	pfConsole::IAddLine( const char *string, short leftMargin )
{
	int			i;
	char		*ptr;


	/// Advance upward
	for( i = 0, ptr = fDisplayBuffer; i < fNumDisplayLines - 1; i++ )
	{
		memcpy( ptr, ptr + kMaxCharsWide, kMaxCharsWide );
		ptr += kMaxCharsWide;
	}

	if( string[ 0 ] == '\t' )
	{
		leftMargin += 4;
		string++;
	}

	memset( ptr, 0, kMaxCharsWide );
	memset( ptr, ' ', leftMargin );
	strncpy( ptr + leftMargin, string, kMaxCharsWide - leftMargin - 1 );
	if( fMode == 0 )
	{
		/// Console is invisible, so show this line for a bit of time
		fMsgTimeoutTimer = kMsgHintTimeout;
	}
}

//// IAddParagraph ///////////////////////////////////////////////////////////

void	pfConsole::IAddParagraph( const char *s, short margin )
{
	char		*ptr, *ptr2, *ptr3, *string=(char*)s;


	// Special character: if \i is in front of the string, indent it
	while( strncmp( string, "\\i", 2 ) == 0 )
	{
		margin += 3;
		string += 2;
	}

	for( ptr = string; ptr != nil && *ptr != 0; )
	{
		// Go as far as possible
		if( strlen( ptr ) < kMaxCharsWide - margin - margin - 1 )
			ptr2 = ptr + strlen( ptr );
		else
		{
			// Back up until we hit a sep
			ptr2 = ptr + kMaxCharsWide - margin - margin - 1;
			for( ; ptr2 > string && *ptr2 != ' ' && *ptr2 != '\t' && *ptr2 != '\n'; ptr2-- );
		}

		// Check for carriage return
		ptr3 = strchr( ptr, '\n' );
		if( ptr3 == ptr )
		{
			IAddLine( "", margin );
			ptr++;
			continue;
		}
		if( ptr3 != nil && ptr3 < ptr2 )
			ptr2 = ptr3;

		// Add this part
		if( ptr2 == ptr || *ptr2 == 0 )
		{
			IAddLine( ptr, margin );
			break;
		}

		*ptr2 = 0;
		IAddLine( ptr, margin );
		ptr = ptr2 + 1;
	}
}

//// IClear //////////////////////////////////////////////////////////////////

void	pfConsole::IClear( void )
{
	memset( fDisplayBuffer, 0, kMaxCharsWide * fNumDisplayLines );
}

//// Draw ////////////////////////////////////////////////////////////////////

void	pfConsole::Draw( plPipeline *p )
{
	int			i, yOff, y, x, eOffset, height;
	char		*line;
	char		tmp[ kMaxCharsWide ];
	hsBool		showTooltip = false;
	float		thisTime;	// For making the console FX speed konstant regardless of framerate
	const float	kEffectDuration = 0.5f;


	plDebugText&	drawText = plDebugText::Instance();
	
	thisTime = (float)hsTimer::PrecTicksToSecs( hsTimer::GetPrecTickCount() );

	if( fMode == kModeHidden && fEffectCounter == 0 )
	{
		if( fMsgTimeoutTimer > 0 )
		{
			/// Message hint--draw the last line of the console for a bit
			drawText.DrawString( 10, 4, fDisplayBuffer + kMaxCharsWide * ( fNumDisplayLines - 1 ), fConsoleTextColor );
			fMsgTimeoutTimer--;
		}
		fLastTime = thisTime;
		return;
	}

	drawText.SetDrawOnTopMode( true );

	yOff = drawText.GetFontHeight() + 2;
	if( fMode == kModeSingleLine )
		height = yOff * 3 + 14;
	else
		height = yOff * ( fNumDisplayLines + 2 ) + 14;

	if( fHelpTimer == 0 && !fHelpMode && fLastHelpMsg[ 0 ] != 0 )
		showTooltip = true;
	
	if( fEffectCounter > 0 )
	{
		int	numElapsed = (int)( (float)kEffectDivisions * ( ( thisTime - fLastTime ) / (float)kEffectDuration ) );
		if( numElapsed > fEffectCounter )
			numElapsed = fEffectCounter;
		else if( numElapsed < 0 )
			numElapsed = 0;

		if( fMode == kModeSingleLine )
			eOffset = fEffectCounter * height / kEffectDivisions;
		else if( fMode == kModeFull )
			eOffset = fEffectCounter * ( height - yOff * 3 - 14 ) / kEffectDivisions;
		else
			eOffset = ( kEffectDivisions - fEffectCounter ) * ( height - yOff * 3 - 14 ) / kEffectDivisions;
		fEffectCounter -= numElapsed;
	}
	else 
		eOffset = 0;
	fLastTime = thisTime;

	if( fMode == kModeSingleLine )
	{
		// Bgnd (TEMP ONLY)
		x = kMaxCharsWide * drawText.CalcStringWidth( "W" ) + 4;
		y = height - eOffset;
		drawText.DrawRect( 4, 0, x, y, /*color*/0, 0, 0, 127 );

		/// Actual text
		if( fEffectCounter == 0 )
			drawText.DrawString( 10, 4, "Plasma 2.0 Console", 255, 255, 255, 255 );

		if( !showTooltip )
			drawText.DrawString( 10, 4 + yOff - eOffset, fDisplayBuffer + kMaxCharsWide * ( fNumDisplayLines - 1 ), fConsoleTextColor );

		y = 4 + yOff + yOff - eOffset;
	}
	else
	{
		// Bgnd (TEMP ONLY)
		x = kMaxCharsWide * drawText.CalcStringWidth( "W" ) + 4;
		y = yOff * ( fNumDisplayLines + 2 ) + 14 - eOffset;
		drawText.DrawRect( 4, 0, x, y, /*color*/0, 0, 0, 127 );

		/// Actual text
		drawText.DrawString( 10, 4, "Plasma 2.0 Console", 255, 255, 255, 255 );

		static int	countDown = 3000;
		if( fHelpTimer > 0 || fEffectCounter > 0 || fMode != kModeFull )
			countDown = 3000;
		else if( countDown > -720 )
			countDown--;

		// Resource data is encrypted so testers can't peer in to the EXE, plz don't decrypt
		static bool rezLoaded = false;
		static char tmpSrc[ kMaxCharsWide ];
		if( !rezLoaded )
		{
			memset( tmp, 0, sizeof( tmp ) );
			memset( tmpSrc, 0, sizeof( tmpSrc ) );
			// Our concession to windows
#ifdef HS_BUILD_FOR_WIN32
			#include "../../Apps/plClient/res/resource.h"
			HRSRC rsrc = FindResource( nil, MAKEINTRESOURCE( IDR_CNSL1 ), "CNSL" );
			if( rsrc != nil )
			{
				HGLOBAL hdl = LoadResource( nil, rsrc );
				if( hdl != nil )
				{
					UInt8 *ptr = (UInt8 *)LockResource( hdl );
					if( ptr != nil )
					{
						for( i = 0; i < SizeofResource( nil, rsrc ); i++ )
							tmpSrc[ i ] = ptr[ i ] + 26;
						UnlockResource( hdl );
					}
				}
			}
			rezLoaded = true;
#else
			// Need to define for other platforms?
#endif
		}
		memcpy( tmp, tmpSrc, sizeof( tmp ) );

		if( countDown <= 0 )
		{
			y = 4 + yOff - eOffset;
			if( countDown <= -480 )
			{
				tmp[ ( (-countDown - 480)>> 4 ) + 1 ] = 0;
				drawText.DrawString( 10, y, tmp, fConsoleTextColor );
			}
			y += yOff * ( fNumDisplayLines - ( showTooltip ? 1 : 0 ) );
		}
		else
		{
			for( i = 0, y = 4 + yOff - eOffset, line = fDisplayBuffer; i < fNumDisplayLines - ( showTooltip ? 1 : 0 ); i++ )
			{
				drawText.DrawString( 10, y, line, fConsoleTextColor );
				y += yOff;
				line += kMaxCharsWide;
			}
		}

		if( showTooltip )
			y += yOff;
	}

//	strcpy( tmp, fHelpMode ? "Get Help On:" : "]" );
	if ( fHelpMode )
		strcpy( tmp, "Get Help On:");
	else if (fPythonMode )
		if ( fPythonMultiLines == 0 )
			strcpy( tmp, ">>>");
		else
			strcpy( tmp, "...");
	else
		strcpy( tmp, "]" );

	drawText.DrawString( 10, y, tmp, 255, 255, 255, 255 );
	i = 10 + drawText.CalcStringWidth( tmp ) + 4;
	drawText.DrawString( i, y, fWorkingLine, fConsoleTextColor );

	if( fCursorTicks >= 0 )
	{
		strcpy( tmp, fWorkingLine );
		tmp[ fWorkingCursor ] = 0;
		x = drawText.CalcStringWidth( tmp );
		drawText.DrawString( i + x, y + 2, "_", 255, 255, 255 );
	}
	fCursorTicks--;
	if( fCursorTicks < -kCursorBlinkRate )
		fCursorTicks = kCursorBlinkRate;

	if( showTooltip )
		drawText.DrawString( i, y - yOff, fLastHelpMsg, 255, 255, 0 );
	else
		fHelpTimer--;

	drawText.SetDrawOnTopMode( false );
}

//// IUpdateTooltip //////////////////////////////////////////////////////////

void	pfConsole::IUpdateTooltip( void )
{
	char	tmpStr[ kWorkingLineSize ];
	char	*c;


	strcpy( tmpStr, fWorkingLine );
	c = (char *)fEngine->GetCmdSignature( tmpStr );
	if( c == nil || strcmp( c, fLastHelpMsg ) != 0 )
	{
		/// Different--update timer to wait
		fHelpTimer = kHelpDelay;
		strncpy( fLastHelpMsg, c ? c : "", kMaxCharsWide - 2 );
	}
}

//// IPrintSomeHelp //////////////////////////////////////////////////////////

void	pfConsole::IPrintSomeHelp( void )
{
	char	msg1[] = "The console contains commands arranged under groups and subgroups. \
To use a command, you type the group name plus the command, such as 'Console.Clear' or \
'Console Clear'.";
	
	char	msg2[] = "To get help on a command or group, type '?' followed by the command or \
group name. Typing '?' and just hitting enter will bring up this message. Typing '?' and \
then 'commands' will bring up a list of all base groups and commands.";

	char	msg3[] = "You can also have the console auto-complete a command by pressing tab. \
This will search for a group or command that starts with what you have typed. If there is more \
than one match, pressing tab repeatedly will cycle through all the matches.";


	AddLine( "" );
	AddLine( "How to use the console:" );
	IAddParagraph( msg1, 2 );
	AddLine( "" );
	IAddParagraph( msg2, 2 );
	AddLine( "" );
	IAddParagraph( msg3, 2 );
	AddLine( "" );
}


//============================================================================
void pfConsole::AddLineF(const char * fmt, ...) {
	char str[1024];
	va_list args;
	va_start(args, fmt);
	_vsnprintf(str, arrsize(str), fmt, args);
	va_end(args);
	AddLine(str);
}

//============================================================================
void pfConsole::RunCommandAsync (const char cmd[]) {

	plConsoleMsg * consoleMsg = NEWZERO(plConsoleMsg);
	consoleMsg->SetCmd(plConsoleMsg::kExecuteLine);
	consoleMsg->SetString(cmd);
//	consoleMsg->SetBreakBeforeDispatch(true);
	consoleMsg->Send(nil, true);
}