s0beit

#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;
    }
}