Macro Pack + Spammer Source [C++]
Spammer:
Macro Pack:
A lot of this code is pretty messy/ straight up bad, sorry about that. I don't write code to release it, that just happens sometimes. I tried to comment it, but I forgot how some of the stuff worked/ why I did stuff.
Compiled this with Code::Blocks. You still need pthreads (https://www.sourceware.org/pthreads-win32/) to compile this.
Code:
#include <iostream>
#include <windows.h>
#include <winable.h>
#include <map>
#include <algorithm>
#define Winver 0x500
using namespace std;
void Generate_Key(int key, bool shift){
INPUT input;
if(shift){
input.type = INPUT_KEYBOARD;
input.ki.wScan = 0;
input.ki.time = 0;
input.ki.dwExtraInfo = 0;
input.ki.wVk = VK_SHIFT;
SendInput(1, &input, sizeof(INPUT));
}
input.type = INPUT_KEYBOARD;
input.ki.wScan = 0;
input.ki.time = 0;
input.ki.dwExtraInfo = 0;
input.ki.wVk = key;
SendInput(1, &input, sizeof(INPUT));
input.ki.dwFlags = KEYEVENTF_KEYUP;
SendInput(1, &input, sizeof(INPUT));
if(shift){
input.type = INPUT_KEYBOARD;
input.ki.wScan = 0;
input.ki.time = 0;
input.ki.dwExtraInfo = 0;
input.ki.wVk = VK_SHIFT;
input.ki.dwFlags = KEYEVENTF_KEYUP;
SendInput(1, &input, sizeof(INPUT));
}
}
int main()
{
int sleep_time = 1000;
cout << "Wait how long between each message? (in milliseconds) ";
cin >> sleep_time;
map<string, int> keycodes;
keycodes.insert(make_pair("a", 0x41)); //map of letters and virtual keys
keycodes.insert(make_pair("b", 0x42));
keycodes.insert(make_pair("c", 0x43));
keycodes.insert(make_pair("d", 0x44));
keycodes.insert(make_pair("e", 0x45));
keycodes.insert(make_pair("f", 0x46));
keycodes.insert(make_pair("g", 0x47));
keycodes.insert(make_pair("h", 0x48));
keycodes.insert(make_pair("i", 0x49));
keycodes.insert(make_pair("j", 0x4A));
keycodes.insert(make_pair("k", 0x4B));
keycodes.insert(make_pair("l", 0x4C));
keycodes.insert(make_pair("m", 0x4D));
keycodes.insert(make_pair("n", 0x4E));
keycodes.insert(make_pair("o", 0x4F));
keycodes.insert(make_pair("p", 0x50));
keycodes.insert(make_pair("q", 0x51));
keycodes.insert(make_pair("r", 0x52));
keycodes.insert(make_pair("s", 0x53));
keycodes.insert(make_pair("t", 0x54));
keycodes.insert(make_pair("u", 0x55));
keycodes.insert(make_pair("v", 0x56));
keycodes.insert(make_pair("w", 0x57));
keycodes.insert(make_pair("x", 0x58));
keycodes.insert(make_pair("y", 0x59));
keycodes.insert(make_pair("z", 0x5A));
keycodes.insert(make_pair(" ", VK_SPACE));
string phrase = "";
while(phrase == ""){ //make sure they enter something
cin.clear();cin.sync();
cout << "Enter the phrase you wish to spam: ";
getline(cin, phrase);
}
string upper_alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string phrase_copy = phrase; //save the phrase
while(true){
if((GetKeyState(VK_HOME) & 0x80) != 0){
Sleep(50);
while(true){
Generate_Key(VK_RETURN, false); //in-lobby does nothing, but in-game it opens the chat box
Sleep(50);
for(unsigned int iter = 0; iter < phrase.length(); iter++){ //loop through the string
string letter(1, phrase[iter]); //turn each char in the string into a string
if(upper_alpha.find(letter) != string::npos){ //if the letter is found in the uppercase letters
transform(phrase.begin(), phrase.end(), phrase.begin(), ::tolower); //revert the entire string to lowercase (I should do 1 letter, but bleh, I did this quick and dirty) so it can be found in the map
string letter(1, phrase[iter]); //convert that letter back to a string
Generate_Key(keycodes.find(letter)->second, true); //find the letter's keycode, and generate it along with shift
phrase = phrase_copy; //restore the phrase
}
else{ //if the letter is lowercase
transform(phrase.begin(), phrase.end(), phrase.begin(), ::tolower); //same stuff
string letter(1, phrase[iter]);
Generate_Key(keycodes.find(letter)->second, false); //generate it without shift pressed
phrase = phrase_copy;
}
if((GetKeyState(VK_END) & 0x80) != 0){
break;
}
Sleep(1);
}
if((GetKeyState(VK_END) & 0x80) != 0){
break;
}
Generate_Key(VK_RETURN, false); //actually send the phrase
int count = 1;
while(count < sleep_time){ //this is so the user can end it even when it's pausing between spams
Sleep(1);
count++;
if((GetKeyState(VK_END) & 0x80) != 0){
break;
}
}
if(count < sleep_time){ //if the user ended it early, end it completely
break;
}
}
Sleep(1);
}
}
return 0;
}
Code:
#define WINVER 0x0500 //windows version XP or higher
#include <iostream>
#include <windows.h>
#include <time.h>
#include <winable.h>
#include <map>
#include <algorithm> //for looping through the map
#include <pthread.h> //threading
#include <ctime> //for the time stuff in the mouse hook
#include <sys/timeb.h> //time stuff in the mouse hook. These two may not be necessary, I had a different time loop that I was using and forgot to remove these 2
#include <vector>
using namespace std;
HHOOK mousehook;
bool chat_active = false;
bool command_active = false;
int qswitch_key;
//==========================//
int crouch_key;
//==========================//
int walk_key;
//==========================//
int scope_speed_milliseconds;
//==========================//
bool burst;
int burst_amount;
int burst_speed;
int click_amount;
//==========================//
void Generate_Key(int key){
INPUT input;
input.type = INPUT_KEYBOARD;
input.ki.wScan = 0;
input.ki.time = 0;
input.ki.dwExtraInfo = 0;
input.ki.wVk = key;
SendInput(1, &input, sizeof(INPUT));
input.ki.dwFlags = KEYEVENTF_KEYUP;
SendInput(1, &input, sizeof(INPUT));
}
void Generate_Key_down(int key){
INPUT input;
input.type = INPUT_KEYBOARD;
input.ki.wScan = 0;
input.ki.time = 0;
input.ki.dwExtraInfo = 0;
input.ki.wVk = key;
SendInput(1, &input, sizeof(INPUT));
}
void Generate_Key_up(int key){
INPUT input;
input.type = INPUT_KEYBOARD;
input.ki.wScan = 0;
input.ki.time = 0;
input.ki.dwExtraInfo = 0;
input.ki.wVk = key;
input.ki.dwFlags = KEYEVENTF_KEYUP;
SendInput(1, &input, sizeof(INPUT));
}
void unclick(bool middle_or_right){
INPUT input = {0};
//input.mi.dwExtraInfo = 0x200;
input.type = INPUT_MOUSE;
if(middle_or_right){ //
input.mi.dwFlags = MOUSEEVENTF_MIDDLEUP;
SendInput(1, &input, sizeof(INPUT));
}
else if(!middle_or_right){
input.mi.dwFlags = MOUSEEVENTF_RIGHTUP;
SendInput(1, &input, sizeof(INPUT));
}
}
void click(bool middle_or_right){
INPUT input = {0};
//input.mi.dwExtraInfo = 0x200;
input.type = INPUT_MOUSE;
if(middle_or_right){
input.mi.dwFlags = MOUSEEVENTF_MIDDLEDOWN;
SendInput(1, &input, sizeof(INPUT));
}
else if(!middle_or_right){
input.mi.dwFlags = MOUSEEVENTF_RIGHTDOWN;
SendInput(1, &input, sizeof(INPUT));
}
}
void macro_click(){ //this is a separate function because I didn't wanna have to call the click/unclick functions with their parameters for a simple click
INPUT input={0};
// middle down
input.type = INPUT_MOUSE;
input.mi.dwFlags = MOUSEEVENTF_MIDDLEDOWN;
SendInput(1,&input,sizeof(INPUT));
// middle up
input.type = INPUT_MOUSE;
input.mi.dwFlags = MOUSEEVENTF_MIDDLEUP;
SendInput(1,&input,sizeof(INPUT));
}
clock_t start;
float duration;
MSG msg;
int wep_spot = 1;
LRESULT CALLBACK MouseHookProc(int nCode, WPARAM wParam, LPARAM lParam) { //hook for mouse wheel
if (nCode >= 0) {
if (wParam == WM_MOUSEWHEEL){ //only care if the mouse wheel moves
bool cont = true;
duration = (clock() - start ) / (float) CLOCKS_PER_SEC; //I kinda forgot what this does, something about the mouse wheel scrolling too fast and AVA not being able to keep up
if(duration < 0.01){
cont = false;
}
else{
start = -1;
}
if(cont){
if(start == -1){
start = clock();
}
MSLLHOOKSTRUCT *pMhs = (MSLLHOOKSTRUCT *)lParam;
short zDelta = HIWORD(pMhs->mouseData); //get how much the wheel moved
if(duration > 0.05){ //this is where it really stops the mouse wheel from switching the program's wep spot too fast
if(zDelta < 0){ //if it moved down
if(wep_spot < 4){ //move the wep spot that way
wep_spot++;
}
else{ //if the wep spot goes past 1 grenade, cycle back to the primary weapon
wep_spot = 1;
}
}
else if(zDelta > 0){ //vice versa for when the mouse wheel moves up
if(wep_spot == 1){
wep_spot = 4;
}
else{
wep_spot--;
}
}
}
}
}
}
return CallNextHookEx(0, nCode, wParam, lParam);
}
int prev_wep = 2; //default prev wep is the pistol, so I default to that
void* mouse_event_loop(void* ignore){ //this was originally an event loop for the mouse, but I changed it and forgot to change the name. I repurposed it for the sake of catching the Switch key when the user switches weapons
while(true){
if(!chat_active && !command_active){
Sleep(250);
if((GetKeyState(qswitch_key) & 0x80) != 0){
int temp = wep_spot; //save the wep spot (will become the previous wep spot)
wep_spot = prev_wep; //update the current wep spot to the prev wep spot
prev_wep = temp; //set the prev wep spot to what the prev wep was
}
}
Sleep(1);
}
return NULL;
}
bool qswitch_active = false; //this is for the weapon spot
bool qscope_active = false;
bool qswitch_active_toggled = false; //this is for the 7 and 8 keys
bool qscope_active_toggled = false;
void get_wep(){ //update the weapon spot, turn the qswitch and qscope functions off and on
if(qswitch_active_toggled || qscope_active_toggled){
if(!chat_active && !command_active){
if((GetKeyState(0x31) & 0x80) != 0){
wep_spot = 1;
Sleep(100);
}
if((GetKeyState(0x32) & 0x80) != 0){
wep_spot = 2;
Sleep(100);
}
if((GetKeyState(0x33) & 0x80) != 0){
wep_spot = 3;
Sleep(100);
}
if((GetKeyState(0x34) & 0x80) != 0){
wep_spot = 4;
Sleep(100);
}
if(wep_spot != 1){
if(qswitch_active_toggled){
qswitch_active = false;
}
if(qscope_active_toggled){
qscope_active = false;
}
}
else if(wep_spot == 1){
if(qswitch_active_toggled){
qswitch_active = true;
}
if(qscope_active_toggled){
qscope_active = true;
}
}
}
}
}
int choose_scope_speed(){
cin.clear();cin.sync();
float scope_speed_seconds;
int scope_speed_milliseconds;
cout << "Scope speeds:" << endl;
cout << "0.21s: Mosin Nagant Basic Scope, AWM Precision Scope" << endl;
cout << "0.23s: FR-F2 Sharpshooter Scope, ASW.338 Quick Scope II, AWM Basic Scope, DSR-1 Quick Scope 2, Blaser R93 Sharpshooter Scope" << endl;
cout << "0.25s: ASW.338 Sharpshooter Scope II" << endl;
cout << "0.27s: ASW.338 Basic Scope" << endl;
cout << "0.29s: M24 Basic Scope, SV98 Precision Scope, FR-F2 Basic Scope, DSR-1 Basic Scope, PGM.338 Precision Scope, Blaser R93 Precison Scope" << endl;
cout << "0.30s: SV98 Basic Scope" << endl;
cout << "0.31s: Blaser R93 Basic Scope, FR-F2 Quick Scope, DSR-1 High Powered Scope 2" << endl;
cout << "0.39s: TPG1 High Powered Scope, PGM.338 High Powered Scope" << endl;
cout << "0.43s: TPG1 Basic Scope, PGM.338 Basic Scope" << endl << endl;
cout << "Enter your scope speed in seconds: ";
cin >> scope_speed_seconds;
scope_speed_milliseconds = scope_speed_seconds * 1000;
return scope_speed_milliseconds;
}
string catch_key(map<string, int> keycodes){
while(true){
for(map<string, int>::iterator it = keycodes.begin(); it != keycodes.end(); it++){
int key_int = it->second;
if((GetKeyState(key_int) & 0x80) != 0){
return it->first;
}
}
Sleep(1);
}
}
int choose_key(int type){
Sleep(700);
cin.clear();cin.sync();
map<string, int> keycodes;
keycodes.insert(make_pair("a", 0x41));
keycodes.insert(make_pair("b", 0x42));
keycodes.insert(make_pair("c", 0x43));
keycodes.insert(make_pair("d", 0x44));
keycodes.insert(make_pair("e", 0x45));
keycodes.insert(make_pair("f", 0x46));
keycodes.insert(make_pair("g", 0x47));
keycodes.insert(make_pair("h", 0x48));
keycodes.insert(make_pair("i", 0x49));
keycodes.insert(make_pair("j", 0x4A));
keycodes.insert(make_pair("k", 0x4B));
keycodes.insert(make_pair("l", 0x4C));
keycodes.insert(make_pair("m", 0x4D));
keycodes.insert(make_pair("n", 0x4E));
keycodes.insert(make_pair("o", 0x4F));
keycodes.insert(make_pair("p", 0x50));
keycodes.insert(make_pair("q", 0x51));
keycodes.insert(make_pair("r", 0x52));
keycodes.insert(make_pair("s", 0x53));
keycodes.insert(make_pair("t", 0x54));
keycodes.insert(make_pair("u", 0x55));
keycodes.insert(make_pair("v", 0x56));
keycodes.insert(make_pair("w", 0x57));
keycodes.insert(make_pair("x", 0x58));
keycodes.insert(make_pair("y", 0x59));
keycodes.insert(make_pair("z", 0x5A));
keycodes.insert(make_pair("left control", VK_LCONTROL));
keycodes.insert(make_pair("right control", VK_RCONTROL));
keycodes.insert(make_pair("left click", VK_LBUTTON));
keycodes.insert(make_pair("right click", VK_RBUTTON));
keycodes.insert(make_pair("middle click", VK_MBUTTON));
keycodes.insert(make_pair("enter", VK_RETURN));
keycodes.insert(make_pair("shift", VK_SHIFT));
keycodes.insert(make_pair("alt", VK_MENU));
keycodes.insert(make_pair("capslock", VK_CAPITAL));
keycodes.insert(make_pair("1-2-1", 0x32));
keycodes.insert(make_pair("1-3-1", 0x33));
keycodes.insert(make_pair("1-4-1", 0x34));
if(type == 0){ //switch
cout << "What do you want as your quickswitch key? "; //NOTE: this part was nuts to figure out, because the user never had to press enter. whatever key they had pressed was carrying over into whatever they needed to type next
string key = catch_key(keycodes);
Sleep(250);
Generate_Key(VK_RETURN); //so I press enter for them
cin.clear();
cin.ignore(INT_MAX, '\n'); //then clear the input buffer. I do the same thing for the rest of the blocks
cout << "Your quickswitch key is " << key << endl;
return keycodes.find(key)->second;
}
else if(type == 1){ //crouch
cout << "What do you want as your crouch key? ";
string key = catch_key(keycodes);
Sleep(250);
Generate_Key(VK_RETURN);
cin.clear();
cin.ignore(INT_MAX, '\n');
cout << "Your crouch key is " << key << endl;
return keycodes.find(key)->second;
}
else if(type == 2){
cout << "What do you want as your walk key? ";
string key = catch_key(keycodes);
Sleep(250);
Generate_Key(VK_RETURN);
cin.clear();
cin.ignore(INT_MAX, '\n');
cout << "Your walk key is " << key << endl;
return keycodes.find(key)->second;
}
else{
return -1;
}
}
void* qswitch(void* ignore){
while(true){
while(qswitch_active_toggled){
if(!chat_active && !command_active){
if((GetKeyState(0x38) & 0x80) != 0){
Sleep(200);
if((GetKeyState(0x38) & 0x80) != 0){
cout << "Quickswitch macro paused" << endl;
qswitch_active_toggled = false;
}
}
}
while(qswitch_active_toggled && qswitch_active){
if(!chat_active && !command_active){
if((GetKeyState(0x38) & 0x80) != 0){
Sleep(200);
if((GetKeyState(0x38) & 0x80) != 0){
cout << "Quickswitch macro paused" << endl;
qswitch_active_toggled = false;
}
}
}
if((GetKeyState(VK_LBUTTON) & 0x80) != 0){
click(true);
Sleep(50);
unclick(true);
Sleep(50);
if(qswitch_key == 2 || qswitch_key == 3 || qswitch_key == 4){
Generate_Key(qswitch_key); //quick switch using the key chosen
Sleep(5);
Generate_Key(1); //switch back to main weapon
Sleep(1);
}
else{
Generate_Key(qswitch_key); //quick switch using the key chosen
Sleep(5);
Generate_Key(qswitch_key); //switch back to main weapon
Sleep(1);
}
}
Sleep(1);
}
Sleep(1);
}
if(!chat_active && !command_active){
if((GetKeyState(0x37) & 0x80) != 0){
Sleep(200);
if((GetKeyState(0x37) & 0x80) != 0){
cout << "Quickswitch macro activated" << endl;
qswitch_active_toggled = true;
}
}
}
Sleep(1);
}
return NULL;
}
void* qscope(void* ignore){
while(true){
while(qscope_active_toggled){
if(!chat_active && !command_active){
if((GetKeyState(0x30) & 0x80) != 0){
Sleep(200);
if((GetKeyState(0x30) & 0x80) != 0){
cout << "Quickscope macro paused" << endl;
qscope_active_toggled = false;
}
}
}
while(qscope_active && qscope_active_toggled){
if((GetKeyState(VK_LBUTTON) & 0x80) != 0){
Sleep(50);
click(false); //click right
Sleep(5);
unclick(false); //un_click right
Sleep(scope_speed_milliseconds); //wait for the scope to zoom
click(true); //click middle
Sleep(50);
unclick(true); //un_click middle
if(qswitch_key == 2 || qswitch_key == 3 || qswitch_key == 4){
Generate_Key(qswitch_key); //quick switch using the key chosen
Sleep(5);
Generate_Key(1); //switch back to main weapon
Sleep(1);
}
else{
Generate_Key(qswitch_key); //quick switch using the key chosen
Sleep(5);
Generate_Key(qswitch_key); //switch back to main weapon
Sleep(1);
}
}
if(!chat_active && !command_active){
if((GetKeyState(0x30) & 0x80) != 0){
Sleep(200);
if((GetKeyState(0x30) & 0x80) != 0){
cout << "Quickscope macro paused" << endl;
qscope_active_toggled = false;
}
}
}
Sleep(1);
}
Sleep(1);
}
if(!chat_active && !command_active){
if((GetKeyState(0x39) & 0x80) != 0){
Sleep(200);
if((GetKeyState(0x39) & 0x80) != 0){
cout << "Quickscope macro activated" << endl;
qscope_active_toggled = true;
}
}
}
Sleep(1);
}
return NULL;
}
void* crouch(void* ignore){
bool crouch_active = false;
while(true){
while(crouch_active){
if((GetKeyState(VK_LBUTTON) & 0x80) != 0){
Generate_Key_down(crouch_key);
click(true);
}
else{
Generate_Key_up(crouch_key);
unclick(true);
}
if(!chat_active){
if((GetKeyState(0x28) & 0x80) != 0){
cout << "Crouch macro paused" << endl;
crouch_active = false;
Sleep(100);
}
}
Sleep(1);
}
if(!chat_active){
if((GetKeyState(0x26) & 0x80) != 0){
cout << "Crouch macro activated" << endl;
crouch_active = true;
Sleep(100);
}
}
Sleep(1);
}
return NULL;
}
void* walk(void* ignore){
bool walk_active = false;
while(true){
while(walk_active){
if((GetKeyState(VK_LBUTTON) & 0x80) != 0){
Generate_Key_down(walk_key);
click(true);
}
else{
Generate_Key_up(walk_key);
unclick(true);
}
if(!chat_active){
if((GetKeyState(0x27) & 0x80) != 0){
cout << "Walk macro paused" << endl;
walk_active = false;
Sleep(100);
}
}
Sleep(1);
}
if(!chat_active){
if((GetKeyState(0x25) & 0x80) != 0){
cout << "Walk macro activated" << endl;
walk_active = true;
Sleep(100);
}
}
Sleep(1);
}
return NULL;
}
void* tap(void* ignore){
bool tap_active = false;
int counter1 = 0;
int counter2 = 0;
while(true){
while(tap_active){
if((GetKeyState(VK_LBUTTON) & 0x80) != 0){
if(burst){
while(counter2 < burst_amount){
while(counter1 < click_amount){
macro_click();
Sleep(1000/click_amount);
counter1++;
}
counter1 = 0;
Sleep(burst_speed);
counter2++;
}
counter2 = 0;
}
else{
while(counter1 < click_amount){
macro_click();
Sleep(1000/click_amount);
counter1++;
}
counter1 = 0;
}
}
if(!chat_active){
if((GetKeyState(VK_END) & 0x80) != 0){
cout << "Tap macro paused" << endl;
tap_active = false;
Sleep(100);
}
}
Sleep(1);
}
if(!chat_active){
if((GetKeyState(VK_HOME) & 0x80) != 0){
cout << "Tap macro activated" << endl;
tap_active = true;
Sleep(100);
}
}
Sleep(1);
}
return NULL;
}
void* normal(void* ignore){
bool normal_active = false;
while(true){
while(normal_active){
if((GetKeyState(VK_LBUTTON) & 0x80) != 0){
click(true);
}
else{
unclick(true);
}
if(!chat_active && !command_active){
if((GetKeyState(0x4C) & 0x80) != 0){
cout << "Normal macro paused" << endl;
normal_active = false;
Sleep(100);
}
}
Sleep(1);
}
if(!chat_active && !command_active){
if((GetKeyState(0x4B) & 0x80) != 0){
cout << "Normal macro activated" << endl;
normal_active = true;
Sleep(100);
}
}
Sleep(1);
}
return NULL;
}
void* catch_chat_command(void* ignore){
while(true){
if((GetKeyState(0x5A) & 0x80) != 0){ //z key
if(!command_active){
command_active = true;
cout << "Command menu activated." << endl;
}
else if(command_active){
command_active = false;
cout << "Command menu deactivated." << endl;
}
Sleep(200);
}
if((GetKeyState(0x58) & 0x80) != 0){ //x key
if(!command_active){
command_active = true;
cout << "Command menu activated." << endl;
}
else if(command_active){
command_active = false;
cout << "Command menu deactivated." << endl;
}
Sleep(200);
}
if((GetKeyState(0x43) & 0x80) != 0){ //c key
if(!command_active){
command_active = true;
cout << "Command menu activated." << endl;
}
else if(command_active){
command_active = false;
cout << "Command menu deactivated." << endl;
}
Sleep(200);
}
if((GetKeyState(VK_RETURN) & 0x80) != 0){
if(chat_active){
chat_active = false;
cout << "Chat deactivated." << endl;
}
else if(!chat_active){
chat_active = true;
cout << "Chat activated." << endl;
}
Sleep(300);
}
if(!chat_active){
if((GetKeyState(VK_F9) & 0x80) != 0){
chat_active = true;
cout << "Chat activated." << endl;
}
if((GetKeyState(VK_F10) & 0x80) != 0){
chat_active = true;
cout << "Chat activated." << endl;
}
if((GetKeyState(VK_F11) & 0x80) != 0){
chat_active = true;
cout << "Chat activated." << endl;
}
}
if(command_active){
if((GetKeyState(0x30) & 0x80) != 0){ //#0
Sleep(300); //this drives me crazy. since the threads run at the same time, the user won't be able to press and release a key fast enough for another function (say Quickswitch) to catch it too when this bool goes false. So I threw in these sleeps to allow the user to release the key, but it only half works. I have no idea why, I gave up trying to figure it out
command_active = false;
cout << "Command menu deactivated." << endl;
}
if((GetKeyState(0x31) & 0x80) != 0){ //#1
Sleep(300);
command_active = false;
cout << "Command menu deactivated." << endl;
}
if((GetKeyState(0x32) & 0x80) != 0){ //#2
Sleep(300);
command_active = false;
cout << "Command menu deactivated." << endl;
}
if((GetKeyState(0x33) & 0x80) != 0){ //#3
Sleep(300);
command_active = false;
cout << "Command menu deactivated." << endl;
}
if((GetKeyState(0x34) & 0x80) != 0){ //#4
Sleep(300);
command_active = false;
cout << "Command menu deactivated." << endl;
}
if((GetKeyState(0x35) & 0x80) != 0){ //#5
Sleep(300);
command_active = false;
cout << "Command menu deactivated." << endl;
}
if((GetKeyState(0x36) & 0x80) != 0){ //#6
Sleep(300);
command_active = false;
cout << "Command menu deactivated." << endl;
}
if((GetKeyState(0x37) & 0x80) != 0){ //#7
Sleep(300);
command_active = false;
cout << "Command menu deactivated." << endl;
}
if((GetKeyState(0x38) & 0x80) != 0){ //#8
Sleep(300);
command_active = false;
cout << "Command menu deactivated." << endl;
}
if((GetKeyState(0x39) & 0x80) != 0){ //#9
Sleep(300);
command_active = false;
cout << "Command menu deactivated." << endl;
}
}
Sleep(1);
}
return NULL;
}
bool run_qswitch = false;
bool run_qscope = false;
bool run_crouch = false;
bool run_walk = false;
bool run_tap = false;
void setup(){
if(run_qswitch || run_qscope){
qswitch_key = choose_key(0);
Sleep(700); //each sleep is so the key the user is pressing doesn't carry over to the next key grab
}
//==========================//
if(run_qscope){
scope_speed_milliseconds = choose_scope_speed();
Sleep(700);
}
//==========================//
if(run_crouch){
crouch_key = choose_key(1);
Sleep(700);
}
//==========================//
if(run_walk){
walk_key = choose_key(2);
Sleep(700);
}
//==========================//
if(run_tap){
string response;
while(true){
cout << "Burst? (y/n) ";
cin >> response;
if(response == "y"){
burst = true;
cout << "Wait time between bursts? (in milliseconds) ";
cin >> burst_speed;
cout << "How many bursts? ";
cin >> burst_amount;
break;
}
else if(response == "n"){
break;
}
else{
cout << "Please enter \'y\' or \'n\'" << endl;
}
}
cout << "Clicks per second? ";
cin >> click_amount;
}
}
vector<string> split_string(string split, string token){ //splits a string based on a token //note: I found the original version of this off stackoverflow, but modified it to my needs
vector<string> ret_val{split};
size_t pos;
bool stop_loop = false;
while(true){
unsigned int iter = 0;
for(iter = 0; iter < ret_val.size();iter++){
string split_this = ret_val[iter];
pos = split_this.find(token);
if(pos != string::npos){
ret_val.pop_back();
ret_val.push_back(split_this.substr(0, pos));
ret_val.push_back(split_this.substr(pos+1));
break;
}
if(iter == ret_val.size()-1){
stop_loop = true;
}
}
if(stop_loop){
break;
}
}
return ret_val;
}
int main()
{
string macros_chosen = "";
cout << "1: Quickswitch\n";
cout << "2: Quickscope\n";
cout << "3: Crouch\n";
cout << "4: Walk\n";
cout << "5: Tap\n";
bool chosen = false;
while(!chosen){
cin.clear();cin.sync();
cout << "Select which macros you want to run (enter the numbers separated by single spaces):";
getline(cin, macros_chosen);
vector<string> to_run = split_string(macros_chosen, " "); //get a vector containing the numbers separated out
for(vector<string>::iterator it = to_run.begin(); it != to_run.end(); it++){
string num = *it;
switch(atoi(num.c_str())){
case 1: run_qswitch = true; chosen = true; break;
case 2: run_qscope = true; chosen = true; break;
case 3: run_crouch = true; chosen = true; break;
case 4: run_walk = true; chosen = true; break;
case 5: run_tap = true; chosen = true; break;
default: cout << "Choose at least one of the numbers.\n";
}
}
}
mousehook = SetWindowsHookEx(WH_MOUSE_LL, MouseHookProc, NULL, 0); //mouse hooks are undetected? lel aeria
setup(); //set the macro settings
Sleep(700); //because the program runs so fast, the user will still be pressing buttons in setup() if this sleep isn't here
if(run_qswitch){
pthread_t qswitch_thread;
pthread_create(&qswitch_thread, NULL, &qswitch, NULL);
}
if(run_qscope){
pthread_t qscope_thread;
pthread_create(&qscope_thread, NULL, &qscope, NULL);
}
if(run_crouch){
pthread_t crouch_thread;
pthread_create(&crouch_thread, NULL, &crouch, NULL);
}
if(run_walk){
pthread_t walk_thread;
pthread_create(&walk_thread, NULL, &walk, NULL);
}
if(run_tap){
pthread_t tap_thread;
pthread_create(&tap_thread, NULL, &tap, NULL);
}
pthread_t normal_thread;
pthread_t catch_thread;
pthread_t mouse_thread;
pthread_create(&normal_thread, NULL, &normal, NULL);
pthread_create(&catch_thread, NULL, &catch_chat_command, NULL);
pthread_create(&mouse_thread, NULL, &mouse_event_loop, NULL);
while(true){
Sleep(1);
}
UnhookWindowsHookEx(mousehook);
return 0;
}
Compiled this with Code::Blocks. You still need pthreads (https://www.sourceware.org/pthreads-win32/) to compile this.
