SolvedLow fps in game - paste code

#define JPN_H 
#define JPN_H 

#include <windows.h> 
#include <iostream> 
#include <TlHelp32.h> 
#include <string> 
#include <sstream> 


class jpn {
protected:
	HANDLE hProcess;
	DWORD dwPID, dwProtection, dwCaveAddress;

	BOOL bPOn, bIOn, bProt;
public:

	jpn( );
	~jpn( );
	int chSizeOfArray( char *chArray );
	int iSizeOfArray( int *iArray );
	bool iFind( int *iAry, int iVal );

#pragma region TEMPLATE MEMORY FUNCTIONS

	template < class cData >
	void Protection( DWORD dwAddress ) {
		if ( !bProt )
			VirtualProtectEx( hProcess, ( LPVOID )dwAddress, sizeof( cData ), PAGE_EXECUTE_READWRITE, &dwProtection ); 
		else
			VirtualProtectEx( hProcess, ( LPVOID )dwAddress, sizeof( cData ), dwProtection, &dwProtection );

		bProt = !bProt;
	}
	template < class cData >
	cData nmd( DWORD dwAddress ) {
		cData cRead;
		ReadProcessMemory( hProcess, ( LPVOID )dwAddress, &cRead, sizeof( cData ), NULL );
		return cRead;
	}
	template < class cData >
	cData nmd( DWORD dwAddress, char *Offset, BOOL Type ) {
		int iSize = iSizeOfArray( Offset ) - 1;
		dwAddress = nmd< DWORD >( dwAddress );

		for ( int i = 0; i < iSize; i++ )
			dwAddress = nmd< DWORD >( dwAddress + Offset[ i ] );

		if ( !Type )
			return dwAddress + Offset[ iSize ];
		else
			return nmd< cData >( dwAddress + Offset[ iSize ] );
	}
	template < class cData >
	void cmd( DWORD dwAddress, cData Value ) {
		WriteProcessMemory( hProcess, ( LPVOID )dwAddress, &Value, sizeof( cData ), NULL );
	}
	template < class cData >
	void cmd( DWORD dwAddress, char *Offset, cData Value ) {
		cmd< cData >( nmd< cData >( dwAddress, Offset, false ), Value );
	}
	virtual void Process(char* ProcessName);
	virtual void Patch(DWORD dwAddress, char *chPatch_Bts, char *chDefault_Bts);
	virtual void Inject(DWORD dwAddress, char *chInj_Bts, char *chDef_Bts, BOOL Type);
	virtual DWORD AOB_Scan(DWORD dwAddress, DWORD dwEnd, char *chPattern);
	virtual DWORD Module(LPSTR ModuleName);

#pragma endregion	

};
#endif

/* header */
#include <iostream>
#include "Windows.h"
#include "alicia.h"

using namespace std;

jpn user;

/* booleans */
bool GlowOn = true;
bool TriggerOn = true;

/* functions */
void WPMshoot();

/* defines */
#define FL_ONGROUND ( 1 << 0 )

/* offsets */
DWORD dwLocal = 0x00A8F53C;
DWORD dwGlow = 0x04FC8BC4;
DWORD dwEntity = 0x04AB0F94;
DWORD dwTeam = 0xF0;
DWORD dwGlowIndex = 0x0000A320;
DWORD dwCrosshair = 0x0000AA64;
DWORD dwAttack = 0x02EF0F98;
DWORD dwJump = 0x04F47AD4;
DWORD dwFlags = 0x100;
DWORD dwHealth = 0xFC;
DWORD dwActiveWeapon = 0x2EE8;
DWORD dwFlash = 0xA2F4;
DWORD dwItemDefinition = 0x2F80;
DWORD dwCrosshairColor = 0x58FACE4C;
DWORD Client;

struct ReadData {

	DWORD GetBase() {

		return user.nmd< DWORD >(Client + dwLocal);

	}

	DWORD GetGlow() {

		return user.nmd< DWORD >(Client + dwGlow);

	}

	DWORD GetJump() {

		return user.nmd< DWORD >(Client + dwJump);

	}

	/*weapon data*/
	DWORD GetWeaponHandle() {

		DWORD LB = Data.GetBase();

		if (LB) {

			return user.nmd< DWORD >(LB + dwActiveWeapon);

		}

	}

	int GetWeaponEntity() {

		return user.nmd< int >(Data.GetWeaponHandle() + 0xFFF);

	}

	DWORD GetCurrentWeapon() {

		return user.nmd< DWORD >(Client + dwEntity + (GetWeaponEntity() - 1) * 0x10);

	}

	int GetWeaponID() {

		return user.nmd< int >(Data.GetCurrentWeapon() + dwItemDefinition);

	}

	/* |weapon data| */

	int GetFlags() {

		DWORD LB = Data.GetBase();

		if (LB) {

			return user.nmd< int >(LB + dwFlags);

		}
	}

	int GetCrosshair() {

		DWORD LB = GetBase();

		if (LB) {

			return user.nmd< int >(LB + dwCrosshair);

		}

	}

