CS:S External Base coded by Scribzz

/*
**********************************************************************
*  ___ ___ ___   ___     _                     _   ___               *
* / __/ __/ __| | __|_ _| |_ ___ _ _ _ _  __ _| | | _ ) __ _ ___ ___ *
*| (__\__ \__ \ | _|\ \ /  _/ -_) '_| ' \/ _` | | | _ \/ _` (_-</ -_)*
* \___|___/___/ |___/_\_\\__\___|_| |_||_\__,_|_| |___/\__,_/__/\___|*
*                                                                    *
**********************************************************************

*CS:S External Base coded by Scribzz*
*Credits : Sandaasu , Guidedhacking*

************Features************

*BunnyHop
*TriggerBot
*Burst-Fire
*Anti Recoil
*sv_cheat Bypass
*sv_pure Bypass
*sv_consistency Bypass
*Wireframe ESP
*Fullbright
*No Smoke
*No Flash
*No Hands
*No Sky
*Draw FPS
*Radar
*/
bool bSpotted = true;
bool bEnabled = true;
#include <windows.h>
#include <iostream>
#include <tlhelp32.h>
#include <tchar.h>
#include <cstdlib>
#include <stdio.h>
#include <direct.h>
#include <stdio.h>
#include <limits>
#include <fstream>
#include <conio.h>
#include <strsafe.h>
#define GetCurrentDir _getcwd
#define M5 0x06
#define space 0x20
#define xxx 0x7B
#define stand 257
#define aerial 256
#define c_jumping 260
#define c_jump 262
int cheats_off = 0;
int cheats_on = 1;
int pure_on = 0;
int pure_off = 1;
int consistency_on = 0;
int consistency_off = 1;
int wire_off = 1;
int wire_on = 2;
int bright_on = 1;
int bright_off = 2;
int no_smoke_on = 0;
int no_smoke_off = 1;
int no_hands_off = 0;
int no_hands_on = 1;
int no_sky_on = 0;
int no_sky_off = 1;
int draw_fps_off = 0;
int draw_fps_on = 1;
int maxplayers = 64;
int gDelay;
int sDelay;
int Time = 25;
int Delay = 17;
int BurstEnable = 0;
bool a = false;
bool b = false;
const DWORD m_bSpotted = 0x935;
const DWORD eBaseAddy = 0x5451BC;
const DWORD PBAddy = 0x538984;
const DWORD JumpOff = 0x00;
const DWORD teamOffs = 0x00;
const DWORD xHairOffs = 0x1478;
const DWORD LoopDistance = 0x10;
using std::numeric_limits;
using std::streamsize;
using std::cout;
using std::cin;
char trigEnable = 'n';
char _Nb;
float sd = 0.0f;
bool i = true;
int n = 0;

DWORD _c0d_3r_dwGetModuleBaseAddress(DWORD _xCt_0_dwProcessIdentifier, TCHAR *sym_lpszModuleName);
using namespace std;

