[Release]Testsystem Source

Quote:

Originally Posted by letslearn

Can someone upload these files ?

Thx

look at post #36 it has it

Quote:

Originally Posted by hoseta

could some1 help me with 1 thing?

when mob is disappear or death and i try to search in "for loop < MAX_MOB" for match ID its faill?, -.-,
It seems that it can not find the correct ID.

PS: LA Bot work fine but i need to delate monster from table after kill cuz i wont to attack non exist monster xD.
And one more thing on XP this work sweet, but on win7 after inject i cant even see a welcome message any idea (BIND DONT WORK TOO)?

here is full code:

Spoiler

functions.h

Spoiler

Code:

//------------------------Based on orginal bloodx Source--------------------
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
//----------------------------DECLARATION-----------------------------------
#include "stuff.h"
//Chat & Notice message
#define MAX_P 500
#define MAX_MOB 500
extern DWORD Attacker;
unsigned int atCount=0;
unsigned long Notice_add;
unsigned int AutoBehead = 0;
typedef void (__cdecl* Notice_org)(char*, int); 
typedef int (__cdecl * Chat_org)(char, char*, int);
BYTE pChat[] = {0x55,0x8B,0xEC,0x83,0x3D,0x48,0x2B,0x86,0x00,0x00,0x74,0x17,0x8B,0x45,0x10,0x50}; // pattern //
char * mChat = "xxx????????xxxx"; // mask //
unsigned long Chat_add = Memory::dwFindPattern( 0x00400000,0x00700000,pChat,mChat);
//end
DWORD SpeedValue = 0;
DWORD dX = 0;
DWORD dY = 0;
#define ID_INFO 9010
const char g_szClassName[] = "toolkal based on bloodx source modify by FANEq";
unsigned int nAttackHack = 0;
unsigned int nLABOT = 0;
DWORD HP0 = 0;
unsigned int MonsterCount=0;
unsigned int PlayerCount=0;
char chWindow_Name[100];
char GameMaster1[26];
char GameMaster2[26];
char GameMaster3[26];
char GameMaster4[26];
char GameMaster5[26];
char GameMaster6[26];
char GameMaster7[26];
char GameMaster8[26];
char GameMaster9[26];
char GameMaster10[26];
DWORD ManaKey;
WPARAM key_Mana;
HWND hwndupdate;
HWND EditBoxA;
HWND EditBoxX;
HWND EditBoxY;
DWORD* dwSpeedpointer = (DWORD*)0x006F3840;
DWORD dwMyPlayerUID=0;
DWORD PlayerNear=1;
DWORD Attackhack_AttackMonster;

//----------------------------end-------------------------------------------
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
//---------------------------STRUCT & Function -----------------------------

struct onOFF
{
	unsigned int nWinShow;
	unsigned int nAutoPick;
	unsigned int LOGGED;
	onOFF() {
		nWinShow = 0;
		nAutoPick = 0;
		LOGGED = 0;
	}
};onOFF SWITCHER;

struct Players {
	DWORD dwPlayerUID;
	char szPlayerName[255];
	DWORD dwPlayerX;
	DWORD dwPlayerY;
	DWORD dwPlayerZ;
	BYTE CharacterType;
	int reserved;
};Players Player[MAX_P]={0};

struct Items {
	WORD Itemindex;
	DWORD dwItemID;
	DWORD dwIX;
	DWORD dwIY;
	DWORD Amount;
};Items Itemx;

struct ActiveMonster{
	WORD MonsterID;
	DWORD MonsterIndexID;
	DWORD mX;
	DWORD mY;
	DWORD mHp;
};ActiveMonster ActivateMonsters[MAX_MOB];


void Kal::SpeedHack(DWORD Speed){
	Memory::MemcpyEx(DWORD(((DWORD)*dwSpeedpointer)+0x00004B14),(DWORD)&Speed,4);
}

DWORD Kal::GetCurHP(DWORD dwAttacker,DWORD dwTarget,WORD dwDamage, bool attacktype){
	int i;
	for(i=0; i<=MAX_MOB;i++)
	{
		if(ActivateMonsters[i].MonsterID==dwTarget || ActivateMonsters[i].MonsterID==dwAttacker)
		{
			if(ActivateMonsters[i].MonsterID==dwTarget)ActivateMonsters[i].mHp -= dwDamage;
			break;
		}
	}

return ActivateMonsters[i].mHp;
}

void Kal::MonsterAppear(char *szBuffer){
	int i = 0;
	if (MonsterCount < MAX_MOB)
	{
		while(1){
			if(ActivateMonsters[i].MonsterID==0) break;	
			i++;	
		}
		ActivateMonsters[i].MonsterID			= *(DWORD*)&szBuffer[5];
		ActivateMonsters[i].MonsterIndexID			= *(WORD*)&szBuffer[3];
		ActivateMonsters[i].mX				= *(DWORD*)&szBuffer[9];
		ActivateMonsters[i].mY				= *(DWORD*)&szBuffer[9+4];
		ActivateMonsters[i].mHp				= *(WORD*)&szBuffer[19]; 							//	= *(DWORD*)&szBuffer[19+4]; Hp Current / or Total?
		MonsterCount++;
		//MessageBox(hwndupdate, "incrased ++", "Information", MB_OK); //TESTED
		}
}