	int GetTeam() {

		DWORD LB = GetBase();

		if (LB) {

			return user.nmd< int >(LB + dwTeam);

		}

	}

	int GetHealth() {

		DWORD LB = GetBase();

		int EntityData = user.nmd< int >(Client + dwEntity + ((Data.GetCrosshair() - 1) * 0x10));

		if (LB) {

			return user.nmd< int >(EntityData + dwHealth);

		}

	}

	int GetEnemyTeam() {

		DWORD LB = GetBase();

		int EntityData = user.nmd< int >(Client + dwEntity + ((Data.GetCrosshair() - 1) * 0x10));

		if (LB) {

			return user.nmd< int >(EntityData + dwTeam);

		}

	}

} Data;

void XHair() {
	while (true) {
		user.cmd< DWORD >(Client + dwCrosshairColor, 2);
		Sleep(1);
	}
}

class cGlow {
public:
	void Glow() {

		while (true) {

			if (GlowOn == true) {

				for (int i = 0; i < 64; i++) {

					int GlowCurrentPlayer = user.nmd< int >(Client + dwEntity + ((i - 1) * 16));

					int GlowCurrentPlayerTeam = user.nmd< int >(GlowCurrentPlayer + dwTeam);

					int GlowCurrentPlayerIndex = user.nmd< int >(GlowCurrentPlayer + dwGlowIndex);

					int GlowCurrentPlayerFlashed = user.nmd< int >(GlowCurrentPlayer + dwFlash);

					if (Data.GetTeam() != GlowCurrentPlayerTeam) {

						user.cmd< float >((Data.GetGlow() + ((GlowCurrentPlayerIndex * 0x38) + 0x4)), 0.f);
						user.cmd< float >((Data.GetGlow() + ((GlowCurrentPlayerIndex * 0x38) + 0x8)), 0.f);
						user.cmd< float >((Data.GetGlow() + ((GlowCurrentPlayerIndex * 0x38) + 0xC)), 1.f);
						user.cmd< float >((Data.GetGlow() + ((GlowCurrentPlayerIndex * 0x38) + 0x10)), 0.49f);
						user.cmd< BOOL >((Data.GetGlow() + ((GlowCurrentPlayerIndex * 0x38) + 0x24)), true);
						user.cmd< BOOL >((Data.GetGlow() + ((GlowCurrentPlayerIndex * 0x38) + 0x25)), false);

					}

				}

			}

			Sleep(1);

		}

	}

};

void Bunny() {

	while (true) {

		if (Data.GetJump() == 5) {

			while (GetAsyncKeyState(VK_SPACE) & 0x8000) {

				if (Data.GetFlags() & FL_ONGROUND) {

					user.cmd< int >(Client + dwJump, 5);

				}

				else {

					user.cmd< int >(Client + dwJump, 4);

				}

			}

		}

	}

}

void Trigger() {

	while (true) {

		if (TriggerOn == true) {

			if (GetAsyncKeyState(VK_MENU) & 0x8000) {

				if (Data.GetHealth() > 0) {

					if (Data.GetEnemyTeam() != Data.GetTeam()) {

						WPMshoot();

					}

				}

			}

		}

		Sleep(1);

	}

}

void WPMshoot() {

	user.cmd< int >(Client + dwAttack, 5);

	Sleep(7);

	user.cmd< int >(Client + dwAttack, 4);

}

#include "alicia.h"

using namespace std;

#pragma region Misc Functions

jpn::jpn( ) {

}

jpn::~jpn( ) {

	CloseHandle( hProcess );
}

int jpn::chSizeOfArray( char *chArray ) {


	for ( int iLength = 1; iLength < MAX_PATH; iLength++ )
		if ( chArray[iLength] == '*' )
			return iLength;

	cout << "\nLENGTH: Failed To Read Length Of Array\n";
	return 0;
}


int jpn::iSizeOfArray( int *iArray ) {


	for ( int iLength = 1; iLength < MAX_PATH; iLength++ )
		if ( iArray[iLength] == '*' )
			return iLength;

	cout << "\nLENGTH: Failed To Read Length Of Array\n";
	return 0;
}

bool jpn::iFind( int *iAry, int iVal ) {

	for ( int i = 0; i < 64; i++ )
		if ( iVal == iAry[i] && iVal != 0 )
			return true;

	return false;
}

#pragma endregion

#pragma region Memory Functions


void jpn::Process( char* ProcessName ) {
	HANDLE hPID = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, NULL );
	PROCESSENTRY32 ProcEntry;
	ProcEntry.dwSize = sizeof( ProcEntry );

	do
		if ( !strcmp(ProcEntry.szExeFile, ProcessName ) ) {
			dwPID = ProcEntry.th32ProcessID;
			CloseHandle( hPID );

			hProcess = OpenProcess( PROCESS_ALL_ACCESS, FALSE, dwPID );
			return;
		}
	while ( Process32Next( hPID, &ProcEntry ) );

	cout << "<<TYLERWARE failed to load - run CSGO first>>";
	system( "pause" );
	exit( 0 );
}