int A_()
{
    DWORD pID;
    HANDLE hHandle;
    HWND hWnd;


    SetConsoleTitle( "External BASE by Scribzz" );
    hWnd = FindWindow(0, "Counter-Strike Source");
    GetWindowThreadProcessId( hWnd, &pID);
    hHandle = OpenProcess( PROCESS_ALL_ACCESS, 0, pID);

    if(hHandle)
    {
        if(!hWnd)
        {
        return 0;
        }
        else
        {
            system("cls");
            system("Color 8A");
            cout << "..... Game found ! :) " << "\n "<< endl;
            cout << "Loading features..." << "\n"<< endl;
            DWORD EngineDll;
            EngineDll = _c0d_3r_dwGetModuleBaseAddress( pID, "engine.dll");
            DWORD ClientDll;
            ClientDll = _c0d_3r_dwGetModuleBaseAddress( pID, "client.dll");
            DWORD materialsystemDll;
            materialsystemDll = _c0d_3r_dwGetModuleBaseAddress( pID, "materialsystem.dll");

    if (GetAsyncKeyState(VK_F1) && a == false)
     {
            WriteProcessMemory( hHandle, (LPVOID)( EngineDll + 0x674B98), &cheats_on, sizeof(int), NULL);
            cout << "sv_Cheats bypass =  ON! " << "\n" << endl;
            Sleep(1000);
     }
    if (GetAsyncKeyState(VK_F1) && a == true)
     {
        WriteProcessMemory( hHandle, (LPVOID)( EngineDll + 0x674B98), &cheats_off, sizeof(int), NULL);
         a = false;
         cout << "sv_Cheats bypass =  OFF! " << "\n" << endl;
         Sleep(1000);
     }
    if (GetAsyncKeyState(VK_F2) && a == true)
     {
        WriteProcessMemory( hHandle, (LPVOID)( EngineDll + 0x3B89F0), &pure_on, sizeof(int), NULL);
         a = false;
         cout << "sv_pure bypass =  OFF! " << "\n" << endl;
         Sleep(1000);
     }
    if (GetAsyncKeyState(VK_F2) && a == false)
     {
         WriteProcessMemory( hHandle, (LPVOID)( EngineDll + 0x3B89F0), &pure_off, sizeof(int), NULL);
         a = true;
         cout << "sv_pure bypass  =  ON! " << "\n" << endl;
         Sleep(1000);
     }
    if (GetAsyncKeyState(VK_F3) && a == true)
     {
        WriteProcessMemory( hHandle, (LPVOID)( EngineDll + 0x5C51E4), &consistency_on, sizeof(int), NULL);
         a = false;
         cout << "sv_consistency bypass =  OFF! " << "\n" << endl;
         Sleep(1000);
     }
    if (GetAsyncKeyState(VK_F3) && a == false)
     {
         WriteProcessMemory( hHandle, (LPVOID)( EngineDll + 0x5C51E4), &consistency_off, sizeof(int), NULL);
         a = true;
         cout << "sv_pure consistency  =  ON! " << "\n" << endl;
         Sleep(1000);
     }
    if (GetAsyncKeyState(VK_F4) && a == false)
     {
         WriteProcessMemory( hHandle, (LPVOID)( ClientDll + 0x5350F0), &wire_on, sizeof(int), NULL);
         a = true;
         cout << "ESP boxes  =  ON! " << "\n" << endl;
         Sleep(1000);
     }
     if (GetAsyncKeyState(VK_F4) && a == true)
     {
         WriteProcessMemory( hHandle, (LPVOID)( ClientDll + 0x5350F0), &wire_off, sizeof(int), NULL);
         a = false;
         cout << "ESP boxes  =  OFF! " << "\n" << endl;
         Sleep(1000);
     }


        if (GetAsyncKeyState(VK_F5) && a == false)
     {
         WriteProcessMemory( hHandle, (LPVOID)( materialsystemDll + 0x10E4B0), &bright_on, sizeof(int), NULL);
         a = true;
         cout << "Fullbright  =  ON! " << "\n" << endl;
         Sleep(1000);
     }
     if (GetAsyncKeyState(VK_F5) && a == true)
     {
         WriteProcessMemory( hHandle, (LPVOID)( materialsystemDll + 0x10E4B0), &bright_off, sizeof(int), NULL);
         a = false;
         cout << "Fullbright  =  OFF! " << "\n" << endl;
         Sleep(1000);
     }
     if (GetAsyncKeyState(VK_F6) && a == false)
     {
        WriteProcessMemory( hHandle, (LPVOID)( ClientDll + 0x567048), &no_smoke_on, sizeof(int), NULL);
        cout << "No Smoke =  ON! " << "\n" << endl;
        Sleep(1000);
     }
    if (GetAsyncKeyState(VK_F6) && a == true)
     {
        WriteProcessMemory( hHandle, (LPVOID)( ClientDll + 0x567048), &no_smoke_off, sizeof(int), NULL);
         a = false;
         cout << "No_Smoke =  OFF! " << "\n" << endl;
         Sleep(1000);
     }
     if (GetAsyncKeyState(VK_F7) && a == false)
     {
         WriteProcessMemory( hHandle, (LPVOID)( ClientDll + 0x8A6768), &no_hands_on, sizeof(int), NULL);
         a = true;
         cout << "NO Hands = ON! " << "\n" << endl;
         Sleep(1000);
     }
     if (GetAsyncKeyState(VK_F7) && a == true)
     {
         WriteProcessMemory( hHandle, (LPVOID)( ClientDll + 0x8A6768), &no_hands_off, sizeof(int), NULL);
         a = false;
         cout << "NO Hands = OFF! " << "\n" << endl;
         Sleep(1000);
     }
     if (GetAsyncKeyState(VK_F8) && a == false)
     {
         WriteProcessMemory( hHandle, (LPVOID)( ClientDll + 0x56E748), &no_sky_on, sizeof(int), NULL);
         a = true;
         cout << "NO Hands = ON! " << "\n" << endl;
         Sleep(1000);
     }
     if (GetAsyncKeyState(VK_F8) && a == true)
     {
         WriteProcessMemory( hHandle, (LPVOID)( ClientDll + 0x56E748), &no_sky_off, sizeof(int), NULL);
         a = false;
         cout << "NO Hands = OFF! " << "\n" << endl;
         Sleep(1000);
     }
     if (GetAsyncKeyState(VK_F9) && a == false)
     {
         WriteProcessMemory( hHandle, (LPVOID)( ClientDll + 0x56B008), &draw_fps_on, sizeof(int), NULL);
         a = true;
         cout << "FPS = ON! " << "\n" << endl;
         Sleep(1000);
     }
     if (GetAsyncKeyState(VK_F9) && a == true)
     {
         WriteProcessMemory( hHandle, (LPVOID)( ClientDll + 0x56B008), &draw_fps_off, sizeof(int), NULL);
         a = false;
         cout << "FPS = OFF! " << "\n" << endl;
         Sleep(1000);
     }
         cout << "Loading Complete , Closing in 8 seconds..." << endl;
         Sleep(8000);
         exit(0);
        }
    }
    else
    {
        system("Color 8C");
        cout << "Error! You need to join a game before load executable..." << endl;

        Sleep(3000);
        exit(0);
    }
    return 0;
}

