[TUTORIAL] Making a Trainer Using C++ in easiest way

[Naniooooo]

19750946]Well most of players want to learn how to create a DLL to inject in cabalmain. Now it's your turn to Create you own DLL using C++.

Take notes: making it simply or coding it in only 1 C++ Files it will result to Complexity so i applied Object Oriented Programming (OOP) to keep it neat, clean, easy to understand and easy to update.

Added Sampe Cheat and Used Multi Level Pointer

-Change Nation
-Movement Speed
-No Cooldown BM2
-Perfect Combo
-No Skill Delay

Requirements

1.) Visual Studio 2005/2008/2010/2012
2.)

Injector might be use

1.)
2.)
3.)

1.) Run Visual Studio then Click New Project.

 Spoiler

2.) Click Win32, Select Win32 Project then Enter the Name of your DLL then hit OK Button

 Spoiler

3.) After clicking OK Button, the next window pop-up with “Previous”,”Next”, “Finish”,”Cancel”. Click Next Button
4.) Choose DLL then checked Empty Project then hit Finish Button

 Spoiler

5.) After clicking finish, you will see like this.

 Spoiler

6.) On Solution Explorer you will add 2 C++ File and 2 Header File.

- Right Click on Header Files > Add > New Item > Select Header File (.h) then name it AllDefines
- Right Click on Header Files > Add > New Item > Select Header File (.h) then name it MyCheat
- Right Click on Source Files > Add > New Item > Select C++ File (.cpp) then name it MainDLL
- Right Click on Source Files > Add > New Item > Select C++ File (.cpp) then name it MyCheat

This is the result after adding files.

 Spoiler

Now will add some sample code.
AllDefines.h

 Spoiler

//============================================================= 1.0.0.200 ========================================================

//BASE ADDRESS
#define ADDR_BASE    0x00A9B820

//MOVEMENT SPEED
#define MOVEMENT_OFFSET 0x204

//NATION (0x0370)
#define NATION_OFFSET 0x0370

//POINTER BELOW IS ONLY WORK IN WIN 7 32BIT AND 64BIT

//BM2 POINTERS 
#define BM2_PTR1 0x3a0
#define BM2_PTR2 0x270
#define BM2_PTR3 0x34c
#define BM2_PTR4 0x124
#define BM2_PTR5 0x20

//PERFECT COMBO
#define CBO_MAIN1 0x3c8
#define CBO_MAIN2 0x2b0
#define CBO_PTR1 0x7d4
#define CBO_PTR2 0x7f1

//NO SKILL DELAY/SP REGEN
#define NSD_PTR1 0x3c8
#define NSD_PTR2 0x2a0
#define NSD_PTR3 0x738
//================================================================================================================================

MyCheat.h

 Spoiler

#include "AllDefines.h"
//====================== CHANGE NATION ================================
void CHANGE_NATION()
{
	if(*(DWORD*)(*(DWORD*)ADDR_BASE+NATION_OFFSET) == 3)
		*(DWORD*)(*(DWORD*)ADDR_BASE+NATION_OFFSET) = 0;
	else
		*(DWORD*)(*(DWORD*)ADDR_BASE+NATION_OFFSET) += 1;

	Sleep(500);
}
//====================================================================

//====================== MOVEMENT SPEED ==============================
void MOVE_SPEED(float Speed)
{
	*(float*)(*(DWORD*)ADDR_BASE+MOVEMENT_OFFSET) = Speed;
}
//====================================================================

//THIS MULTI LEVEL OFFSET FOR BM2, COMBO AND NSD IS ONLY WORK IN WIN 7 32BIT AND 64BIT
//====================== BM2 =========================================
void NOCD_BM2()
{
	DWORD *BM2_1 = (DWORD*)(*(DWORD*)ADDR_BASE + BM2_PTR1);
	DWORD *BM2_2 = (DWORD*)(*(DWORD*)BM2_1 + BM2_PTR2);
	DWORD *BM2_3 = (DWORD*)(*(DWORD*)BM2_2 + BM2_PTR3);
	DWORD *BM2_4 = (DWORD*)(*(DWORD*)BM2_3 + BM2_PTR4);
	*(DWORD*)(*(DWORD*)BM2_4 + BM2_PTR5) = 0x0;
}
//====================================================================

//====================== PERFECT COMBO ===============================
void NOCD_COMBO()
{
	//SIMILAR POINTER
	DWORD *MAIN_1 = (DWORD*)(*(DWORD*)ADDR_BASE + CBO_MAIN1);
	DWORD *MAIN_2 = (DWORD*)(*(DWORD*)MAIN_1 + CBO_MAIN2);
	//COMBO
	*(DWORD*)(*(DWORD*)MAIN_2 + CBO_PTR1) = 0x0;
	*(DWORD*)(*(DWORD*)MAIN_2 + CBO_PTR2) = 0x0;
}
//====================================================================

//====================== NO SKILL DELAY ==============================
void NSD()
{
	DWORD *NSD_1 = (DWORD*)(*(DWORD*)ADDR_BASE + NSD_PTR1);
	DWORD *NSD_2 = (DWORD*)(*(DWORD*)NSD_1 + NSD_PTR2);
	*(DWORD*)(*(DWORD*)NSD_2 + NSD_PTR3) = 1629697;
}
//====================================================================

MyCheat.cpp

 Spoiler

#include <windows.h>
#include "MyCheat.h"

