Psycho's triggerbot *Burst/Toggle*

Here we go again...
People have been asking I guess, if anybody wants to continue making these releases publicly for me I included my Entity/Player class as well as an example on how a trigger can be done, bhop etc can be implemented very easy as well.
Giving away the source because I'm not gonna continue this hack, it isn't that fun, I'd rather work on improving my GUI's and in general becoming a better programmer.
If you do decide to continue it though, please consider placing credits

Disclaimer

Skids, just no.. DO NOT USE THIS SOURCE FOR SELLING "YOUR" "PRIVATE" ON SKYPE.

Example on how to create a trigger using this

Code:

// At the top
CLocalPlayer* p = new CLocalPlayer; // LocalPlayer 
CBaseEntity* e = new CBaseEntity; // Entity in question

//Trigger thread:
void triggerThread()
{
	while(true) {
		p->GetPLocal(); // We wont be able to get our player information if we dotn have our Player
		e->GetEntity(p->GetCHID()-1); // We grab the information from the entity in our crosshair 
		if (trigOn && !burstOn && p->isAlive() && e->IsAlive() && e->GetTeam() != p->GetTeam()) {
			/* If statement summary: 
			Our player can attack and our player is alive.
			Entity in our crosshair is alive and entity in our crosshair is not our own team.*/
			p->SetAttack(5, 5); // Set attack to +attack (5 1st arg) and sleep 5 milliseconds (2nd arg)
			p->SetAttack(4, 5); // Set attack to -attack (4 1st arg) and sleep 5 milliseconds (2nd arg)
		}
		if (trigOn && burstOn && p->isAlive() && e->IsAlive() && e->GetTeam() != p->GetTeam()) {
			/* Burst enabled, everyting else is the same */
			p->SetAttack(5, 200); // Set attack to +attack (5 1st arg) and sleep 200 milliseconds (2nd arg)
			p->SetAttack(4, 210); // same as above really... :P
		}


		Sleep(1); // If you dont put this sleep here you'll kill the CPU.. Not really kill it, but it'll be way to intensive.
	}
}

Header files (Classes)

PMem.h:

Code:

#ifndef PMEM_H
#define PMEM_H
#include <iostream>
#include <Windows.h>
#include <cmath>
#include <string>
#include <TlHelp32.h>
#include <stdint.h>


class PMem {
protected:
        HANDLE hProcess;
        DWORD dwPID, dwProtection, dwCaveAddress;
        BOOL bPOn, bIOn, bProt;

public:
        PMem();
        ~PMem();
		bool Attached;

		 /* Read Template! */
         template <class cData>
        cData Read(DWORD dwAddress)
        {
                cData cRead;
                ReadProcessMemory(hProcess, (LPVOID)dwAddress, &cRead, sizeof(cData), NULL);
                return cRead;
        }
 
 
        virtual bool Process(char* ProcessName);
        virtual DWORD Module(LPSTR ModuleName);

		/* WriteProcessMemory */

	template <class T>
	void Write(DWORD addr, T val) {
		WriteProcessMemory(hProcess, (LPVOID)addr, &val, sizeof(T), NULL);
	}
};
#endif

PMem.cpp:

Code:

#include "PMem.h"

#pragma region Misc functions
PMem::PMem() { }

PMem::~PMem() {
CloseHandle(hProcess);
}
bool PMem::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);
				this->Attached = true;
                return true;
                }
        while (Process32Next(hPID, &ProcEntry));
        return false;
}

DWORD PMem::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));
 
        std::cout << "\nMODULE: Process Platform Invalid\n";
        return 0;
}

Player Classes (Entity and player is in same header/source)
CBaseEntity.h:

Code:

/************************************************
*    Author: Psychobitch
*    File Purpose: Class defintions and members
*    Creation date: 2015-05-17
*************************************************/
#pragma once // Header guard
#include <Windows.h>
#include "PMem.h" 



class CLocalPlayer // Class
{
public: // Public Members
	PMem              Mem; // Memory object
	DWORD             dwClient; // Client dll

	DWORD             m_pLocal; // M stands for member (This is the player in question)
	int               m_iTeam; // Team of player in question (Your player)
	int               m_iHealth; // Health of player in question (Your health)
	int               m_iCHID; // Crosshair id, aka the entity in crosshair
	int               AttackState; // attack state..

public: // Public methods
	DWORD             GetPLocal();
	int               GetTeam();
	bool              isAlive();
	int               GetCHID();
	bool              CanAttack();

	void              SetAttack(int, int);
};


class CBaseEntity  // Class
{
public: // Public Members
	PMem          Mem; // Memory object
	DWORD         dwClient;

	DWORD         m_pEnt; // Entity in question (ent in crosshair)
	int           m_iTeam;
	int           m_iHealth;

public: // Public Methods
	DWORD        GetEntity(int);
	int          GetTeam();
	bool         IsAlive();
};

CBaseEntity.cpp:

Code:

/************************************************
*    Author: Psychobitch
*    File Purpose: Methods & Members of Classes
*    Creation date: 2015-05-17
*************************************************/
#include "CLocalPlayer.h"
#include "Globals.h"


#pragma region CLocalPlayer
DWORD CLocalPlayer::GetPLocal()
{
	this->m_pLocal = Mem.Read<DWORD>(dwClient + Globals::localPlayer);
	return this->m_pLocal;
}

int CLocalPlayer::GetTeam()
{
	this->m_iTeam = Mem.Read<int>(this->m_pLocal + 0xF0); // 0xF0 m_iTeamNum Offset
	return this->m_iTeam;
}

bool CLocalPlayer::isAlive()
{
	this->m_iHealth = Mem.Read<int>(this->m_pLocal + 0xFC); // 0xFc m_iHealth offset
	if (this->m_iHealth > 0) return true;
	else return false;
}

int CLocalPlayer::GetCHID()
{
	this->m_iCHID = Mem.Read<int>(this->m_pLocal + Globals::CHIndex);
	return this->m_iCHID;
}

bool CLocalPlayer::CanAttack()
{
	this->AttackState = Mem.Read<int>(dwClient + Globals::Attack);
	if (this->AttackState == 5) return true;
	else return false;
}


void CLocalPlayer::SetAttack(int _val, int _dur)
{
	Mem.Write<int>(this->dwClient + Globals::Attack, _val);
	Sleep(_dur);
}
#pragma endregion CLocalPlayer


#pragma region CBaseEntity
DWORD CBaseEntity::GetEntity(int _id) 
{
	this->m_pEnt = Mem.Read<DWORD>(dwClient + Globals::entityList + (_id * 0x10)); // Each entity is 0x10 bytes away from eachother inside the entityList
	return this->m_pEnt;
}

int CBaseEntity::GetTeam() 
{
	this->m_iTeam = Mem.Read<int>(this->m_pEnt + 0xF0);
	return this->m_iTeam;
}

bool CBaseEntity::IsAlive()
{
	this->m_iHealth = Mem.Read<int>(this->m_pEnt + 0xFC);
	if (this->m_iHealth > 0) return true;
	else return false;
}
#pragma endregion CBaseEntity

thxn 4 red me post plez +rep

Information:
Toggle trigger on: Arrow key up
Toggle burst on: Arrow key down

Screenshot: