View difference between Paste ID: 6y1HdXy5 and

-
+#include "CustomFiberThread.h"
 #include "Scripting.h"
 #include "../ScriptHook/Log.h"
 
 #include <windows.h>
 #include <stdio.h>
 
 using namespace Scripting;
 
 // ASSEMBLY FUNCTIONS, MAYBE CAN NOT BE A CLASS FUNCTION
 
 __declspec( noinline ) u32 GTA4_GetHandleFromPed( CPool< void* >* pPool, void *Ped )
 {
 	_asm mov	ecx, pPool;
 	_asm mov	eax, Ped;
 	_asm sub	eax, [ecx];
 	_asm cdq;
 	_asm idiv	dword ptr [ecx+12];
 	_asm mov	edx, eax;
 	_asm mov	eax, [ecx+4];
 	_asm movzx	eax, byte ptr [eax+edx];
 	_asm shl	edx, 8;
 	_asm add	eax, edx;
 }
 
 // ASSEMBLY FUNCTIONS, MAYBE CAN NOT BE A CLASS FUNCTION
 
 RiotThread::RiotThread()
 {
 	SetName( "RiotIV_050" );
 }
 
 CPool< void* >* RiotThread::GetPedPoolNative()
 {
 //	HACKHACK: Static address for GTAIV 1.0.6.0; DEPRECIATED!!!
 //	return reinterpret_cast< CPool< void* >* >( *reinterpret_cast< DWORD* >( Game::GetBase() + 0x18A72BC ) );
 
 	return reinterpret_cast< CPool< void* >* >( *reinterpret_cast< DWORD* >( m_ulPedPoolBase ) );
 }
 
 u32 RiotThread::GetPedCount()
 {
 	if( GetPedPoolNative() == NULL ) return 0;
 
 	return GetPedPoolNative()->Count();
 }
 
 b8 RiotThread::GetPedByIndex( int idx, Ped *Out )
 {
 	if( !Out )
 		return false;
 
 	Out->Set( 0 );
 
 	if( GetPedCount() == 0 )
 		return false;
 
 	void *CurrentPedIdx = GetPedPoolNative()->at( idx );
 
 	if( CurrentPedIdx == NULL )
 		return false;
 
 	Out->Set( GTA4_GetHandleFromPed( GetPedPoolNative(), CurrentPedIdx ) );
 
 	return ( Out->IsValid() && DoesCharExist( *Out ) );
 }
 
 Scripting::Vector3 RiotThread::GetPedVector( Scripting::Ped *In )
 {
 	Vector3 Ret(0,0,0);
 	Scripting::GetCharCoordinates( *In, &Ret.X, &Ret.Y, &Ret.Z );
 	return Ret;
 }
 
 Player RiotThread::GetPlayer()
 {
 	Player playerIndex = ConvertIntToPlayerIndex(GetPlayerId());
 	return playerIndex;
 }
 
 Scripting::Ped RiotThread::GetPlayerPed()
 {
 	Ped ped;
 	GetPlayerChar( GetPlayer(), &ped );
 	return ped;
 }
 
 Scripting::eWeapon RiotThread::GetRandomWeapon()
 {
 	srand( GetTickCount() );
 
 	return static_cast< eWeapon >( m_UsableWeaponry[ rand() % m_UsableWeaponry.size() ] );
 }
 
 b8 RiotThread::IsPedPolice( Scripting::Ped ped )
 {
 	eModel CurrentModel;
 
 	Scripting::GetCharModel( ped, &CurrentModel );
 
 	return (
 		( CurrentModel == MODEL_M_Y_COP )			||
 		( CurrentModel == MODEL_M_Y_COP_TRAFFIC )	||
 		( CurrentModel == MODEL_M_M_FATCOP_01 )		||
 		( CurrentModel == MODEL_CS_MITCHCOP )		||
 		( CurrentModel == MODEL_M_Y_SWAT )			||
 		( CurrentModel == MODEL_M_M_FBI )			||
 		( CurrentModel == MODEL_M_Y_STROOPER ) );
 }
 
 b8 RiotThread::ShouldRiot( Scripting::Ped ped )
 {
 	if( m_DontRiotHashes.empty() )
 	{
 		return true;
 	}
 
 	for( size_t i = 0; i < m_DontRiotHashes.size(); i++ )
 	{
 		if( IsCharModel( ped, static_cast< Scripting::eModel >( m_DontRiotHashes[ i ] ) ) )
 		{
 			return false;
 		}
 	}
 
 	return true;
 }
 
 b8 RiotThread::IsPedAllowedToRiot( Scripting::Ped ped )
 {
 	if( m_RiotHashes.empty() )
 		return true;
 
 	for( size_t i = 0; i < m_RiotHashes.size(); i++ )
 	{
 		if( IsCharModel( ped, static_cast< Scripting::eModel >( m_RiotHashes[ i ] ) ) )
 		{
 			return true;
 		}
 	}
 
 	return false;
 }
 
 b8 RiotThread::CausePedToRiot( Scripting::Ped LocalPed, Scripting::Ped RiotPed )
 {
 	// Check if ped exists
 	if( DoesCharExist( RiotPed ) == false )
 	{
 		return false;
 	}
 
 	// Check the model for status
 	if( ShouldRiot( RiotPed ) == false || IsPedAllowedToRiot( RiotPed ) == false )
 	{
 		if( IsPedAMissionPed( RiotPed ) )
 		{
 			MarkCharAsNoLongerNeeded( &RiotPed );
 		}
 
 		return false;
 	}
 
 	// If not "visible", delete them, not needed
 	if( IsCharVisible( RiotPed ) == false )
 	{
 		if( IsPedAMissionPed( RiotPed ) )
 		{
 			MarkCharAsNoLongerNeeded( &RiotPed );
 
 			DeleteChar( &RiotPed );
 		}
 
 		return false;
 	}
 
 	// If dead, fatally injured
 	// if mission ped, unmark, stop
 	if( IsCharDead( RiotPed ) || IsCharFatallyInjured( RiotPed ) )
 	{
 		if( IsPedAMissionPed( RiotPed ) )
 		{
 			MarkCharAsNoLongerNeeded( &RiotPed );
 		}
 
 		return false;
 	}
 
 	// If cops rioting is disabled and ped is police, stop
 
 	if( m_bCopsGoCrazy == false && IsPedPolice( RiotPed ) )
 	{
 		if( IsPedAMissionPed( RiotPed ) )
 		{
 			MarkCharAsNoLongerNeeded( &RiotPed );
 		}
 
 		return false;
 	}
 
 	// If usable weaponry is available
 	if( m_UsableWeaponry.size() > 0 )
 	{
 		//if NOT police (already have weapons)
 		if( IsPedPolice( RiotPed ) == false )
 		{
 			//if have a gun already, and not police, stop
 			if( Scripting::IsCharArmed( RiotPed, WEAPON_SLOT_MELEE )
 					|| Scripting::IsCharArmed( RiotPed, WEAPON_SLOT_HANDGUN )
 					|| Scripting::IsCharArmed( RiotPed, WEAPON_SLOT_HEAVY )
 					|| Scripting::IsCharArmed( RiotPed, WEAPON_SLOT_RIFLE )
 					|| Scripting::IsCharArmed( RiotPed, WEAPON_SLOT_SHOTGUN )
 					|| Scripting::IsCharArmed( RiotPed, WEAPON_SLOT_SMG )
 					|| Scripting::IsCharArmed( RiotPed, WEAPON_SLOT_SNIPER )
 					|| Scripting::IsCharArmed( RiotPed, WEAPON_SLOT_THROWN ) )
 			{
 				return false;
 			}
 		}
 	}
 
 	// Range checking to avoid crashes
 	Scripting::Vector3 LocalVec = GetPedVector( &LocalPed );
 	Scripting::Vector3 PedVec	= GetPedVector( &RiotPed );
 
 	if( PedVec.Distance( &LocalVec ) > m_fMaximumRange )
 	{
 		// HACKHACK: If outside of maximum range mark as no longer needed...
 
 		if( IsPedAMissionPed( RiotPed ) )
 		{
 			MarkCharAsNoLongerNeeded( &RiotPed );
 		}
 
 		return false;
 	}
 
 	if( IsPedAMissionPed( RiotPed ) == false )
 	{
 		// Setup violent tendencies
 
 		SetCharAsMissionChar( RiotPed );
 
 		SetCharAsEnemy( RiotPed, m_bTargetPlayer );
 
 		SetPedDiesWhenInjured( RiotPed, true );
 
 		AllowTargetWhenInjured( RiotPed, true );
 
 		SetCharWillMoveWhenInjured( RiotPed, true );
 
 		SetCharWillDoDrivebys( RiotPed, true );
 
 		SetCharWillUseCarsInCombat( RiotPed, m_bPedsUseCars );
 
 		SetPedWontAttackPlayerWithoutWantedLevel( RiotPed, 0 );
 
 		SetSenseRange( RiotPed, m_fMaximumRange );
 
 		SetCharAccuracy( RiotPed, 100 );
 
 		if( IsPedPolice( RiotPed ) == false )
 		{
 			SetCharWantedByPolice( RiotPed, m_bPedsWanted );
 
 			SetCharRelationshipGroup( RiotPed, 8 );
 
 			// If weaponry available, give random weapon
 
 			if( m_UsableWeaponry.size() > 0 )
 			{
 				eWeapon RandomWeapon = GetRandomWeapon();
 
 				GiveWeaponToChar( RiotPed, RandomWeapon, ( RandomWeapon > 3 ) ? 9999 : 0, 0 );
 
 				SetCurrentCharWeapon( RiotPed, RandomWeapon, true );
 
 				BlockPedWeaponSwitching( RiotPed, true );
 			}
 			else
 			{
 				// Melee if no weapons are set
 
 				RemoveAllCharWeapons( RiotPed );
 			}
 		}
 
 		// Set attacking task
 
 		TaskCombatHatedTargetsAroundChar( RiotPed, m_fMaximumRange );
 
 		SetCharKeepTask( RiotPed, true );
 	}
 
 	return true;
 }
 
 void RiotThread::SpawnNewRioter( Ped LocalPed, Vector3 SpawnVector )
 {
 	Scripting::PrintStringWithLiteralStringNow( "STRING", "Spawning new riot ped", 3000, true );
 
 	srand( GetTickCount() );
 
 	eModel ModelSpawn = static_cast< eModel >( m_SpawnHashes[ rand() % m_SpawnHashes.size() ] );
 
 	RequestModel( ModelSpawn );
 
 	while( HasModelLoaded( ModelSpawn ) == false )
 	{
 		Wait(10);
 	}
 
 	Ped OutPed;
 
 	CreateChar( 2, ModelSpawn, SpawnVector.X, SpawnVector.Y, SpawnVector.Z, &OutPed, true );
 
 	if( OutPed.IsValid() )
 	{
 		while( DoesCharExist( OutPed ) == false )
 		{
 			Wait(10);
 		}
 
 		while( IsCharVisible( OutPed ) == false )
 		{
 			Wait(10);
 		}
 
 		SetCharHealth( OutPed, 200 );
 
 		MarkCharAsNoLongerNeeded( &OutPed );
 	}
 }
 
 void RiotThread::SetupRelationships()
 {
 	SetRelationship( 5, 8, 8 ); // Rioters hate themselves
 	SetRelationship( 5, 8, 3 );	// Rioters hate police
 
 	SetPlayerCanBeHassledByGangs( GetPlayer(), m_bTargetPlayer );
 
 	if( m_bTargetPlayer )
 	{
 		SetRelationship( 5, 8, 0 ); // Rioters hate player (you)
 		SetRelationship( 5, 0, 8 ); // Player hate rioters
 
 		if( m_bCopsGoCrazy )
 		{
 			SetRelationship( 5, 0, 3 ); //Cops hate player (you)
 		}
 	}
 	else
 	{
 		SetRelationship( 1, 8, 0 ); // Rioters ignore player (you)
 		SetRelationship( 1, 0, 8 ); // Player ignore rioters
 	}
 
 	if( m_bCopsGoCrazy )
 	{
 		SetRelationship( 5, 3, 8 ); // Cops hate rioters
 	}
 }
 
 std::vector< int > RiotThread::StringToIntList( const char *str )
 {
 	std::vector< int > ReturnVector;
 
 	if( str == NULL )
 	{
 		ReturnVector.clear();
 
 		return ReturnVector;
 	}
 
 	//
 
 	char *pch = strtok( const_cast< char* >( str ), "," );
 
 	if( pch == NULL )
 	{
 		ReturnVector.push_back( atoi( str ) );
 	}
 	else
 	{
 		while( pch )
 		{
 			ReturnVector.push_back( atoi( pch ) );
 
 			pch = strtok( 0, "," );
 		}
 	}
 
 	return ReturnVector;
 }
 
 void RiotThread::SetupSettingsFile()
 {
 	Log::Debug( "Loading Settings..." );
 
 	m_pConfigService = ScriptHookManager::RequestService< IConfigService >( "Config" );
 
 	if( m_pConfigService )
 	{
 		IConfig* Configuration = m_pConfigService->Create( IConfigService::ConfigTypeXml );
 
 		if( Configuration == NULL )
 			return;
 
 		Configuration->Set( "RiotIV", "Enabled", "1" );
 		Configuration->Set( "RiotIV", "TargetPlayer", "0" );
 		Configuration->Set( "RiotIV", "CrazyCops", "1" );
 		Configuration->Set( "RiotIV", "PedsUseCars", "1" );
 		Configuration->Set( "RiotIV", "PedsWanted", "1" );
 		Configuration->Set( "RiotIV", "MadDrivers", "1" );
 		Configuration->Set( "RiotIV", "EmergencyServicesDisabled", "1" );
 		Configuration->Set( "RiotIV", "PedMultiplierEnforce", "NONE" );
 		Configuration->Set( "RiotIV", "UsableWeaponry", "4,5,7,9,10,11,12,13,14,15,16,17,18" );
 		Configuration->Set( "RiotIV", "DontRiotHashes", "" );
 		Configuration->Set( "RiotIV", "SpawnHashes", "1794146792" );
 		Configuration->Set( "RiotIV", "RiotHashes", "ANY" );
 		Configuration->Set( "RiotIV", "MaximumRange", "100.0" );
 
 		char *pszModulePath = GetModulePath();
 
 		if( pszModulePath == 0 || strlen( pszModulePath ) == 0 )
 			return;
 
 		Log::Debug( "Module Path [%s]", pszModulePath );
 
 		char pszConfigPath[ MAX_PATH ] = { 0 };
 
 		strcat_s( pszConfigPath, MAX_PATH, GetModulePath() );
 		strcat_s( pszConfigPath, MAX_PATH, "Riot.xml" );
 
 		Log::Debug( "Loading configuration from [%s]", pszConfigPath );
 
 		WIN32_FIND_DATAA wfd;
 
 		if ( FindFirstFileA( pszConfigPath, &wfd ) != INVALID_HANDLE_VALUE )
 		{
 			Configuration->Load( pszConfigPath );
 
 			// HACKHACK: Save after we load to ensure any new values are inserted into the file for future loading
 			Configuration->Save( pszConfigPath );
 		}
 		else
 		{
 			Configuration->Save( pszConfigPath );
 		}
 
 		m_bEnabled						= ( Configuration->GetInteger( "RiotIV", "Enabled", 1 ) == 1 );
 		m_bTargetPlayer 				= ( Configuration->GetInteger( "RiotIV", "TargetPlayer", 0 ) == 1 );
 		m_bCopsGoCrazy					= ( Configuration->GetInteger( "RiotIV", "CrazyCops", 0 ) == 1 );
 		m_bPedsUseCars					= ( Configuration->GetInteger( "RiotIV", "PedsUseCars", 1 ) == 1 );
 		m_bPedsWanted					= ( Configuration->GetInteger( "RiotIV", "PedsWanted", 0 ) == 1 );
 		m_bMadDrivers					= ( Configuration->GetInteger( "RiotIV", "MadDrivers", 0 ) == 1 );
 		m_bEmergencyServicesDisabled	= ( Configuration->GetInteger( "RiotIV", "EmergencyServicesDisabled", 0 ) == 1 );
 		m_fMaximumRange					= Configuration->GetFloat( "RiotIV", "MaximumRange", 100.f );
 
 		CONST CHAR* PedMultiEnforce		= Configuration->GetString( "RiotIV", "PedMultiplierEnforce" );
 		CONST CHAR* UsableWeapons		= Configuration->GetString( "RiotIV", "UsableWeaponry" );
 		CONST CHAR* DontRiotHashes		= Configuration->GetString( "RiotIV", "DontRiotHashes" );
 		CONST CHAR* RiotHashes			= Configuration->GetString( "RiotIV", "RiotHashes" );
 		CONST CHAR* SpawnHashes			= Configuration->GetString( "RiotIV", "SpawnHashes" );
 
 		m_UsableWeaponry				= StringToIntList( UsableWeapons );
 		m_DontRiotHashes				= StringToIntList( DontRiotHashes );
 		m_SpawnHashes					= StringToIntList( SpawnHashes );
 
 		if( _stricmp( PedMultiEnforce, "NONE" ) == 0 )
 		{
 			m_bForcePedMultiplier = false;
 		}
 		else
 		{
 			m_bForcePedMultiplier = true;
 
 			m_fPedMultiplier = static_cast< f32 >( atof( PedMultiEnforce ) );
 		}
 
 		if( _stricmp( RiotHashes, "ANY" ) == 0 )
 		{
 			m_RiotHashes.clear();
 		}
 		else
 		{
 			m_RiotHashes = StringToIntList( RiotHashes );
 		}
 
 		Configuration->Release();
 	}
 	else
 	{
 		Log::Debug( "Unable to load configuration service.." );
 	}
 }
 
 char* RiotThread::GetModulePath()
 {
 	static char pszPath[ MAX_PATH ] = { 0 };
 
 	if( strlen( pszPath ) > 0 )
 		return pszPath;
 
 	GetModuleFileNameA( m_hModule, pszPath, sizeof( pszPath ) );
 
     u32 i = strlen( pszPath );
 
     while( i > 0 && pszPath[i] != '\\' )
 	{
 		i--;
 	}
 
 	pszPath[i] = 0;
 
 	strcat_s( pszPath, MAX_PATH, "\\" );
 
 	return pszPath;
 }
 
 void RiotThread::UpdateCode()
 {
 	HMODULE hMainModule = GetModuleHandleW( NULL );
 
 	Log::Debug( "Finding signiture..[0x%X][0x%X]", hMainModule, Game::GetBase() );
 
 	m_ulPedPoolBase = Code::FindAddress::DetectPattern(
 		reinterpret_cast< unsigned long >( hMainModule ), 0xFFFFFF,
 		( BYTE* )"\x55\x8B\xEC\x83\xE4\xF0\x8B\x15\x00\x00\x00\x00\x81\xEC\xEC\x00\x00\x00",
 		( CHAR* )"xxxxxxxx????xxxxxx" );
 
 	if( m_ulPedPoolBase == NULL )
 	{
 		Log::Fatal( "PedPoolBase not found...critical error" );
 
 		ExitProcess(0);
 	}
 	else
 	{
 		Log::Debug( "PedPoolBase 001 [0x%X]", m_ulPedPoolBase );
 
 		m_ulPedPoolBase += 8;
 
 		Log::Debug( "PedPoolBase 002 [0x%X]", m_ulPedPoolBase );
 
 		m_ulPedPoolBase = *reinterpret_cast< unsigned long* >( m_ulPedPoolBase );
 
 		Log::Debug( "PedPoolBase FIN [0x%X]", m_ulPedPoolBase );
 
 		Log::Debug( "Address - Base = [0x%X]", m_ulPedPoolBase - reinterpret_cast< unsigned long >( hMainModule ) );
 	}
 }
 
 void RiotThread::RunScript()
 {
 	SetupSettingsFile();
 
 	CreateKeyboard();
 
 	CreateMenu();
 
 	while( IsThreadAlive() )
 	{
 		if( NetworkIsSessionStarted() == false )
 		{
 			Ped LocalPed = GetPlayerPed();
 
 			if( LocalPed.IsValid() == false )
 				continue;
 
 			Vector3 LocalVector = GetPedVector( &LocalPed );
 
 			if( m_bSpawnRandomPedNextFrame && m_SpawnHashes.size() )
 			{
 				SpawnNewRioter( LocalPed, Vector3( LocalVector.X + 2.f, LocalVector.Y, LocalVector.Z ) );
 
 				m_bSpawnRandomPedNextFrame = false;
 			}
 
 			if( m_bForcePedMultiplier )
 			{
 				SetPedDensityMultiplier( m_fPedMultiplier );
 			}
 
 			SwitchMadDrivers( m_bMadDrivers );
 
 			AllowEmergencyServices( !m_bEmergencyServicesDisabled );
 
 			SetPoliceIgnorePlayer( GetPlayer(), m_bEmergencyServicesDisabled );
 
 			if( m_bEmergencyServicesDisabled )
 			{
 				SetCharWantedByPolice( LocalPed, false );
 
 				ClearWantedLevel( GetPlayer() );
 
 				ClearAreaOfCops( LocalVector.X, LocalVector.Y, LocalVector.Z, m_fMaximumRange );
 			}
 
 			if( m_bEnabled )
 			{
 				AllowGangRelationshipsToBeChangedByNextCommand( true );
 
 				SetupRelationships();
 
 				for( u32 i = 0; i < GetPedCount(); i++ )
 				{
 					Ped Index;
 
 					Index.Set( 0 );
 
 					if( GetPedByIndex( i, &Index ) )
 					{
 						if( Index.IsNull() )
 							continue;
 
 						if( Index.Get() == LocalPed.Get() )
 							continue;
 
 						if( CausePedToRiot( LocalPed, Index ) == false )
 							continue;
 					}
 				}
 			}
 		}
 
 		Wait( 10 );
 	}
 }
 
 void RiotThread::OnStart()
 {
 	m_pMenu = NULL;
 }
 
 void RiotThread::OnKill()
 {
 	IKeyboardHookService *kbhService = ScriptHookManager::RequestService<IKeyboardHookService>( "KeyboardHook" );
 
 	kbhService->RemoveHandler( this );
 
 	if( m_pMenu )
 	{
 		m_pMenu->Release();
 		m_pMenu = NULL;
 	}
 
 	ScriptThread::OnKill();
 }
 
 void RiotThread::CreateKeyboard()
 {
 	IKeyboardHookService *kbhService = ScriptHookManager::RequestService<IKeyboardHookService>( "KeyboardHook" );
 
 	kbhService->AddHandler( this );
 }
 
 void RiotThread::CreateMenu()
 {
 	IMenuService *menuService = ScriptHookManager::RequestService< IMenuService >( "Menu" );
 
 	m_pMenu = menuService->CreateMenu();
 
 	m_pMenu->SetTitle( "Riot mode" );
 
 	AddMenuItemCustom( 0, m_bEnabled ? "Disable Riot Mode" : "Enable Riot Mode" );
 	AddMenuItemCustom( 1, m_bTargetPlayer ? "Disable peds targetting player" : "Enable peds targetting player" );
 	AddMenuItemCustom( 2, m_bCopsGoCrazy ? "Disable cops rioting" : "Enable cops rioting" );
 	AddMenuItemCustom( 3, m_bPedsUseCars ? "Disable peds use cars in combat" : "Enable peds use cars in combat" );
 	AddMenuItemCustom( 4, m_bPedsWanted ? "Disable peds wanted" : "Enable peds wanted" );
 	AddMenuItemCustom( 5, m_bMadDrivers ? "Disable mad drivers" : "Enable mad drives" );
 	AddMenuItemCustom( 6, m_bEmergencyServicesDisabled ? "Enable emergancy services" : "Disable emergancy services" );
 
 	m_pMenu->SetEventHandler( this );
 }
 
 void RiotThread::AddMenuItemCustom( int idx, char *pszFormat, ... )
 {
 	char FormattedBuffer[ 1024 ] = { 0 };
 
 	va_list va_alist;
 
 	va_start( va_alist, pszFormat );
 
 	_vsnprintf(
 		FormattedBuffer + strlen( FormattedBuffer ),
 		sizeof( FormattedBuffer ) - strlen( FormattedBuffer ),
 		pszFormat, va_alist );
 
 	va_end( va_alist );
 
 	m_pMenu->AddItem( idx, FormattedBuffer );
 }
 
 void RiotThread::SetMenuItemCustom( int idx, char *pszFormat, ... )
 {
 	char FormattedBuffer[ 1024 ] = { 0 };
 
 	va_list va_alist;
 
 	va_start( va_alist, pszFormat );
 
 	_vsnprintf(
 		FormattedBuffer + strlen( FormattedBuffer ),
 		sizeof( FormattedBuffer ) - strlen( FormattedBuffer ),
 		pszFormat, va_alist );
 
 	va_end( va_alist );
 
 	m_pMenu->SetItem( idx, FormattedBuffer );
 }
 
 void RiotThread::OnMenuSelectionChanged( IMenu *menu, u32 id )
 {
 	// None?
 }
 
 void RiotThread::OnMenuSelected( IMenu *menu, u32 id )
 {
 	switch( id )
 	{
 	case 0:
 		{
 			m_bEnabled = !m_bEnabled;
 
 			SetMenuItemCustom( 0, m_bEnabled ? "Disable Riot Mode" : "Enable Riot Mode" );
 
 			break;
 		}
 	case 1:
 		{
 			m_bTargetPlayer = !m_bTargetPlayer;
 
 			SetMenuItemCustom( 1, m_bTargetPlayer ? "Disable peds targetting player" : "Enable peds targetting player" );
 
 			break;
 		}
 	case 2:
 		{
 			m_bCopsGoCrazy = !m_bCopsGoCrazy;
 
 			SetMenuItemCustom( 2, m_bCopsGoCrazy ? "Disable cops rioting" : "Enable cops rioting" );
 
 			break;
 		}
 	case 3:
 		{
 			m_bPedsUseCars = !m_bPedsUseCars;
 
 			SetMenuItemCustom( 3, m_bPedsUseCars ? "Disable peds use cars in combat" : "Enable peds use cars in combat" );
 
 			break;
 		}
 	case 4:
 		{
 			m_bPedsWanted = !m_bPedsWanted;
 
 			SetMenuItemCustom( 4, m_bPedsWanted ? "Disable peds wanted" : "Enable peds wanted" );
 
 			break;
 		}
 	case 5:
 		{
 			m_bMadDrivers = !m_bMadDrivers;
 
 			SetMenuItemCustom( 5, m_bMadDrivers ? "Disable mad drivers" : "Enable mad drives" );
 
 			break;
 		}
 	case 6:
 		{
 			m_bEmergencyServicesDisabled = !m_bEmergencyServicesDisabled;
 
 			SetMenuItemCustom( 6, m_bEmergencyServicesDisabled ? "Enable emergancy services" : "Disable emergancy services" );
 
 			break;
 		}
 	}
 }
 
 void RiotThread::OnKeyboardHookEvent( const IKeyboardHookHandler::KeyEventArgs &args )
 {
 	if( args.VirtualKey == VK_INSERT && !args.WasKeyDownBefore )
 	{
 		if( m_pMenu )
 		{
 			m_pMenu->Show();
 		}
 	}
 
 	if( args.VirtualKey == VK_F3 && !args.WasKeyDownBefore )
 	{
 		m_bSpawnRandomPedNextFrame = true;
 	}
 }