void Start()
{	
	bool OnSpeed,OnBM2,OnCombo,OnNSD;
	char * CAPTION = "My Sample DLL";

	while(true)
	{
		//================================ CHANGE NATION ===================================================
		if (GetKeyState(VK_F11) < 0) {CHANGE_NATION();}
		//==================================================================================================

		//================================ MOVEMENT SPEED ==================================================
		if (GetKeyState(VK_F12) < 0) 
		{
			if(!OnSpeed){
				OnSpeed = true;
				MessageBoxA (NULL,"Movement Speed ON",CAPTION,MB_OK);
			}else{
				OnSpeed = false;
				MOVE_SPEED(450.0);
				MessageBoxA (NULL,"Movement Speed OFF",CAPTION,MB_OK);
			}
		}
		//==================================================================================================

		//THIS BM2, COMBO AND NSD IS ONLY WORK IN WIN 7 32BIT AND 64BIT

		//================================ NO COOLDOWN BM2 =================================================
		if (GetKeyState(VK_F10) < 0) 
		{
			if(!OnBM2){
				OnBM2 = true;
				MessageBoxA (NULL,"No Cooldown BM2 ON",CAPTION,MB_OK);
			}else{
				OnBM2 = false;
				MessageBoxA (NULL,"No Cooldown BM2 OFF",CAPTION,MB_OK);
			}
		}
		//==================================================================================================
		
		//================================ PERFECT COMBO ===================================================
		if (GetKeyState(VK_F9) < 0) 
		{
			if(!OnCombo){
				OnCombo = true;
				MessageBoxA (NULL,"PERFECT COMBO ON",CAPTION,MB_OK);
			}else{
				OnCombo = false;
				MessageBoxA (NULL,"PERFECT COMBO OFF",CAPTION,MB_OK);
			}
		}
		//==================================================================================================

		//================================ NO SKILL DELAY ==================================================
		if (GetKeyState(VK_F8) < 0) 
		{
			if(!OnNSD){
				OnNSD = true;
				MessageBoxA (NULL,"No Skill Delay ON",CAPTION,MB_OK);
			}else{
				OnNSD = false;
				MessageBoxA (NULL,"No Skill Delay OFF",CAPTION,MB_OK);
			}
		}
		//==================================================================================================

		//================================ FREEZING VALUE ==================================================
		if(OnSpeed) MOVE_SPEED(600.0);
		if(OnBM2) NOCD_BM2();
		if(OnCombo) NOCD_COMBO();
		if(OnNSD) NSD();
		//==================================================================================================

		Sleep(1);
	}

}

MainDLL.cpp

 Spoiler

#include <windows.h>

extern void Start();

//=========================================================== STARTING POINT =======================================================
BOOL WINAPI DllMain ( HMODULE hModule, DWORD dwReason, LPVOID lpvReserved)
{
    switch ( dwReason ) {
        case DLL_PROCESS_ATTACH:

            DisableThreadLibraryCalls(hModule);

	    CreateThread(0, 0, (LPTHREAD_START_ROUTINE)Start, 0, 0, 0);		
	    MessageBoxA (NULL,"Cheat Activated","My Sample DLL",MB_OK);
            break;            
        case DLL_PROCESS_DETACH:
            break;
        case DLL_THREAD_ATTACH:
            break;
        case DLL_THREAD_DETACH:
            break;
    }
    return TRUE;
}
//==================================================================================================================================

6.) Make it Release to prevent error “msvcp100d.dll”
If you don’t install C++ Redistribution. You will encounter DLL problem.
DEBUG = msvcp100d.dll
RELEASE = msvcp100.dll

 Spoiler

7.) Click Build on Menu then Build MySampleDLL

 Spoiler

8.) After build DLL you will see “Build succeeded” Now the final step is open the Compiled DLL.
On Solution Explorer Click Show All Files > Right Click Release > Click Open Folder in Windows Explorer.

 Spoiler

You will see the MySampleDLL.dll

 Spoiler

Special Thanks:
- for ep9 CE table based on Cabal NA (Support Win 7 32bit and 64bit Only)
- for Simple C++ Code of AOE

Don't forget to HIT THANKS


credits to FUJl

[iamlegend93]

it could work, but it would differently need some time too figure out how too code it

[gawron25]

Little Help

#include "Form1.h"
#include "Functions.h"
#include <winbase.h>


using namespace Test;

void Main (void)
{
    Application::EnableVisualStyles();
    Application::SetCompatibleTextRenderingDefault(false);
    Application::Run(gcnew Form1);
    Application::Exit();
}



DWORD ssPotAdyy = 0x008AA348;
DWORD PotReturn = ssPotAdyy+10;
BYTE disablePOT[] = {0x83, 0x78, 0x08, 0x13};

void __declspec(naked) _stdcall PotASM()
{
    __asm
    {
        cmp dword ptr [eax+0x08],0x01 // checking for HP pot?
        jne [check_mana]
        mov dword ptr[eax+0x08],0x11 // change to auto pot
        mov dword ptr[eax+0x10],0x11
        check_mana:
        cmp dword ptr [eax+0x08],0x02
        jne [finished_check]
        mov dword ptr[eax+0x08],0x12 // change to auto pot
        mov dword ptr[eax+0x10],0x12
        finished_check:
        cmp dword ptr [eax+0x08],0x13
        jmp [PotReturn]
    }
}



void Form1::checkBox1_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{
        if(checkBox1->Checked)
    {
        *(BYTE*)ssPotAdyy = 0xE9;
        *(DWORD*)(ssPotAdyy + 1) = jmp(ssPotAdyy, PotASM); 
        }

    else
    {

        WriteMemory(ssPotAdyy, 4, 0x83, 0x78, 0x08, 0x13);
    };

}


DWORD ssZoomAdyy = 0x00654226;
DWORD ZoomReturn = ssZoomAdyy+5;
BYTE disableZoom[] = {0x83, 0x78, 0x08, 0x13, 0x90, 0x90};