struct lmao
    {
    DWORD ClientDll;
    DWORD PB;
    DWORD EBase;
    HANDLE hHandle;
    DWORD CurrentEBase;
    bool toggle;
    int mT;
    int eT;
    int xID;
    int flag;

    void read()
    {
        ReadProcessMemory( hHandle, (LPVOID)(ClientDll + eBaseAddy), &EBase, sizeof(DWORD), NULL);
        ReadProcessMemory( hHandle, (LPCVOID*)(ClientDll +  PBAddy), &PB, sizeof(DWORD), NULL);
        ReadProcessMemory( hHandle, (LPCVOID*)(PB +  JumpOff), &flag, sizeof(int), NULL);
        ReadProcessMemory( hHandle, (LPVOID)(PB+teamOffs), &mT, sizeof(int), NULL);
        ReadProcessMemory( hHandle, (LPVOID)(PB+xHairOffs), &xID, sizeof(int), NULL);
        ReadProcessMemory( hHandle, (LPVOID)((ClientDll + eBaseAddy) + ((xID - 1) * LoopDistance)), &CurrentEBase, sizeof(DWORD), NULL);
        ReadProcessMemory( hHandle, (LPVOID)(CurrentEBase + teamOffs), &eT, sizeof(DWORD), NULL);
        ReadProcessMemory( hHandle, (LPVOID)(ClientDll + 0x74575C), &PB, sizeof(DWORD), NULL);
    }
    void FlashAlpha(float Alpha){
        WriteProcessMemory( hHandle, (LPVOID)(PB + 0x1410), &Alpha, sizeof(float), NULL);
    }
    }lol;

DWORD _c0d_3r_dwGetModuleBaseAddress(DWORD _xCt_0_dwProcessIdentifier, TCHAR *sym_lpszModuleName)
{
    HANDLE Ak3_sk3r_hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, _xCt_0_dwProcessIdentifier);
    DWORD b1_0t_dwModuleBaseAddress = 0;
    if (Ak3_sk3r_hSnapshot != INVALID_HANDLE_VALUE)
    {
        MODULEENTRY32 _An0n_ym0us_ME32 = { 0 };
        _An0n_ym0us_ME32.dwSize = sizeof(MODULEENTRY32);
        if (Module32First(Ak3_sk3r_hSnapshot, &_An0n_ym0us_ME32))
        {
            do
            {
                if (_tcsicmp(_An0n_ym0us_ME32.szModule, sym_lpszModuleName) == 0)
                {
                    b1_0t_dwModuleBaseAddress = (DWORD)_An0n_ym0us_ME32.modBaseAddr;
                    break;
                }
            } while (Module32Next(Ak3_sk3r_hSnapshot, &_An0n_ym0us_ME32));
        }
        CloseHandle(Ak3_sk3r_hSnapshot);
    }
    return b1_0t_dwModuleBaseAddress;
}

int random(int limit)
{
    int div = RAND_MAX/(limit+1);
    int ret;

    do
    {
        ret = rand() / div;
    }
    while (ret > limit);

    return ret;
}

void Sleeptime(int Seconds){
    Sleep(Seconds * 1000);
}

void Burst()
{
    if(BurstEnable == 1)
    {
        Time = 24;
        Delay = 16;
    }
    if(BurstEnable == 2)
    {
        Time = 33;
        Delay = 300;
    }
    if(BurstEnable == 3)
    {
        Time = 112;
        Delay = 380;
    }
    Sleep(1);
}

void M()
    {
        mouse_event(MOUSEEVENTF_WHEEL, 0, 0, -120, 0);


        Sleep(250);
    }

void bH()
    {
        for(int p_nK_xY_i = 0;p_nK_xY_i != 3 && (GetAsyncKeyState(space));p_nK_xY_i++)
        {
            lol.read();
            if(lol.flag != aerial && lol.flag != c_jump && lol.flag != c_jumping)
            {
                if(_Nb == 'y')
                {
                   M();
                }
                if(_Nb == 'n')
                {
                exit(0);
                }
            }
        }
        Sleep(1);
    }

void TBoat()
{
    lol.read();
    Burst();

    if(lol.xID == 0)
    return;

    if(lol.xID > maxplayers)
    return;

    if(lol.eT == lol.mT)
    return;

    int Number = random(2);
    int Delay =Number + 11;

    if(lol.xID != 0)
    {
        Sleep(Delay);
        mouse_event(MOUSEEVENTF_LEFTDOWN, 0, 0, 0, 0);
        Sleep(Time);
        mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
        Sleep(Delay);
    }
    Sleep(1);
}

void Radar()
{
    HANDLE hHandle;
    DWORD ClientDll;
    for( int i = 0; i < 32; i++ )
    {
        DWORD dwEntity = 0;
        ReadProcessMemory( hHandle, (LPVOID)( ClientDll + 0xA89444 + i * 0x10 ), &dwEntity, 4, NULL );
        WriteProcessMemory( hHandle, (LPVOID)( dwEntity + m_bSpotted ), &bSpotted, 1, NULL );
    }
while( !GetAsyncKeyState( 0x77 ) )
{
    if( GetAsyncKeyState( 0x09 ) & 1 )
    {
        bEnabled = !bEnabled;
    }

    if( bEnabled )
    {
        Radar();
    }
    }
Sleep(1);
}

void init(){
    {
        SetConsoleTitle( "CS:S External Base by Scribzz" );
        system("Color 80");

cout << "" << endl;
cout << "\t\t******COUNTER-STRIKE: SOURCE EXTERNAL BASE*******" << endl;
cout << "\t\t***********************..,***********************" << endl;
cout << "\t\t*********************.....,**********************" << endl;
cout << "\t\t********************,.....***********************" << endl;
cout << "\t\t******************.....................,*..******" << endl;
cout << "\t\t*****************........,........,*/*/**********" << endl;
cout << "\t\t*****************.............,,*.***************" << endl;
cout << "\t\t****************,........,***********************" << endl;
cout << "\t\t****************........,************************" << endl;
cout << "\t\t****************........*************************" << endl;
cout << "\t\t****************,........,***********************" << endl;
cout << "\t\t****************...........,*********************" << endl;
cout << "\t\t***************.....,*,....,*********************" << endl;
cout << "\t\t**************,.....****.....********************" << endl;
cout << "\t\t**************.....******.....*******************" << endl;
cout << "\t\t************......********....,******************" << endl;
cout << "\t\t**************Coded by Scribzz*******************" << endl;
        cout << "" << endl;
        cout << "\t\t   Enable Bhop, Bind Jump To MWheelDown!" << endl;
        cout << "" << endl;
        cout << "\t\t   Enable TriggerBot By Pressing Mouse4!" << endl;
        cout << "" << endl;
        cout << "\t\t   Enable Burst-Fire? (1= No, 2= Burst)\n";
        cin >> BurstEnable;
        cout << "\t\t   F1 sv_cheats Bypass" << endl;

        cout << "\t\t   F2 sv_pure Bypass" << endl;

        cout << "\t\t   F3 sv_consistency Bpass" << endl;

        cout << "\t\t   F4 ESP" << endl;

        cout << "\t\t   F5 Fullbright" << endl;

        cout << "\t\t   F6 No Smoke" << endl;

        cout << "\t\t   F7 No Hands" << endl;

        cout << "\t\t   F8 No Hands" << endl;

        cout << "\t\t   F9 Draw FPS" << endl;

        cout << "\t\t   Press ENTER after joining a game..." << "\n " << endl;

        cin.get();
        system("cls");
        A_();
    }
}

int main(int argc, _TCHAR* argv[])
{
    init();

    void a1();
    POINT pft;


    while(i)
    {
        GetCursorPos(&pft);

        if(GetAsyncKeyState(M5))
        {
          n++;
            sd += 0.1f;
            if(n < 300) SetCursorPos(pft.x - (int)sd,pft.y + 1);
            if(sd > 1.1f) sd = 0.0f;

            if(n < 50)
                Sleep(4);
            else if(n < 75)
                Sleep(6);
            else if(n < 200)
                Sleep(9);
            else if(n < 350)
                Sleep(15);
            else
                Sleep(25);
        }
            else
            n = 0;
    }
char A[5];
DWORD S = 500;
ifstream ifile("C:/GuidedHacking.cfg");
if (!ifile)
    {
        ofstream Settings;
        Settings.open("C:/GuidedHacking.cfg");
        Settings << "[FlashBangAlpha]" << endl;
        Settings << "Alpha=22" << endl;
        Settings.close();
    }
    GetPrivateProfileString("FlashBangAlpha", "Alpha", NULL, A, S, "C:/GuidedHacking.cfg");
    float AlphaF = atoi(A);
        lol.read();
        lol.FlashAlpha(AlphaF);
    while (true)
    {
        Sleep(1);
        lol.read();
        lol.FlashAlpha(AlphaF);
    }
    getchar();
    {



         while(!GetAsyncKeyState(xxx))
        {
            while(GetAsyncKeyState(space))
            {
                bH();
                }
                while(GetAsyncKeyState(M5))
                {
                TBoat();
                }
             }
        }
    return 0;
    }

DWORD GetMB(const DWORD dwProcId, const char *szModuleName)
{
    HANDLE hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPMODULE, dwProcId);
    if (!hSnap)
    {
        return 0;
    }
    MODULEENTRY32 me;
    me.dwSize = sizeof(MODULEENTRY32);
    DWORD dwReturn = 0;
    if (Module32First(hSnap, &me))
    {
        while (Module32Next(hSnap, &me))
        {
            if (lstrcmpi(me.szModule, szModuleName) == 0)
            {
                dwReturn = (DWORD)me.modBaseAddr;
                break;
            }
        }
    }
    CloseHandle(hSnap);
    return dwReturn;
}