void Kal::MonsterDisapear(char *szBuffer){
	DWORD MonsterID=*(DWORD*)&szBuffer[3];
	for(int i=0; i<=MAX_MOB;i++){
		if(ActivateMonsters[i].MonsterID==MonsterID){	
			MonsterCount--;
			memset(&ActivateMonsters[i],0,sizeof(ActivateMonsters[i]));
		char szMyString[10] ={0}; // Have enough storage in character array.
		sprintf(szMyString, "0x%08x",MonsterID);
		//test
		MessageBox(NULL, szMyString, TEXT("  dissapear"), MB_OK) ;
			break;			
		}		
	}

}

void Kal::MonsterMove(char *szBuffer){
	DWORD MonsterID = *(DWORD*)&szBuffer[3];
	int X= szBuffer[7];
	int Y= szBuffer[8];
	for(int i=0; i<=MAX_MOB;i++){
		if(ActivateMonsters[i].MonsterID==MonsterID){
			ActivateMonsters[i].mX+=X;
			ActivateMonsters[i].mY+=Y;
			break;			
		}		
	}
	
}

void Kal::MonsterDie(char *szBuffer){ 
	DWORD MonsterID=*(DWORD*)&szBuffer[3];
	BYTE BehadeState = *(BYTE*)&szBuffer[7];
	//ActivateMonsters[i].MonsterID==0
	for(int i=0; i<=MAX_MOB;i++){

		if(ActivateMonsters[i].MonsterID==MonsterID){

			if (AutoBehead == 1 && BehadeState == 0x08){
				SendKoemV2(0x10,"bbd",1,1,MonsterID);
			}
			memset(&ActivateMonsters[i],0,sizeof(ActivateMonsters[i]));
			MonsterCount--;	
			//test
			MessageBox(hwndupdate, "decrased --", "Information", MB_OK);
			break;			
		}		
	}

}

void Kal::ItemDropped(char* szBuffer)
{
	if(SWITCHER.nAutoPick==1)
	{
				Itemx.Itemindex =*(WORD*)&szBuffer[3];
				Itemx.dwItemID = *(DWORD*)&szBuffer[5];
				Itemx.dwIX = *(DWORD*)&szBuffer[5+4];
				Itemx.dwIY = *(DWORD*)&szBuffer[5+4+4];
				Itemx.Amount = *(DWORD*)&szBuffer[17];
				SendKoemV2(0x20,"ddd",Itemx.dwItemID,Itemx.dwIX/32,Itemx.dwIY/32);
	}
}

// When f3 is pressed storm hack
void Kal::StormHack()
{
	//cordinates Y and Y read
	DWORD_PTR* cordY = reinterpret_cast< DWORD_PTR* >( (*(DWORD_PTR*)0x006F3840) + 0x463C);
	DWORD_PTR* cordX = reinterpret_cast< DWORD_PTR* >( (*(DWORD_PTR*)0x006F3840) + 0x4644);
	unsigned int SetCordX = *cordX;
	unsigned int SetCordY = *cordY;
	//end
	SendKoemV2(0x10,"bdd",43,SetCordX,SetCordY);
}


void Kal::ChatBox(const char *prefix, int mType, char* mFormat,...)
{
        if (!*(DWORD*)0x0070eaf8) { return; }
        char* uText = new char[255];
        char* mText = new char[255];
       DWORD RGBCol;
	//	DWORD cRGBCol;
        DWORD cbCall = 0x00475830;
        if (mType == 1) RGBCol = 0x004080ff; //255 128 64 StudentChat Orange
        /*
                Colours:
                        Flashy Green   : 0x06c40b
                        Sweet Blue         : 0xcd944f
                        Soft Red       : 0x3030ff
                        Flashy Fuchsia : 0xb337f4
        */
     //   else { RGBCol = cRGBCol; } // highly destructive ?
        va_list args;
        va_start(args, mFormat);
        vsprintf_s(mText,255,mFormat,args);
        va_end(args);
        strcpy_s(uText,255,prefix);
        strcat_s(uText,255,mText);
        __asm
        {
                mov eax, RGBCol
                push eax
                mov ecx, uText
                push ecx
                mov dl, 0x40
                push edx
                mov ecx, dword ptr ds:[0x0070eaf8]
                call cbCall
        }
        delete[] mText;
        delete[] uText;
}


void Kal::Notice(int color,char* mFormat,...){
	char* mText = new char[255];
	va_list args;
	va_start(args, mFormat);
	vsprintf_s(mText,255,mFormat,args);
	va_end(args);

	((Notice_org)Notice_add)(mText,color);
}

void Kal::PlayerDisappear(char* szBuffer)
{
	DWORD PlayerID=*(DWORD*)&szBuffer[3];
	for(int i=0; i<=MAX_P;i++)
	{
		if(Player[i].dwPlayerUID==PlayerID)
		{	memset(&Player[i],0,sizeof(Player[i]));					
			Player[i].dwPlayerUID=0;
			PlayerCount--;
			break;			
		}		
	}
}

void Kal::Login(char* szBuffer)
{
	nAttackHack=0;
	nLABOT=0;
	SWITCHER.nAutoPick=0;
	SpeedValue=0;
	dwMyPlayerUID=0;
	PlayerCount=0;
	MonsterCount=0;
	AutoBehead = 0;
	for(int i = 0;i <= MAX_P;i++)
	{
		memset(&Player[i],0,sizeof(Player[i]));
		memset(&ActivateMonsters[i],0,sizeof(Player[i]));
		Player[i].dwPlayerUID=0;
	}
}

void Kal::TP(char* szBuffer)
{
}

void Kal::PlayeMove (char *szBuffer){
	DWORD PlayerID = *(DWORD*)&szBuffer[3];
	int X= szBuffer[7];
	int Y= szBuffer[8];
	int Z= szBuffer[9];
	for(int i=0; i<=MAX_P;i++){
		if(Player[i].dwPlayerUID==PlayerID){
			Player[i].dwPlayerX+=X;
			Player[i].dwPlayerY+=Y;
			Player[i].dwPlayerZ+=Z;
			//cout << "Monster Move: " << Monsters[ActiveMonsters[i].MonsterIndexID].MonsterName << " Coord: (x,y) :" << ActiveMonsters[i].mX << "," << ActiveMonsters[i].mY << endl; 
			break;			
		}		
	}
}
void Kal::PlayerMoveSit(char *szBuffer){
	DWORD PlayerID = *(DWORD*)&szBuffer[3];
	if(Player[0].dwPlayerUID==PlayerID){
		Player[0].dwPlayerX = *(DWORD *)&szBuffer[7];
		Player[0].dwPlayerY = *(DWORD *)&szBuffer[11];
		Player[0].dwPlayerZ	= *(DWORD *)&szBuffer[15];		
	}		
}

void Kal::PlayerAppear(char* szBuffer)
{
	if(PlayerCount <= MAX_P)
	{
	int i;
	for (i = 0;i < MAX_P;i++)
	{
		if (Player[i].dwPlayerUID == 0)
		{
			Player[i].dwPlayerUID=*(DWORD*)&szBuffer[3];
			memcpy((void*)&Player[i].szPlayerName,(void*)((DWORD)szBuffer+7),16);
			Player[i].reserved=strlen(Player[i].szPlayerName);
			Player[i].dwPlayerX=*(DWORD*)&szBuffer[7+Player[i].reserved+2];
			Player[i].dwPlayerY=*(DWORD*)&szBuffer[7+Player[i].reserved+2+4];
			Player[i].dwPlayerZ=*(DWORD*)&szBuffer[7+Player[i].reserved+2+4+4];
			if(dwMyPlayerUID == 0)dwMyPlayerUID=Player[0].dwPlayerUID;
				//Kal::Chat(red,"Player[%s] is in Range @ (%d/%d/%d)",Player[i].szPlayerName,Player[i].dwPlayerX,Player[i].dwPlayerY,Player[i].dwPlayerZ);
				Sleep(1);
			PlayerCount++;
			break; //ender der schleife
		}
	}
	}
}

//----------------------------end-------------------------------------------
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
//---------------------kalonline settings load------------------------------

void Kal::SetManaKey()
{
	switch (ManaKey)
	{
	case 0:
		key_Mana = 0x30;
		break;
	case 1:
		key_Mana = 0x31;
		break;
	case 2:
		key_Mana = 0x32;
		break;
	case 3:
		key_Mana = 0x33;
		break;
	case 4:
		key_Mana = 0x34;
		break;
	case 5:
		key_Mana = 0x35;
		break;
	case 6:
		key_Mana = 0x36;
		break;
	case 7:
		key_Mana = 0x37;
		break;
	case 8:
		key_Mana = 0x38;
		break;
	case 9:
		key_Mana = 0x39;
		break;
	}
}

void Kal::ReadSettings()
{
char temp_key[2];
DWORD destSize;
destSize=100;
int x = 0;
if(x==0)
{
GetPrivateProfileString("KalWindow","Name","NULL",chWindow_Name,destSize,"Testsystem/Settings.ini");
x++;
}
GetPrivateProfileString("Settings","ManaKey","NULL",temp_key,destSize,"Testsystem/Settings.ini");
ManaKey = atoi(temp_key);
Kal::SetManaKey();
GetPrivateProfileString("GM","1","NULL",GameMaster1,destSize,"Testsystem/Settings.ini");
GetPrivateProfileString("GM","2","NULL",GameMaster2,destSize,"Testsystem/Settings.ini");
GetPrivateProfileString("GM","3","NULL",GameMaster3,destSize,"Testsystem/Settings.ini");
GetPrivateProfileString("GM","4","NULL",GameMaster4,destSize,"Testsystem/Settings.ini");
GetPrivateProfileString("GM","5","NULL",GameMaster5,destSize,"Testsystem/Settings.ini");
GetPrivateProfileString("GM","6","NULL",GameMaster6,destSize,"Testsystem/Settings.ini");
GetPrivateProfileString("GM","7","NULL",GameMaster7,destSize,"Testsystem/Settings.ini");
GetPrivateProfileString("GM","8","NULL",GameMaster8,destSize,"Testsystem/Settings.ini");
GetPrivateProfileString("GM","9","NULL",GameMaster9,destSize,"Testsystem/Settings.ini");
GetPrivateProfileString("GM","10","NULL",GameMaster10,destSize,"Testsystem/Settings.ini");
}

main.h

Spoiler

Code:

#ifndef MAIN_H
#define MAIN_H

#pragma once
#define WIN32_LEAN_AND_MEAN             // Exclude rarely-used stuff from Windows headers
// Windows Header Files:

#include <ws2tcpip.h>
#include <WinSock2.h>
#include <detours.h>
#include <Windows.h>
#include <iostream>
#include <io.h>
#include <fcntl.h>
#include <process.h>
#include <math.h>
#include <stdio.h>
#include <fstream>
#include <vector>
#include <iterator>
#include <algorithm>
#include <string>
#include <cstring>

#pragma comment(lib, "detours.lib")
#pragma comment(lib, "ws2_32.lib")
#pragma comment(lib, "winmm.lib")


#define INST_NOP 0x90
#define INST_CALL 0xe8
#define INST_JMP 0xe9
#define INST_BYTE 0x00
#define SHORT_JZ 0x74
#define orange 16594
#define lightblue 15073034
#define violett 12615808
#define green 32768
#define pink 16751615
#define blue 15453831
#define red 255

#undef UNICODE
// TODO: reference additional headers your program requires here
class Memory
{
	public:
	static void ShowWelcomeMessage(HWND hwNd);
	static LPVOID MemcpyEx(DWORD lpDest, DWORD lpSource, int len);
	static unsigned int __stdcall InitSend(void * pParams);
	static bool bDataCompare(const BYTE* pData, const BYTE* bMask, const char* szMask);
	static DWORD dwFindPattern(DWORD dwAddress,DWORD dwLen, BYTE *bMask, char * szMask);
	static DWORD Intercept(int instruction, DWORD lpSource, DWORD lpDest, int len);
};

class Kal
{
	public:
	static DWORD GetCurHP(DWORD dwAttacker,DWORD dwTarget,WORD dwDamage, bool attacktype);
	static void ItemDropped(char* szBuffer);
	static void SetManaKey();
	static void ReadSettings();
	static void SpeedHack(DWORD Speed);
	static void PlayerAppear(char* szBuffer);
	static void ChatBox(const char *prefix,int mType, char* mFormat,...);
	static void StormHack();
	static void Notice(int color,char* mFormat,...);
	static void PlayerDisappear(char* szBuffer);
	static void Login(char* szBuffer);
	static void TP(char* szBuffer);
	static void MonsterAppear(char *szBuffer);
	static void MonsterDisapear(char *szBuffer);
	static void PlayerMoveSit(char *szBuffer);
	static void PlayeMove (char *szBuffer);
	static void MonsterDie(char *szBuffer);
	static void MonsterMove(char *szBuffer);
};


#endif MAIN_H

recv.h

Spoiler

stuff.h

Spoiler

Code:

void Memory::ShowWelcomeMessage(HWND hwNd)
{
	MessageBox(hwNd, "Welcome to toolkal orginal bloodx source modify by FANEq\nBINDS:\n(+)KEY Speed incrase\n(-)KEY Speed decrase\nF2 = AttackHack\nF3 = StormHack\nF4 = AutoPick on\off\nF5 = Window on/off\nF6 = LA HACK on/off\nF7 = BOT\nF8 = AutoSplashy on/off\nF9 = UG\nF11 = AutoBehead on/off\nF12 = Binds Information", "Information", MB_OK);
}

DWORD SendKoemBack;

char SendText[]="SEND TYPE: 0x%0.2x  FORMAT: %s\n";
__declspec (naked) int __cdecl SendKoemV2(BYTE type , char* format, ...)
{
	__asm jmp SendKoemBack
}
extern HANDLE InitSendx;
unsigned int __stdcall Memory::InitSend(void * pParams)
{
	SendKoemBack = ((*(DWORD*)(0x004921F4+1))+(0x004921F4+1)+4);
	CloseHandle(InitSendx);
	_endthreadex(0);
	return NULL;
}

bool Memory::bDataCompare(const BYTE* pData, const BYTE* bMask, const char* szMask)
{
	for(;*szMask;++szMask,++pData,++bMask)
		if(*szMask=='x' && *pData!=*bMask )
			return false;
	return (*szMask) == NULL;
}

DWORD Memory::dwFindPattern(DWORD dwAddress,DWORD dwLen, BYTE *bMask, char * szMask) {
	for(DWORD i=0;i<dwLen;i++)
		if( bDataCompare( (BYTE*)( dwAddress+i ),bMask,szMask) )
			return (DWORD)(dwAddress+i);
	return NULL;
}

DWORD Memory::Intercept(int instruction, DWORD lpSource, DWORD lpDest, int len)
{
	DWORD realtarget;
	LPBYTE buffer = new BYTE[len];

	memset(buffer,0x90,len);

	if (instruction != INST_NOP && len >= 5)
	{
		buffer[(len-5)] = instruction; 
		DWORD dwJMP = (DWORD)lpDest - (lpSource + 5 + (len-5));
		memcpy(&realtarget,(void*)(lpSource+1),4);
		realtarget = realtarget+lpSource+5;
		memcpy(buffer + 1 + (len-5),&dwJMP,4);
	}
	if (instruction == SHORT_JZ)
	{
		buffer[0]=instruction;
		buffer[1]=(BYTE)lpDest;
	}
	if (instruction == INST_BYTE)
	{
		buffer[0]=(BYTE)lpDest;
	}
	MemcpyEx(lpSource, (DWORD) buffer, len);
	delete[] buffer;
	return realtarget;
}

LPVOID Memory::MemcpyEx(DWORD lpDest, DWORD lpSource, int len)
{
	DWORD oldSourceProt,oldDestProt=0;
	VirtualProtect((LPVOID)lpSource,len,PAGE_EXECUTE_READWRITE,&oldSourceProt);
	VirtualProtect((LPVOID)lpDest,len,PAGE_EXECUTE_READWRITE,&oldDestProt);
	memcpy((void*)lpDest,(void*)lpSource,len);
	VirtualProtect((LPVOID)lpDest,len,oldDestProt,&oldDestProt);
	VirtualProtect((LPVOID)lpSource,len,oldSourceProt,&oldSourceProt);
	return (LPVOID)lpDest;
};

functions.cpp

Spoiler

Code:

//--------------------MENU AND ALL FUNCTIONS--------------------------------
//--------------------------------------------------------------------------
//--------------------------include-----------------------------------------
//--------------------------------------------------------------------------
#include "main.h"
#include "functions.h"
#include "recv.h"
//----------------------------end-------------------------------------------
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------
//----------------------------declare---------------------------------------

//----------------------------end-------------------------------------------
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------

LRESULT CALLBACK WndProc(HWND hwnd, UINT Message, WPARAM wParam, LPARAM lParam)
{
	switch(Message)
	{
	case WM_CREATE:
		{
	hwndupdate = hwnd;
	Sleep(1);
	int waiter;
	std::cin >> waiter;

			HMENU hMenu, hSubMenu;
			hMenu = CreateMenu();
			HMENU hCurrent = GetMenu(0);
			AppendMenu(hMenu, MF_STRING ,ID_INFO,  "&Information");
			hSubMenu = CreatePopupMenu();
			SetMenu(hwnd, hMenu);
		}
	case WM_COMMAND:
		switch(LOWORD(wParam))
		{
		case ID_INFO:
			Memory::ShowWelcomeMessage(hwndupdate);
			break;
		}
	default:
		Sleep(3);
		return DefWindowProc(hwnd, Message, wParam, lParam);
	}
	return 0;
}


int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,LPSTR lpCmdLine, int nCmdShow)
{
	WNDCLASSEX wc;
	HWND hwnd;
	MSG Msg;

	wc.cbSize		 = sizeof(WNDCLASSEX);
	wc.style		 = 0;
	wc.lpfnWndProc	 = WndProc;
	wc.cbClsExtra	 = 0;
	wc.cbWndExtra	 = 0;
	wc.hInstance	 = hInstance;
	wc.hIcon		 = NULL;
	wc.hCursor		 = LoadCursor(NULL, IDC_ARROW);
	wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
	wc.lpszMenuName  = NULL;
	wc.lpszClassName = g_szClassName;
	wc.hIconSm		 = NULL;

	if(!RegisterClassEx(&wc))
	{
		MessageBox(NULL, "Window Registration Failed!", "Error!",
			MB_ICONEXCLAMATION | MB_OK);
		return 0;
	}

	//InitConsole();
		//Sleep(500);
		//FindWindow(0, ConsoleTitle);
	hwnd = CreateWindowEx(
		0,
		g_szClassName,
		"toolkal // modify bloodx's source",//Name of the Hack Window
		WS_OVERLAPPEDWINDOW,
		CW_USEDEFAULT, CW_USEDEFAULT, 240, 165,
		NULL, NULL, hInstance, NULL);

	EditBoxA = CreateWindow(TEXT("Edit"),TEXT("200"),WS_CHILD|WS_VISIBLE|WS_THICKFRAME,1, 1, 100 , 30, hwnd, (HMENU) 1, 0, 0);
	EditBoxX = CreateWindow(TEXT("Edit"),TEXT("0"),WS_CHILD|WS_VISIBLE|WS_THICKFRAME,1, 60, 100 , 30, hwnd, (HMENU) 2, 0, 0);
	EditBoxY = CreateWindow(TEXT("Edit"),TEXT("0"),WS_CHILD|WS_VISIBLE|WS_THICKFRAME,110, 60, 100 , 30, hwnd, (HMENU) 3, 0, 0);
	SetWindowText(EditBoxX, "X CORD");
	SetWindowText(EditBoxY, "Y CORD");

	if(hwnd == NULL)
	{
		MessageBox(NULL, "Window Creation Failed!", "Error!",
			MB_ICONEXCLAMATION | MB_OK);
		return 0;
	}
	Memory::ShowWelcomeMessage(hwndupdate);
	ShowWindow(hwnd, nCmdShow);
// widow hiden on start.
	UpdateWindow(hwnd);

	while(GetMessage(&Msg, NULL, 0, 0) > 0)
	{
		TranslateMessage(&Msg);
		DispatchMessage(&Msg);
	}
	return Msg.wParam;
}