void __declspec(naked) _stdcall ZoomASM()
{
    __asm
    {
        mov [edi+0x04],0xFF // change value to maximum zoom
        movss xmm0,[edi+0x04]
        jmp [ZoomReturn]
    }
}


{
    WriteMemory(*0x00654226, 6, 0x83, 0x78, 0x08, 0x13, 0x90, 0x90);
}



void Form1::checkBox2_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{
        if(checkBox2->Checked)
    {
        *(BYTE*)ssZoomAdyy = 0xE9;
        *(DWORD*)(ssZoomAdyy + 1) = jmp(ssZoomAdyy, ZoomASM); 
        }

    else
    {

        WriteMemory(ssZoomAdyy, 6, 0x83, 0x78, 0x08, 0x13, 0x90, 0x90);
    };

}

[iamlegend93]

always nice too see people sharing something with the community

Even though if everybody got their fingers in this, the game would getting even more destroyed...

[SkyDrag0n]

Originally Posted by iamlegend93

always nice too see people sharing something with the community

Even though if everybody got their fingers in this, the game would getting even more destroyed...

Wait... It's not already?

[iamlegend93]

Originally Posted by SkyDrag0n

Wait... It's not already?

yeah u right... lost all my gear back in august and haven't seen even one single piece of it yet..
gms keep saying, we are investigeting the issue .. dafq

[Naniooooo]

XD
you can find nice things at cabal section
by the way any1 know where i can find gameguard bypass ?

[gawron25]

Form1.cpp

#include <windows.h>
#include "Form1.h"
#include "Functions.h"



using namespace Dekaron_Boost;


void Android(void)
{

    Application::EnableVisualStyles();
    Application::SetCompatibleTextRenderingDefault(false);
    Application::Run(gcnew Dekaron);
    Application::Exit();
}


//AutoPot

DWORD ssPotAdyy = 0x008C17B8;
DWORD PotReturn = ssPotAdyy+10;
BYTE disablePOT[] = {0x83, 0x78, 0x08, 0x13};

void PotASM()
{
    __asm
    {
        cmp dword ptr [eax+0x08],0x01 // checking for HP pot?
        jne [check_mana]
        mov dword ptr[eax+0x08],0x11 // change to auto pot
        mov dword ptr[eax+0x10],0x11
        check_mana:
        cmp dword ptr [eax+0x08],0x02
        jne [finished_check]
        mov dword ptr[eax+0x08],0x12 // change to auto pot
        mov dword ptr[eax+0x10],0x12
        finished_check:
        cmp dword ptr [eax+0x08],0x13
        jmp [PotReturn]
    }
}

void Dekaron::checkBox1_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{
     if(this->checkBox1->Checked)
         {
        *(BYTE*)ssPotAdyy = 0xE9; 
        *(DWORD*)(ssPotAdyy + 1) = jmp(ssPotAdyy, PotASM); 
         }
     else 
        { 
        WriteMemory(ssPotAdyy, 4, 0x83, 0x78, 0x08, 0x13);
         }
}


//Minimap Tele

DWORD ssteleAdyy = 0x0056B023;
DWORD teleReturn = ssPotAdyy+7;
BYTE disabletele[] = {0x8B, 0x80, 0xA0, 0x00, 0x00, 0x00, 0xC3};

void __declspec(naked) _stdcall teleASM()
{
    __asm
    {
        mov eax,00000003
        nop
        ret
        jmp [teleReturn]
    }
}
void Dekaron::checkBox2_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{
     if(this->checkBox2->Checked)
         {
        *(BYTE*)ssteleAdyy = 0xE9; 
        *(DWORD*)(ssteleAdyy + 1) = jmp(ssteleAdyy, teleASM); 
         }
     else 
        { 
        WriteMemory(ssteleAdyy, 7, 0x8B, 0x80, 0xA0, 0x00, 0x00, 0x00, 0xC3);
         }
}


//WallHack

DWORD sswallAdyy = 0x0086BAE9;
DWORD wallReturn = sswallAdyy+12;
BYTE disablewall[] = {0xFF, 0x50, 0x10, 0x8B, 0xF0, 0x8D, 0xBC, 0x24, 0x88, 0x00, 0x00, 0x00, 0xB9, 0x75, 0x04, 0x00, 0x00, 0xF3, 0xA5};

void __declspec(naked) _stdcall wallASM()
{
    __asm

    {
        call dword ptr [eax+0x10]
        mov esi,eax
        lea edi,ss:[esp+0x00000088]
    cmp dword ptr [eax+0x00000402],0x5F626577
        je [check_wall]
    check_wall:
    mov dword ptr [eax+0x00000402],0x5F626577
    mov dword ptr [eax+0x00000406],0x67616D69
    mov dword ptr [eax+0x0000040A],0x616D2E65
    mov dword ptr [eax+0x0000040E],0x00000063
        jmp [wallReturn]

    }
}

void Dekaron::checkBox3_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{
     if(this->checkBox3->Checked)
         {
        *(BYTE*)sswallAdyy = 0xE9; 
        *(DWORD*)(sswallAdyy + 1) = jmp(sswallAdyy, wallASM); 
         }
     else 
        { 
        WriteMemory(sswallAdyy, 19, 0xFF, 0x50, 0x10, 0x8B, 0xF0, 0x8D, 0xBC, 0x24, 0x88, 0x00, 0x00, 0x00, 0xB9, 0x75, 0x04, 0x00, 0x00, 0xF3, 0xA5);
         }
}


//SkillHack

DWORD ssskillAdyy = 0x00506C14;
DWORD skillReturn = ssskillAdyy+6;
BYTE disablekill[] = {0x55, 0x8B, 0xCE, 0x88, 0x47, 0x61};

void __declspec(naked) _stdcall ssskillASM()
{
    __asm
    {
        push ebp
        mov ecx,esi
        mov [edi+0x61],0x0a1
        jmp [skillReturn]
    }
}

void Dekaron::checkBox4_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{
     if(this->checkBox4->Checked)
         {
        *(BYTE*)ssskillAdyy = 0xE9;
        *(DWORD*)(ssskillAdyy + 1) = jmp(ssskillAdyy, ssskillASM); 
         }
     else 
        { 
        WriteMemory(ssskillAdyy, 6, 0x55, 0x8B, 0xCE, 0x88, 0x47, 0x61);
         }
}

//PetHack+NoAnim

DWORD Pdelay1 = 0x004BF3B9;
DWORD Pdelay2 = 0x004BF482;
DWORD Pdelay3 = 0x004BF551;
DWORD Pattack1 = 0x004BF43C;
DWORD Pattack2 = 0x004BF505;
DWORD Pattack3 = 0x004BF5D2;

BYTE enableattack1[] = {0xC7, 0x44, 0x24, 0x24, 0x07, 0x00, 0x00, 0x00};
BYTE enableattack2[] = {0xC7, 0x44, 0x24, 0x24, 0x07, 0x00, 0x00, 0x00};
BYTE enableattack3[] = {0xC7, 0x44, 0x24, 0x20, 0x07, 0x00, 0x00, 0x00};
BYTE disableattack1[] = {0xC7, 0x44, 0x24, 0x24, 0x04, 0x00, 0x00, 0x00};
BYTE disableattack2[] = {0xC7, 0x44, 0x24, 0x24, 0x06, 0x00, 0x00, 0x00};
BYTE disableattack3[] = {0xC7, 0x44, 0x24, 0x20, 0x05, 0x00, 0x00, 0x00};
BYTE enabledelay1[] = {0x8B, 0x68, 0x01};
BYTE enabledelay2[] = {0x8B, 0x68, 0x01};
BYTE enabledelay3[] = {0x8B, 0x68, 0x01};
BYTE disabledelay1[] = {0x8B, 0x68, 0x20};
BYTE disabledelay2[] = {0x8B, 0x68, 0x28};
BYTE disabledelay3[] = {0x8B, 0x68, 0x30};

DWORD ssnoanimAdyy = 0x005C334B;
DWORD noanimReturn = ssnoanimAdyy+6;
BYTE disablenoanim[] = {0xD8, 0x8B, 0x14, 0x01, 0x00, 0x00};

void __declspec(naked) _stdcall noanimASM()
{
    __asm
    {
        mov dword ptr [ebx+0x00000114],0x3C0CCDCC
        fmul dword ptr [ebx+0x00000114]
        jmp [noanimReturn]
    }
}

void Dekaron::checkBox5_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{
     if(this->checkBox5->Checked)
         {
        memcpy((void*)Pdelay1, enabledelay1, sizeof(enabledelay1));
        memcpy((void*)Pdelay2, enabledelay2, sizeof(enabledelay2));
        memcpy((void*)Pdelay3, enabledelay3, sizeof(enabledelay3));
        memcpy((void*)Pattack1, enableattack1, sizeof(enableattack1));
        memcpy((void*)Pattack2, enableattack2, sizeof(enableattack2));
        memcpy((void*)Pattack3, enableattack3, sizeof(enableattack3));
        *(BYTE*)ssnoanimAdyy = 0xE9; 
        *(DWORD*)(ssnoanimAdyy + 1) = jmp(ssnoanimAdyy, noanimASM);
         }
         else
         {
        memcpy((void*)Pdelay1, disabledelay1, sizeof(disabledelay1));
        memcpy((void*)Pdelay2, disabledelay2, sizeof(disabledelay2));
        memcpy((void*)Pdelay3, disabledelay3, sizeof(disabledelay3));
        memcpy((void*)Pattack1, disableattack1, sizeof(disableattack1));
        memcpy((void*)Pattack2, disableattack2, sizeof(disableattack2));
        memcpy((void*)Pattack3, disableattack3, sizeof(disableattack3));
        WriteMemory(ssnoanimAdyy, 6, 0xD8, 0x8B, 0x14, 0x01, 0x00, 0x00);
         }
}


//NonAggro

DWORD aggro1Adyy = 0x005BE6F7;
DWORD aggro1Return = aggro1Adyy+6;
BYTE disableaggro1[] = {0x89, 0x4C, 0x24, 0x48, 0x8B, 0x4F, 0x0C};



void __declspec(naked) _stdcall aggro1ASM()
{
    __asm
    {
        mov [esp+0x48],ecx
        mov [esp+0x30],0x00000000
        mov [esp+0x4C],0x00000000
        mov [esi+0x0000029C],0x00000000
        mov [esi+0x000002D4],0x00000000
        mov [esi+0x000003B4],0x00000000
        mov [esi+0x000003EC],0x00000000
        mov [esi+0x00000424],0x00000000
        mov [esi+0x0000045C],0x00000000
        mov [esi+0x00000240],0x00000000
        mov [esi+0x0000023C],0x00000000
        mov [esi+0x00000238],0x00000000
        mov ecx,[edi+0x0C]
        jmp [aggro1Return]
    }
}

DWORD aggro2Adyy = 0x005BE70F;
DWORD aggro2Return = aggro2Adyy+7;
BYTE disableaggro2[] = {0x0F, 0xB7, 0x86, 0x64, 0x01, 0x00, 0x00};

void __declspec(naked) _stdcall aggro2ASM()
{
    __asm
    {
        movzx eax,word ptr [esi+0x00000160]
        mov byte ptr [esi+0x00000180],0x00
        mov byte ptr [esi+0x00000250],0x00
        mov dword ptr [esi+0x0000024C],0x00000000
        mov dword ptr [esi+0x00000248],0x00000000
        mov dword ptr [esi+0x00000244],0x00000000
        mov eax,0x00000006
        mov [esi+0x00000160],ax
        jmp [aggro2Return]
    }
}


void Dekaron::checkBox6_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{
     if(this->checkBox6->Checked)
         {
        *(DWORD*)aggro1Adyy = 0xE9; 
        *(DWORD*)aggro2Adyy = 0xE9;
        *(DWORD*)(aggro1Adyy + 1) = jmp(aggro1Adyy, aggro1ASM);
        *(DWORD*)(aggro2Adyy + 1) = jmp(aggro2Adyy, aggro2ASM); 
         }
     else 
        { 
        WriteMemory(aggro1Adyy, 7, 0x89, 0x4C, 0x24, 0x48, 0x8B, 0x4F, 0x0C);
        WriteMemory(aggro2Adyy, 7, 0x0F, 0xB7, 0x86, 0x64, 0x01, 0x00, 0x00);
         }
}


DWORD ssdillAdyy = 0x005D265E;
DWORD dillReturn = ssPotAdyy+5;
BYTE disabledill[] = {0x5F, 0x5E, 0xC2, 0x04, 0x00};
#define FuncToCall 0x00566980
DWORD myfunc = FuncToCall;
BYTE *blah3 = new BYTE[2024]; 






    

void __declspec(naked) _stdcall dillASM()
{
    __asm
    {
        mov bx,[edi+0x10]
        mov eax,blah3 
        mov dword ptr [eax],0xE7395B84
        mov dword ptr [eax+0x04],0x00180000
        mov dword ptr [eax+0x08],0x00000000
        mov dword ptr [eax+0x0C],0x05030003
        mov dword ptr [eax+0x10],0x00000500
        mov [eax+0x14],bx
        mov word ptr [eax+0x16],0x1000
        mov ecx,[0x00CA01B0]
        mov bx,0x0001
        push eax
        __asm call dword ptr [myfunc];
        mov ax,0x0001
        pop edi
        pop esi
        ret 0004
        
    }
}
void Dekaron::checkBox7_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{
     if(this->checkBox7->Checked)
         {
        *(BYTE*)ssdillAdyy = 0xE9; 
        *(DWORD*)(ssdillAdyy + 1) = jmp(ssdillAdyy, dillASM); 
         }
     else 
        { 
        WriteMemory(ssdillAdyy, 5, 0x5F, 0x5E, 0xC2, 0x04, 0x00);
         }
}

Form1.h

#pragma once

using namespace System;
using namespace System::ComponentModel;
using namespace System::Collections;
using namespace System::Windows::Forms;
using namespace System::Data;
using namespace System::Drawing;


namespace Dekaron_Boost {

    /// <summary>
    /// Summary for Dekaron_Boost
    ///
    /// WARNING: If you change the name of this class, you will need to change the
    ///          'Resource File Name' property for the managed resource compiler tool
    ///          associated with all .resx files this class depends on.  Otherwise,
    ///          the designers will not be able to interact properly with localized
    ///          resources associated with this form.
    /// </summary>
    public ref class Dekaron : public System::Windows::Forms::Form
    {
    public:
        Dekaron(void)
        {
            InitializeComponent();
            //
            //TODO: Add the constructor code here
            //
        }

    protected:
        /// <summary>
        /// Clean up any resources being used.
        /// </summary>
        ~Dekaron()
        {
            if (components)
            {
                delete components;
            }
        }
    protected: System::Windows::Forms::CheckBox^  checkBox1;
    protected: System::Windows::Forms::CheckBox^  checkBox2;
    protected: System::Windows::Forms::CheckBox^  checkBox3;
    protected: System::Windows::Forms::CheckBox^  checkBox5;
    protected: 





    protected: System::Windows::Forms::CheckBox^  checkBox4;



    protected: System::Windows::Forms::CheckBox^  checkBox6;
    protected: System::Windows::Forms::CheckBox^  checkBox7;
    protected: System::Windows::Forms::Button^  button1;




    protected: System::ComponentModel::IContainer^  components;








    protected:
        /// <summary>
        /// Required designer variable.
        /// </summary>


#pragma region Windows Form Designer generated code
        /// <summary>
        /// Required method for Designer support - do not modify
        /// the contents of this method with the code editor.
        /// </summary>
        void InitializeComponent(void)
        {
            this->checkBox1 = (gcnew System::Windows::Forms::CheckBox());
            this->checkBox2 = (gcnew System::Windows::Forms::CheckBox());
            this->checkBox3 = (gcnew System::Windows::Forms::CheckBox());
            this->checkBox5 = (gcnew System::Windows::Forms::CheckBox());
            this->checkBox4 = (gcnew System::Windows::Forms::CheckBox());
            this->checkBox6 = (gcnew System::Windows::Forms::CheckBox());
            this->checkBox7 = (gcnew System::Windows::Forms::CheckBox());
            this->button1 = (gcnew System::Windows::Forms::Button());
            this->SuspendLayout();
            // 
            // checkBox1
            // 
            this->checkBox1->AutoSize = true;
            this->checkBox1->Location = System::Drawing::Point(12, 12);
            this->checkBox1->Name = L"checkBox1";
            this->checkBox1->Size = System::Drawing::Size(71, 19);
            this->checkBox1->TabIndex = 0;
            this->checkBox1->Text = L"AutoPot";
            this->checkBox1->UseVisualStyleBackColor = true;
            this->checkBox1->CheckedChanged += gcnew System::EventHandler(this, &Dekaron::checkBox1_CheckedChanged);
            // 
            // checkBox2
            // 
            this->checkBox2->AutoSize = true;
            this->checkBox2->Location = System::Drawing::Point(12, 37);
            this->checkBox2->Name = L"checkBox2";
            this->checkBox2->Size = System::Drawing::Size(99, 19);
            this->checkBox2->TabIndex = 2;
            this->checkBox2->Text = L"MiniMap Tele";
            this->checkBox2->UseVisualStyleBackColor = true;
            this->checkBox2->CheckedChanged += gcnew System::EventHandler(this, &Dekaron::checkBox2_CheckedChanged);
            // 
            // checkBox3
            // 
            this->checkBox3->AutoSize = true;
            this->checkBox3->Location = System::Drawing::Point(12, 62);
            this->checkBox3->Name = L"checkBox3";
            this->checkBox3->Size = System::Drawing::Size(80, 19);
            this->checkBox3->TabIndex = 4;
            this->checkBox3->Text = L"WallHack";
            this->checkBox3->UseVisualStyleBackColor = true;
            this->checkBox3->CheckedChanged += gcnew System::EventHandler(this, &Dekaron::checkBox3_CheckedChanged);
            // 
            // checkBox5
            // 
            this->checkBox5->AutoSize = true;
            this->checkBox5->Location = System::Drawing::Point(12, 112);
            this->checkBox5->Name = L"checkBox5";
            this->checkBox5->Size = System::Drawing::Size(74, 19);
            this->checkBox5->TabIndex = 5;
            this->checkBox5->Text = L"PetHack";
            this->checkBox5->UseVisualStyleBackColor = true;
            this->checkBox5->CheckedChanged += gcnew System::EventHandler(this, &Dekaron::checkBox5_CheckedChanged);
            // 
            // checkBox4
            // 
            this->checkBox4->AutoSize = true;
            this->checkBox4->Location = System::Drawing::Point(12, 87);
            this->checkBox4->Name = L"checkBox4";
            this->checkBox4->Size = System::Drawing::Size(79, 19);
            this->checkBox4->TabIndex = 6;
            this->checkBox4->Text = L"SkillHack";
            this->checkBox4->UseVisualStyleBackColor = true;
            this->checkBox4->CheckedChanged += gcnew System::EventHandler(this, &Dekaron::checkBox4_CheckedChanged);
            // 
            // checkBox6
            // 
            this->checkBox6->AutoSize = true;
            this->checkBox6->Location = System::Drawing::Point(12, 137);
            this->checkBox6->Name = L"checkBox6";
            this->checkBox6->Size = System::Drawing::Size(82, 19);
            this->checkBox6->TabIndex = 9;
            this->checkBox6->Text = L"NonAggro";
            this->checkBox6->UseVisualStyleBackColor = true;
            this->checkBox6->CheckedChanged += gcnew System::EventHandler(this, &Dekaron::checkBox6_CheckedChanged);
            // 
            // checkBox7
            // 
            this->checkBox7->AutoSize = true;
            this->checkBox7->Location = System::Drawing::Point(12, 163);
            this->checkBox7->Name = L"checkBox7";
            this->checkBox7->Size = System::Drawing::Size(85, 19);
            this->checkBox7->TabIndex = 10;
            this->checkBox7->Text = L"Pickup DIll";
            this->checkBox7->UseVisualStyleBackColor = true;
            this->checkBox7->CheckedChanged += gcnew System::EventHandler(this, &Dekaron::checkBox7_CheckedChanged);
            // 
            // button1
            // 
            this->button1->AutoSize = true;
            this->button1->AutoSizeMode = System::Windows::Forms::AutoSizeMode::GrowAndShrink;
            this->button1->BackColor = System::Drawing::SystemColors::ControlLight;
            this->button1->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Center;
            this->button1->Dock = System::Windows::Forms::DockStyle::Bottom;
            this->button1->Font = (gcnew System::Drawing::Font(L"Gill Sans Ultra Bold", 9.75F, System::Drawing::FontStyle::Regular, System::Drawing::GraphicsUnit::Point, 
                static_cast<System::Byte>(238)));
            this->button1->ForeColor = System::Drawing::Color::Black;
            this->button1->Location = System::Drawing::Point(0, 331);
            this->button1->Name = L"button1";
            this->button1->Size = System::Drawing::Size(362, 29);
            this->button1->TabIndex = 11;
            this->button1->Text = L"Terminate Dekaron";
            this->button1->UseVisualStyleBackColor = false;
            this->button1->Click += gcnew System::EventHandler(this, &Dekaron::button1_Click_1);
            // 
            // Dekaron
            // 
            this->AccessibleDescription = L"";
            this->AccessibleName = L"";
            this->AutoScaleMode = System::Windows::Forms::AutoScaleMode::None;
            this->AutoSizeMode = System::Windows::Forms::AutoSizeMode::GrowAndShrink;
            this->BackColor = System::Drawing::Color::Black;
            this->BackgroundImageLayout = System::Windows::Forms::ImageLayout::Stretch;
            this->ClientSize = System::Drawing::Size(362, 360);
            this->Controls->Add(this->button1);
            this->Controls->Add(this->checkBox7);
            this->Controls->Add(this->checkBox6);
            this->Controls->Add(this->checkBox4);
            this->Controls->Add(this->checkBox5);
            this->Controls->Add(this->checkBox3);
            this->Controls->Add(this->checkBox2);
            this->Controls->Add(this->checkBox1);
            this->Font = (gcnew System::Drawing::Font(L"Arial", 9, System::Drawing::FontStyle::Bold, System::Drawing::GraphicsUnit::Point, static_cast<System::Byte>(0)));
            this->ForeColor = System::Drawing::Color::Transparent;
            this->FormBorderStyle = System::Windows::Forms::FormBorderStyle::Fixed3D;
            this->Name = L"Dekaron";
            this->ShowIcon = false;
            this->ShowInTaskbar = false;
            this->StartPosition = System::Windows::Forms::FormStartPosition::Manual;
            this->Text = L"Alien Panther  [xGawronx]";
            this->Load += gcnew System::EventHandler(this, &Dekaron::Dekaron_Load);
            this->ResumeLayout(false);
            this->PerformLayout();

        }
#pragma endregion
    protected: System::Void Dekaron_Load(System::Object^  sender, System::EventArgs^  e) {
             }
protected: System::Void checkBox1_CheckedChanged(System::Object^  sender, System::EventArgs^  e);
         
protected: System::Void checkBox2_CheckedChanged(System::Object^  sender, System::EventArgs^  e);
         
protected: System::Void checkBox3_CheckedChanged(System::Object^  sender, System::EventArgs^  e);
         
protected: System::Void checkBox4_CheckedChanged(System::Object^  sender, System::EventArgs^  e);
         
protected: System::Void checkBox5_CheckedChanged(System::Object^  sender, System::EventArgs^  e);
         
protected: System::Void checkBox6_CheckedChanged(System::Object^  sender, System::EventArgs^  e);

protected: System::Void checkBox7_CheckedChanged(System::Object^  sender, System::EventArgs^  e);

protected: System::Void button1_Click_1(System::Object^  sender, System::EventArgs^  e) {

             ExitProcess(0);
         }
};
}