void jpn::Patch( DWORD dwAddress, char *Patch_Bts, char *Default_Bts ) {
	int iSize = chSizeOfArray( Default_Bts );

	if ( !bPOn )
		for ( int i = 0; i < iSize; i++ )
			cmd< BYTE >( dwAddress + i, Patch_Bts[i] );
	else
		for ( int i = 0; i < iSize; i++ )
			cmd< BYTE >( dwAddress + i, Default_Bts[ i ] );

	bPOn = !bPOn;
}


void jpn::Inject( DWORD dwAddress, char *Inj_Bts, char *Def_Bts, BOOL Type ){


	int i_ISize = chSizeOfArray( Inj_Bts );
	int i_DSize = chSizeOfArray( Def_Bts );
	if ( !bIOn ) {
		if ( i_DSize > 5 )
			for ( int i = 6; i < i_DSize; i++ )
				cmd< BYTE >( dwAddress + i, 0x90 );
		else { cout << "\nINJECTION: Default Bytes Must Be More Than 5\n"; return; }


		dwCaveAddress = ( DWORD )VirtualAllocEx( hProcess, NULL, i_ISize + 5, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE );


		DWORD dwRetJmp = ( dwAddress + i_DSize ) - dwCaveAddress - 5;
		DWORD dwBaseJmp = dwCaveAddress - dwAddress - 5;

		for ( int i = 0; i <= i_ISize; i++ )
			cmd< BYTE >( dwCaveAddress + i, Inj_Bts[ i ] );


		cmd< BYTE >( dwCaveAddress + i_ISize, Type ? 0xE9 : 0xE8 );
		cmd< DWORD >( dwCaveAddress + i_ISize + 1, dwRetJmp );


		cmd< BYTE >( dwAddress, Type ? 0xE9 : 0xE8 );
		cmd< DWORD >( dwAddress + 1, dwBaseJmp );
	}
	else {

		for ( int i = 0; i < i_DSize; i++ )
			cmd< BYTE >( dwAddress + i, Def_Bts[ i ] );

		VirtualFreeEx( hProcess, ( LPVOID )dwCaveAddress, i_ISize + 5, MEM_DECOMMIT );
	}
	bIOn = !bIOn;
}


DWORD jpn::AOB_Scan( DWORD dwAddress, DWORD dwEnd, char *Bytes ) {


	int iBytesToRead = 0, iTmp = 0;
	int length = chSizeOfArray( Bytes );
	bool bTmp = false;


	if (Bytes[0] == '?') {
		for ( ; iBytesToRead < MAX_PATH; iBytesToRead++ )
			if ( Bytes[ iBytesToRead ] != '?' ) {
				iTmp = ( iBytesToRead + 1 );
				break;
			}
	}
	for ( ; dwAddress < dwEnd; dwAddress++ ) {
		if ( iBytesToRead == length)
			return dwAddress - iBytesToRead;
		if ( nmd< BYTE >( dwAddress ) == Bytes[ iBytesToRead ] || ( bTmp && Bytes[iBytesToRead] == '?' ) ) {
			iBytesToRead++;
			bTmp = true;
		}
		else {
			iBytesToRead = iTmp;
			bTmp = false;
		}
	}
	cout << "\nAOB_SCAN: Failed To Find Byte Pattern\n";
	return 0;
}


DWORD jpn::Module( LPSTR ModuleName ){


	HANDLE hModule = CreateToolhelp32Snapshot( TH32CS_SNAPMODULE, dwPID );
	MODULEENTRY32 mEntry;
	mEntry.dwSize = sizeof( mEntry );

	do
		if ( !strcmp( mEntry.szModule, ModuleName ) ) {
			CloseHandle( hModule );
			return ( DWORD )mEntry.modBaseAddr;
		}
	while ( Module32Next(hModule, &mEntry ) );

	cout << "\nCouldn't find client.dll, retrying...\n";
	return 0;
}

#pragma endregion

/* main */
#include "cheat.h"

cGlow * pGlow;

void Tyler( ) {

	/* Set The Console Title */
	SetConsoleTitle( "cheat" );

	/* Attach to CS:GO */
	user.Process( "csgo.exe" );  

	/* Client.dll */
	Client = user.Module( "client.dll" );

	pGlow->Glow( );

}

int main( ) {
	HANDLE Threads[ ] = {

		CreateThread( 0 , 0 , ( LPTHREAD_START_ROUTINE ) Tyler , 0 , 0 , 0 ),
		CreateThread( 0 , 0 , ( LPTHREAD_START_ROUTINE ) XHair , 0 , 0 , 0 ),
		CreateThread( 0 , 0 , ( LPTHREAD_START_ROUTINE) Trigger , 0 , 0 , 0 ),
		CreateThread( 0 , 0 , ( LPTHREAD_START_ROUTINE) Bunny , 0 , 0 , 0 )

	};

	WaitForMultipleObjects( sizeof( Threads ) / sizeof( HANDLE ), Threads, TRUE, INFINITE );

	return( 0 );

}