extern HANDLE InitConsoleThread;
unsigned int __stdcall ConsoleMenu(void * pParams){ WinMain(NULL,NULL,NULL,1); CloseHandle(InitConsoleThread); _endthreadex(0); return NULL; }


unsigned int __stdcall AttackHackMainThread(void * start_parameter)
{
	while(true)
	{
		Sleep(1);
		if(atCount == 1)
		{
					
				SendKoemV2(0x10,"bbd",3,1,Attackhack_AttackMonster);
				SendKoemV2(0x10,"bbd",16,1,Attackhack_AttackMonster);
				SendKoemV2(0x10,"bbd",9,1,Attackhack_AttackMonster);
				SendKoemV2(0x10,"bbd",21,1,Attackhack_AttackMonster);
				//PostMessage(Kal,WM_KEYDOWN,key_Mana,NULL);
				atCount = 0;
				Sleep(1);
		}
		if(atCount == 2)
		{
		do{
			SendKoemV2(0x10,"bbd",18,1,Attackhack_AttackMonster);
			atCount = 0;
			Sleep(1);
		}while(HP0>30);
			if(HP0==0 || HP0 == 1 || HP0 < 0){
				SendKoemV2(0x10,"bbd",18,1,Attackhack_AttackMonster);
				SendKoemV2(0x10,"bbd",3,1,Attackhack_AttackMonster);
			}
		}
	}

	return 0;
}


// sniff key pressed
unsigned int __stdcall Sniff_KB(void * start_parameter)
{
	while(true)
	{
		Sleep(5); // PROC usage
			if(GetAsyncKeyState(VK_F2) & 1) // HotKey F2 tests.
			{
				if((nAttackHack == 0) && (atCount == 0)){
					nAttackHack=1;
					Kal::ChatBox("[toolkal] ",1,"AttackHack: ON");
					Sleep(500); // avoid keyspam
					goto skip;
					//Kal::Notice(red,"ON");
				}
				if ((nAttackHack == 1) && (atCount == 0)){
					nAttackHack=0;
					Kal::ChatBox("[toolkal] ",1,"AttackHack: OFF");
					Sleep(500); // avoid keyspam
				}
				skip:;
			}
			if(GetAsyncKeyState(VK_F3) & 1) // HotKey F3 Storm Hack
			{
				Kal::StormHack();
				Sleep(5); // avoid keyspam
				
			}
			if(GetAsyncKeyState(VK_F4) & 1) // HotKey F4 AutoPick on/off
			{
				if(SWITCHER.nAutoPick==1){
					SWITCHER.nAutoPick=0;
					Kal::ChatBox("[toolkal] ",1,"AutoPick: OFF");
					Sleep(500); // avoid keyspam
				}else{
					SWITCHER.nAutoPick=1;
					Kal::ChatBox("[toolkal] ",1,"AutoPick: ON");
					Sleep(500); // avoid keyspam
				}
				
			}
			if(GetAsyncKeyState(VK_F5) & 1) // HotKey F3
			{
				if(SWITCHER.nWinShow==1){
					ShowWindow(hwndupdate,0); // window hide
					SWITCHER.nWinShow=0;
					Sleep(500); // avoid keyspam
				}else{
					ShowWindow(hwndupdate,5); // window show
					SWITCHER.nWinShow=1;
					Sleep(500); // avoid keyspam
				}
			}
		if(GetAsyncKeyState(VK_F6) & 1) // Speed Set
			{
				if((nLABOT == 0) && (atCount == 0)){
					nLABOT = 1;
					Kal::ChatBox("[toolkal] ",1,"LAHack: ON");
					Sleep(500); // avoid keyspam
					goto jump;
				}
				if ((nLABOT == 1) && (atCount == 0)){
					nLABOT = 0;
					Kal::ChatBox("[toolkal] ",1,"LAHack: OFF");
					Sleep(500); // avoid keyspam
				}
				jump:;
			}
		if(GetAsyncKeyState(VK_F11) & 1) // Speed Set
			{
				if((AutoBehead == 0) && (atCount == 0)){
					AutoBehead = 1;
					Kal::ChatBox("[toolkal] ",1,"BeheadHack ON");
					Sleep(500); // avoid keyspam
					goto jumper;
				}
				if ((AutoBehead == 1) && (atCount == 0)){
					AutoBehead = 0;
					Kal::ChatBox("[toolkal] ",1,"BeheadHack OFF");
					Sleep(500); // avoid keyspam
				}
				jumper:;
			}
		if(GetAsyncKeyState(VK_F12) & 1) // Bind key info
			{
			Memory::ShowWelcomeMessage(hwndupdate);
			}
		if(GetAsyncKeyState(VK_ADD) & 1) // Speed Set
			{
				if(SpeedValue < 5000)
				{
					SpeedValue+=50;
				Kal::SpeedHack(SpeedValue);
				Kal::ChatBox("[toolkal] ",1,"Speed incrased to %u", SpeedValue);
				Sleep(500); // avoid keyspam
				}
			}
		if(GetAsyncKeyState(VK_SUBTRACT) & 1) // Speed Set
			{
				
				if(SpeedValue > 0)
				{
					SpeedValue-=50;
				Kal::SpeedHack(SpeedValue);
				Kal::ChatBox("[toolkal] ",1,"Speed decrease to %u", SpeedValue);
				Sleep(500); // avoid keyspam
				}
			}
		
	}
	return 0;
}

main.cpp

Spoiler

Code:

#include "main.h"


HANDLE MainThreadx = INVALID_HANDLE_VALUE;
unsigned int MainThreadIID = 0;

HANDLE InitSendx = INVALID_HANDLE_VALUE;
unsigned int InitSendIID = 0;

HANDLE InitMenux = INVALID_HANDLE_VALUE;
unsigned int InitMenuIID = 0;

HANDLE AttackhackThread = INVALID_HANDLE_VALUE;
unsigned int AttackhackID = 0;

HANDLE InitConsoleThread = INVALID_HANDLE_VALUE;
unsigned int InitConsoleThreadID = 0;

HANDLE Sniff_KThread = INVALID_HANDLE_VALUE;
unsigned int Sniff_KThreadID = 0;



extern DWORD dwFindPattern(DWORD dwAddress,DWORD dwLen, BYTE *bMask, char * szMask);
extern DWORD Intercept(int instruction, DWORD lpSource, DWORD lpDest, int len);
extern unsigned int __stdcall InitSend(void * pParams);
extern unsigned int __stdcall InitMenu(void * pParams);
extern unsigned int __stdcall ConsoleMenu(void * pParams);
extern int (__stdcall *DetourRecv)(SOCKET Socket, char *Buffer, int Length, int Flags);
extern int __stdcall FilterRecv(SOCKET Socket, char* Buffer,int iLenght, int iFlags);
HWND hKal, hKal1,hWait;
extern unsigned int __stdcall InitConsole(void * start_parameter);
extern unsigned int __stdcall AttackHackMainThread(void * start_parameter);
extern unsigned int __stdcall Sniff_KB(void * start_parameter);
extern void ReadSettings();
extern char chWindow_Name[100];;


unsigned int __stdcall MainThread(void * pParams)
{
	Sleep(5500);
	BYTE Replacer=0x85;
	DWORD Virutal_add=0x00504DBF-0x00104DBF;
	Memory::MemcpyEx(Virutal_add+0x00104DBF,(DWORD)&Replacer,1);
	Replacer=0x75;
	Memory::MemcpyEx(Virutal_add+0x00104F66,(DWORD)&Replacer,1);
	Memory::MemcpyEx(Virutal_add+0x0010DB66,(DWORD)&Replacer,1);
	Replacer=0x61;
	Memory::MemcpyEx(Virutal_add+0x002A2A6D,(DWORD)&Replacer,1);

	Kal::ReadSettings();


	while(true)
	{
		hKal = FindWindow(NULL,chWindow_Name);
		SetWindowTextA(hKal,"KalOnline toolkal");
		hWait = FindWindow(0,"KalOnline toolkal");
		hKal1 = GetForegroundWindow();
		if (hWait == hKal1) goto endwait;
		Sleep(100);
	}
	endwait:;
	
	DetourRecv = (int (__stdcall *)(SOCKET, char *, int, int))DetourFunction((PBYTE)0x0052F060,(PBYTE)FilterRecv);

	InitSendx = (HANDLE)_beginthreadex(NULL,0,&Memory::InitSend,NULL,NULL,&InitSendIID);

//	load menu
//	InitMenux = (HANDLE)_beginthreadex(NULL,0,&InitMenu,NULL,NULL,&InitMenuIID);

	InitConsoleThread = (HANDLE)_beginthreadex(NULL,0,&ConsoleMenu,NULL,NULL,&InitConsoleThreadID);
	Sniff_KThread = (HANDLE)_beginthreadex(NULL,0,&Sniff_KB,NULL,NULL,&Sniff_KThreadID);
	AttackhackThread = (HANDLE)_beginthreadex(NULL,0,&AttackHackMainThread,NULL,NULL,&AttackhackID);


	CloseHandle(MainThreadx);
	_endthreadex(0);
	return NULL;

}
BOOL APIENTRY DllMain(HMODULE hModule, unsigned long ulCallReason, LPVOID lpReserved) {
	switch(ulCallReason){
	case DLL_PROCESS_ATTACH:
		MainThreadx = (HANDLE)_beginthreadex(NULL,0,&MainThread,NULL,NULL,&MainThreadIID);
		break;
	case DLL_PROCESS_DETACH:

		break;

	}
	return 1;
}