Functions.h

#include <Windows.h>

#define jmp(frm, to) (int)(((int)to - (int)frm) - 5)
#define jne(frm, to) (int)(((int)to - (int)frm) - 5)
#define je(frm, to) (int)(((int)to - (int)frm) - 5)




// don't do anything, it's not a functioni

DWORD ReadPointer1(CONST LPDWORD lpdwBase, CONST INT iOffset) {     __try { return *(LPDWORD)(*lpdwBase + iOffset); }     __except (EXCEPTION_EXECUTE_HANDLER) { return NULL; } }


//Reads a Pointer
unsigned long ReadPointer(unsigned long ulBase, int iOffset) //Now look at my read pointer.
{
    __try { return *(unsigned long*)(*(unsigned long*)ulBase + iOffset); }
    __except (EXCEPTION_EXECUTE_HANDLER) { return 0; }
}

//Reads Negative Pointers
int ReadNegativePointer(int ulBase, int iOffset)
{
    __try { return *(int*)(*(int*)ulBase + iOffset); }
    __except (EXCEPTION_EXECUTE_HANDLER) { return 0; }
}
//Writes a Pointer
bool WritePointer(unsigned long ulBase, int iOffset, int iValue)
{
    __try { *(int*)(*(unsigned long*)ulBase + iOffset) = iValue; return true; }
    __except (EXCEPTION_EXECUTE_HANDLER) { return false; }
}

unsigned long GetPointedAddress(unsigned long ulBase, int iOffset)
{
    __try { return *(unsigned long*)ulBase + iOffset; }
    __except (EXCEPTION_EXECUTE_HANDLER) { return 0; }
}


bool WriteValue(unsigned long ulBase, int iOffset, int iValue)
{
    __try { *(int*)(ulBase + iOffset) = iValue; return true; }
    __except (EXCEPTION_EXECUTE_HANDLER) { return false; }
}
//WritePointer Function---------------------------------------------------------------------
void Memory(PVOID address, void* val, int bytes)
{
    DWORD d, ds;
    VirtualProtect(address, bytes, PAGE_EXECUTE_READWRITE, &d);
    memcpy(address, val, bytes);
    VirtualProtect(address,bytes,d,&ds);
}

//waitn
void MakePageWritable(unsigned long ulAddress, unsigned long ulSize)
{
    MEMORY_BASIC_INFORMATION* mbi = new MEMORY_BASIC_INFORMATION;
    VirtualQuery((void*)ulAddress, mbi, ulSize);
    if (mbi->Protect != PAGE_EXECUTE_READWRITE)
    {
        unsigned long* ulProtect = new unsigned long;
        VirtualProtect((void*)ulAddress, ulSize, PAGE_EXECUTE_READWRITE, ulProtect);
        delete ulProtect;
    }

    delete mbi;
}



//CALL Function------------------------------------------------------
bool Call(unsigned long ulAddress, void* Function, unsigned long ulNops) 
{ 
    __try 
    {  
        *(unsigned char*)ulAddress = 0xE8; 
        *(unsigned long*)(ulAddress + 1) = jmp(ulAddress, Function);  
        memset((void*)(ulAddress + 5), 0x90, ulNops); 
        return true; 
    } 
    __except (EXCEPTION_EXECUTE_HANDLER) { return false; } 
}
//JMPCALL Function------------------------------------------------------
inline DWORD_PTR jmpcall(LPCVOID lpcvSrc, LPCVOID lpcvDest)
{
    return reinterpret_cast<DWORD_PTR>(lpcvDest) - reinterpret_cast<DWORD_PTR>(lpcvSrc) - 5;
}


//MakePageRWX Function------------------------------------------------------
bool MakePageRWX(LPCVOID lpcvMemory)
{
    MEMORY_BASIC_INFORMATION mbiInfo;
    SecureZeroMemory(&mbiInfo, sizeof(MEMORY_BASIC_INFORMATION));

    if (VirtualQuery(lpcvMemory, &mbiInfo, sizeof(mbiInfo)) == 0)
        return false;

    if (mbiInfo.Protect != PAGE_EXECUTE_READWRITE)
    {
        DWORD dwProtect = 0;
        return (VirtualProtect(const_cast<LPVOID>(lpcvMemory), mbiInfo.RegionSize, PAGE_EXECUTE_READWRITE, &dwProtect) != FALSE);
    }

    return true;
}




//JUMPCALL Function------------------------------------------------------
bool JumpCall(bool fJump, const LPBYTE lpbAddress, LPCVOID lpcvHook, const LPBYTE lpbBuffer, size_t cNops)
{
    if (MakePageRWX(reinterpret_cast<LPCVOID>(lpbAddress)))
    {
        if (lpbBuffer != NULL)
            memcpy(reinterpret_cast<void*>(lpbBuffer), reinterpret_cast<const void*>(lpbAddress), cNops + 5);

        *lpbAddress = (fJump ? 0xE9 : 0xE8);
        *reinterpret_cast<LPDWORD>(lpbAddress + 1) = jmpcall(lpbAddress, lpcvHook);

        if (cNops)
            memset(reinterpret_cast<void*>(lpbAddress + 5), 0x90, cNops);

        return true;
    }

    return false;
}


void WriteMemory( unsigned long ulAddress, unsigned char ucAmount, ...)   
{ 
    //MakePageWritable(ulAddress, (unsigned long)ucAmount); //Make memory writable before any modifications are attempted 
    DWORD dwOldProtect; 
    VirtualProtect((void*)ulAddress, ucAmount, PAGE_EXECUTE_READWRITE, &dwOldProtect);//Unprotect memory 

    va_list* va = new va_list; 
    va_start(*va, ucAmount); 

    for (unsigned char ByteToWrite = va_arg(*va, unsigned char), ucIndex = 0; ucIndex < ucAmount; ucIndex++, ByteToWrite = va_arg(*va, unsigned char)) 
    { 
        *(unsigned char*)(ulAddress + ucIndex) = ByteToWrite; 
    } 

    va_end(*va); 
    delete va; 

    VirtualProtect((void*)ulAddress, ucAmount, dwOldProtect, &dwOldProtect);//revert back to the original. 
}

MainDLL.ccp

#include <windows.h>

extern void Android(void);

::BOOL WINAPI DllWork (__in ::HMODULE hModule )
{
    Android();
    return true;
}

::BOOL WINAPI DllMain ( __in ::HMODULE hModule, __in ::DWORD dwReason, __in __reserved ::LPVOID lpvReserved )
{
    ::HANDLE hThread = NULL;

    if ( dwReason == DLL_PROCESS_ATTACH ) 
    {
        if (( hThread = ::CreateThread(NULL, 0, (::LPTHREAD_START_ROUTINE)&DllWork, (::HMODULE)hModule, 0, NULL) ) == NULL ) 
        {
            return FALSE;
        }
        if ( ::CloseHandle(hThread) == FALSE )
        {
                      //do nothing
        }
    }
    return TRUE;
}

[iCraziE]

I tried building this but i get these errors..

---------------------------------------------

EDIT::: Never mind, I figured it out

----------------------------------------------

EDIT2 :: Now I get this when injecting the dll

 Spoiler

heres the warnings when building...

 Spoiler

EDIT3 :: Changed the properties to No CLR Support and now i Just get only the C4793 warnings,
I can still injected the dll but im wondering if the warnings are going to be an issue.

[superlols]

1>------ Build started: Project: DK_Hacks, Configuration: Release Win32 ------
1>  Form1.cpp
1>c:\users\.....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(3): error C2871: 'System' : a namespace with this name does not exist
1>c:\users\....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(4): error C2653: 'System' : is not a class or namespace name
1>c:\users\....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(4): error C2871: 'ComponentModel' : a namespace with this name does not exist
1>c:\users\.....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(5): error C2653: 'System' : is not a class or namespace name
1>c:\users\....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(5): error C2871: 'Collections' : a namespace with this name does not exist
1>c:\users\.....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(6): error C2653: 'System' : is not a class or namespace name
1>c:\users\....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(6): error C2871: 'Forms' : a namespace with this name does not exist
1>c:\users\....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(7): error C2653: 'System' : is not a class or namespace name
1>c:\users\....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(7): error C2871: 'Data' : a namespace with this name does not exist
1>c:\users\.....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(8): error C2653: 'System' : is not a class or namespace name
1>c:\users\.....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(8): error C2871: 'Drawing' : a namespace with this name does not exist
1>c:\users\....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(22): error C2059: syntax error : 'public'
1>c:\users\...\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(22): error C2059: syntax error : 'public'
1>c:\users\....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(22): error C2653: 'System' : is not a class or namespace name
1>c:\users\....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(22): error C2143: syntax error : missing ';' before '{'
1>c:\users\....\documents\visual studio 2010\projects\dk_hacks\dk_hacks\Form1.h(22): error C2447: '{' : missing function header (old-style formal list?)
1>Form1.cpp(338): fatal error C1004: unexpected end-of-file found
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

i'am using the .h from gawron but still giving me errors :/

[iCraziE]

when u create the solution.. instead of making form1.h a header file. right click the header files hit add new, click on windows form, or form.. and label it Form1.h
then when you click form1.h, press F7 or double click the form to view the code.

paste the code gawron provided for form1.h there. also the form1.cpp info should go in the cpp file it creates in the headers section.