recv.cpp

Spoiler

Code:

#include "main.h"
#include "recv.h"
extern HWND hwndupdate;
extern void ItemDropped(char* szBuffer);
struct SMobx
{
	DWORD MID;
	DWORD X;
	DWORD Y;
	DWORD Z;
	BYTE Classe;
	DWORD HP;
};
SMobx Mob[500]={0};
DWORD mobsx;

DWORD Target;
DWORD Attacker;
void MyRecv(char* szBuffer,int iLenght)
{
	switch(szBuffer[2])
	{
		case ItemDrop:
			Kal::ItemDropped(szBuffer);
		break;
		case PlayerAppear:
			Kal::PlayerAppear(szBuffer);
			break;
		case PlayerDisappear:
			Kal::PlayerDisappear(szBuffer);
			break;
		case SkillAttack:
		{
			DWORD Attacker = *(DWORD*)&szBuffer[3+1];
			DWORD Target  = *(DWORD*)&szBuffer[7+1];
			WORD Damage	 = *(WORD*)&szBuffer[11+3];
				if(nLABOT == 0 && nAttackHack == 0)
				{
				 Kal::GetCurHP(Attacker,Target,Damage,1);
				}
			if(nAttackHack == 1 && nLABOT == 0)
			{
				if(Attacker==dwMyPlayerUID)
				{
					Attackhack_AttackMonster = Target;
					atCount=1;
				}
			}
			if(nLABOT == 1 && nAttackHack == 0)
			{
				if(Attacker==dwMyPlayerUID)
				{
					HP0 = Kal::GetCurHP(Attacker,Target,Damage,0);
					Attackhack_AttackMonster = Target;
					atCount=2;
				}
			}
		break;
		}
		case MonsterNormalAttack:
		{
			Attacker = *(DWORD*)&szBuffer[3];
			Target = *(DWORD*)&szBuffer[7];
			WORD Damage = *(WORD*)&szBuffer[11];

			if(nAttackHack == 1 && nLABOT == 0)
			{
				if(Attacker==dwMyPlayerUID)
				{
					Attackhack_AttackMonster = Target;
					atCount=1;
				}
			}
			if(nLABOT == 1 && nAttackHack == 0)
			{
				if(Attacker==dwMyPlayerUID)
				{
					HP0 = Kal::GetCurHP(Attacker,Target,Damage,0);
					Attackhack_AttackMonster = Target;
					atCount=2;
				}
			}
		break;	
		}	
		case MonsterMove:
			Kal::MonsterMove(szBuffer);
			break;
		case MonsterMoveStop:
			Kal::MonsterMove(szBuffer);
			break;
		case MobApear:
			Kal::MonsterAppear(szBuffer);
			break;
		case PlayerMove:
			Kal::PlayeMove(szBuffer);
			break;
		case PlayerMoveStop:
			break;
		case PlayerMoveSit:
			Kal::PlayerMoveSit(szBuffer);
			break;
		case MonsterDie:
		{
			/*DWORD MonsterID=*(DWORD*)&szBuffer[3];
			BYTE BehadeState = *(BYTE*)&szBuffer[7];	
				if (AutoBehead==1 && BehadeState==0x08)
				{
					SendKoemV2(0x10,"bbd",1,1,MonsterID);	
				}*/
			Kal::MonsterDie(szBuffer);
			break;
		}

		case LOGIN:
			Kal::Login(szBuffer);
			break;
		case GamSTARTnTP:
			Kal::TP(szBuffer);
			break;
	}
}
int (__stdcall *DetourRecv)(SOCKET Socket, char *Buffer, int Length, int Flags);
int ASyncPos = 0;
int FinalSize = 0;
int __stdcall FilterRecv(SOCKET Socket,char *Buffer, int iLength, int iFlags)
{
	if (ASyncPos==FinalSize && FinalSize>0)
	{
		MyRecv(Buffer, ASyncPos);

		ASyncPos = 0;
	}
	int RecvRET = DetourRecv(Socket, Buffer, iLength, iFlags);
	if (RecvRET<0)
	{
		return RecvRET;
	}
	if (ASyncPos==0)
		FinalSize = *((short int*) Buffer);
	ASyncPos+=RecvRET;

	return RecvRET;
}