#include <Windows.h>
#include "Form1.h"
#include "Functions.h"
#include "Defines.h"
#include "Auto Bot.h"

using namespace GameKillerTrainer;


//Program Opacity
void Form1::numericUpDown1_ValueChanged(System::Object^  sender, System::EventArgs^  e)
{
	double iOpacityValue = Convert::ToDouble(this->numericUpDown1->Text);
	double iOpacity = iOpacityValue / 100;
	this->Opacity = iOpacity;
}


void Form1::button3_Click(System::Object^  sender, System::EventArgs^  e)
{
	ColorDialog^ MyDialog = gcnew ColorDialog();
    MyDialog->AllowFullOpen = false ;
    MyDialog->ShowHelp = true ;
    MyDialog->Color = this->BackColor;

	if ( MyDialog->ShowDialog() == ::DialogResult::OK )
      {
         this->BackColor = MyDialog->Color;
		 BackColor = MyDialog->Color;
		 tabPage1->BackColor = MyDialog->Color;
		 tabPage2->BackColor = MyDialog->Color;
		 tabPage3->BackColor = MyDialog->Color;
      }
}

void Form1::button4_Click(System::Object^  sender, System::EventArgs^  e)
{
	ColorDialog^ MyDialog = gcnew ColorDialog();
    MyDialog->AllowFullOpen = false ;
    MyDialog->ShowHelp = true ;
    MyDialog->Color = this->ForeColor;

	if ( MyDialog->ShowDialog() == ::DialogResult::OK )
      {
         this->ForeColor = MyDialog->Color;
		 ForeColor = MyDialog->Color;

      }
}





/**************
*   Hide MS   *
**************/
//This will hide and restore the MapleStory Window.
//*It will not hide any injected .dlls, as it finds only the MapleStory window.
void Form1::button1_Click(System::Object^  sender, System::EventArgs^  e)
{
	if(this->button1->Text == "Hide MapleStory")
	{
		this->button1->Text = "Show MapleStory";
		HWND hWnd = FindWindowA("MapleStoryClass", NULL);
		ShowWindow(hWnd, SW_HIDE);
	}
	else
	{
		this->button1->Text = "Hide MapleStory";
		HWND hWnd = FindWindowA("MapleStoryClass", NULL);
		ShowWindow(hWnd, SW_SHOW);
	}
}




//Main Function
void Main (void)
{
	//MessageBox:: Show("Made by MoopleFag! ",  "I like big cocks and I cannot lie.");
	Application::EnableVisualStyles();
	Application::SetCompatibleTextRenderingDefault(false);
	Application::Run(gcnew Form1);
	Application::Exit();
}

//Cool Hit effect.
DWORD CoolHitEffect2 = 0x00A00AF6;
BYTE enableCoolHitEffect2[] = {0x83, 0x7C, 0x25, 0x74, 0x01};
BYTE disableCoolHitEffect2[] = {0x83, 0x7C, 0x24, 0x74, 0x00};


void Form1::checkBox1_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
 {

if(this->checkBox1->Checked)
{
		WriteMemory(CoolHitEffect2,5,0x83, 0x7C, 0x25, 0x74, 0x01);
}
else
 {
		WriteMemory(CoolHitEffect2,5,0x83, 0x7C, 0x24, 0x74, 0x00);
        }
 }

//UA.
DWORD US2 = 0x009C80F0;
BYTE enableUS2[] = {0xEB};
BYTE disableUS2[] = {0x7E};

void Form1::checkBox2_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{

if(this->checkBox2->Checked)
{
		WriteMemory(US2,1,0xEB);
}
else
{
		WriteMemory(US2,1,0x7E);
}
}

// Raining Mobs
DWORD RM2 = 0x006A4E16;
BYTE enableRM2[] = {0xD9, 0xC1};
BYTE disableRM2[] = {0xD9, 0xC0};

void Form1::checkBox3_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
 {
if(this->checkBox3->Checked)
{
WriteMemory(RM2,2,0xD9, 0xC1);
}
else
 {
WriteMemory(RM2,2,0xD9, 0xC0);
        }
 }
//Map Speedup
DWORD MSU2 = 0x6666EB03;
BYTE enableMSU2[] = {0x58};
BYTE disableMSU2[] = {0x08};

void Form1::checkBox4_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
 {
if(this->checkBox4->Checked)
{
WriteMemory(MSU2,1,0x58);
}
else
 {
WriteMemory(MSU2,1,0x08);
        }


 }
//Packet Godmode.
DWORD BD2 = 0x00A014E5;
BYTE enableBD2[] = {0x0F, 0x85};
BYTE disableBD2[] = {0x0F, 0x84};

void Form1::checkBox5_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
 {
if(this->checkBox5->Checked)
{
WriteMemory(BD2,2,0x0F, 0x85);
}
else
 {
WriteMemory(BD2,2,0x0F, 0x84);
        }
 }

//Miss Godmode
DWORD MGM2 = 0x009FF73B;
BYTE enableMGM2[] = {0x0F, 0x85};
BYTE disableMGM2[] = {0x0F, 0x84};

void Form1::checkBox6_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
 {

if(this->checkBox6->Checked)
{
WriteMemory(BD2,2,0x0F, 0x85);
}
else
 {
WriteMemory(BD2,2,0x0F, 0x85);
        }
 }
//All Mob KB
DWORD AMK = 0x00695882;
BYTE enableAMK[] = {0x75};
BYTE disableAMK[] = {0x74};

void Form1::checkBox7_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
 {
if(this->checkBox7->Checked)
{
WriteMemory(AMK,1,0x75);
}
else
 {
WriteMemory(AMK,1,0x74);
        }
 }
//Slow Mobs
DWORD SM = 0x006A52CB;
BYTE enableSM[] = {0xB8, 0x00, 0x00, 0x00, 0x00};
BYTE disableSM[] = {0xB8, 0xE8, 0x03, 0x00, 0x00};

void Form1::checkBox8_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
 {
if(this->checkBox8->Checked)
{
WriteMemory(SM,5,0xB8, 0x00, 0x00, 0x00, 0x00);
}
else
 {
WriteMemory(SM,5,0xB8, 0xE8, 0x03, 0x00, 0x00);
        }
 }
//Show Rank
//Needs Udating.
DWORD SR = 0x00A00E0A;
BYTE enableSR[] = {0x90, 0x90, 0x90, 0x90, 0x90, 0x90};
BYTE disableSR[] = {0x0F, 0x84, 0x9F, 0x00, 0x00, 0x00};

void Form1::checkBox9_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
 {
if(this->checkBox9->Checked)
{
WriteMemory(SR,6,0x90, 0x90, 0x90, 0x90, 0x90, 0x90);
}
else
 {
WriteMemory(SR,6,0x0F, 0x84, 0x9F, 0x00, 0x00, 0x00);
        }
 }


//Full Godmode
DWORD FMG = 0x009FF50C;
BYTE enableFMG[] = {0x0F, 0x84};
BYTE disableFMG[] = {0x0F, 0x85};

void Form1::checkBox10_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
 {

if(this->checkBox10->Checked)
{
WriteMemory(FMG,2,0x0F, 0x84);
}
else
 {
WriteMemory(FMG,2,0x0F, 0x85);
        }
 }
//No KB
DWORD NKB = 0x007A9BDB;
BYTE enableNKB[] = {0x00};
BYTE disableNKB[] = {0x01};

void Form1::checkBox11_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
 {

if(this->checkBox11->Checked)
{
WriteMemory(NKB,1,0x00);
}
else
 {
WriteMemory(NKB,1,0x01);
        }
 }

//Pic Typer
DWORD PICT = 0x004F7B65;
BYTE enablePICT[] = {0xEB};
BYTE disablePICT[] = {0x74};

void Form1::checkBox12_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
 {

if(this->checkBox12->Checked)
{
		WriteMemory(PICT, 1, 0xEB);
}
else
 {
		WriteMemory(PICT, 1, 0x74);
 }
 }
//Super Tubi
DWORD ST = 0x004B0DB7;

void Form1::checkBox13_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
 {
if(this->checkBox14->Checked)
{
WriteMemory(ST, 5, 0x09, 0x90, 0x90, 0x90, 0x90, 0x90);
}
else
 {
WriteMemory(ST, 2, 0x89, 0x86, 0xB8, 0x20, 0x00, 0x00);
        }
 }
//No Aran Skill Movement
DWORD NASM = 0x009CB51F;
BYTE enableNASM[] = {0x00};
BYTE disableNASM[] = {0x01};

void Form1::checkBox14_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
 {

if(this->checkBox14->Checked)
{
WriteMemory(NASM, 1, 0x00);
}
else
 {
WriteMemory(NASM, 1, 0x01);
        }
 }

//Block Map Crash Auto Enable---------------------------

DWORD BMC = 0x009B4AF2;

/*void Form1::Form1_Load(System::Object^  sender, System::EventArgs^  e)
{
		WriteMemory(BMC,6,0xE9, 0x0B, 0x1F, 0x00, 0x00, 0x90);
}*/

//--------------------------------------------------------


//CS MOB LAG
DWORD CSMOB = 0x006A628A;
BYTE enableCSMOB[] = {0xB8, 0x00};
BYTE disableCSMOB[] = {0xB8, 0x01};


void Form1::checkBox24_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
 {

if(this->checkBox24->Checked)
{
		WriteMemory(CSMOB,2,0xB8, 0x00);
}
else
 {
		WriteMemory(CSMOB,2,0xB8, 0x01);
        }
 }



//Server MOB LAG
DWORD SSMOB1 = 0x00A05D13;
BYTE enableSSMOB1[] = {0xB8, 0x00};
BYTE disableSSMOB1[] = {0x88, 0x01};


void Form1::checkBox25_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
 {

if(this->checkBox25->Checked)
{
		WriteMemory(SSMOB1,2,0xB8, 0x00);
}
else
 {
		WriteMemory(SSMOB1,2,0x88, 0x01);
        }
 }

//No Skill Move
DWORD NOSKILLM = 0x007A9BDF;
BYTE enableNOSKILLM[] = {0xD8, 0xD2};
BYTE disableNOSKILLM[] = {0xD8, 0xD1};


void Form1::checkBox27_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
 {

if(this->checkBox27->Checked)
{
		WriteMemory(NOSKILLM,2,0xD8, 0xD2);
}
else
 {
		WriteMemory(NOSKILLM,2,0xD8, 0xD1);
        }
 }

//Invisible Mobs
DWORD INVSMOB = 0x0043BD42;
BYTE enableINVSMOB[] = {0x0F, 0x85};
BYTE disableINVSMOB[] = {0x0F, 0x84};


void Form1::checkBox28_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
 {

if(this->checkBox28->Checked)
{
		WriteMemory(INVSMOB,2,0x0F, 0x85);
}
else
 {
		WriteMemory(INVSMOB,2,0x0F, 0x84);
        }
 }


//ALT TUBI
DWORD ALTTUBI = 0x004B10A7;
BYTE enableALTTUBI[] = {0x90, 0x90};
BYTE disableALTTUBI[] = {0x33, 0xc0};


void Form1::checkBox26_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
 {

if(this->checkBox26->Checked)
{
		WriteMemory(ALTTUBI,2,0x90, 0x90);
}
else
 {
		WriteMemory(ALTTUBI,2,0x33, 0xc0);
        }
 }




//Fall Through FLoor.
DWORD FTFAddy = 0x00A64D3C;

void Form1::checkBox23_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
 {

if(this->checkBox23->Checked)
{
WriteMemory(FTFAddy, 1, 0x00);
}
else
 {
WriteMemory(FTFAddy, 1, 0x02);
        }
 }

//HP Auto Potter ComboBox
void Form1::comboBox5_SelectedIndexChanged(System::Object^  sender, System::EventArgs^  e)
{
	HPKey = GetKey(this->comboBox5->SelectedIndex);
}

// MP Auto Potter ComboBox Body
void Form1::comboBox6_SelectedIndexChanged(System::Object^  sender, System::EventArgs^  e)
{
	MPKey = GetKey(this->comboBox6->SelectedIndex);
}

//Auto Attack Combobox
void Form1::comboBox1_SelectedIndexChanged(System::Object^  sender, System::EventArgs^  e)
{
	AttackKey = GetKey(this->comboBox1->SelectedIndex);
}
//Auto Loot ComboBox
void Form1::comboBox2_SelectedIndexChanged(System::Object^  sender, System::EventArgs^  e)
{
	LootKey = GetKey(this->comboBox2->SelectedIndex);
}
//Auto Skill 1 ComboBox
void Form1::comboBox3_SelectedIndexChanged(System::Object^  sender, System::EventArgs^  e)
{
	Skill1Key = GetKey(this->comboBox3->SelectedIndex);
}

//Auto skill 2 ComboBox
void Form1::comboBox4_SelectedIndexChanged(System::Object^  sender, System::EventArgs^  e)
{
	Skill2Key = GetKey(this->comboBox4->SelectedIndex);
}




//Auto Skill 1
void Form1::textBox6_TextChanged(System::Object^  sender, System::EventArgs^  e) //Delay textbox
{
	UserSetAutoSkillDelay1 = Convert::ToInt32(this->textBox6->Text)*1000; //Default delay
}

//Auto Skill 2
void Form1::textBox7_TextChanged(System::Object^  sender, System::EventArgs^  e)// Delay textbox
{
	UserSetAutoSkillDelay2 = Convert::ToInt32(this->textBox7->Text)*1000; //Default delay
}





    #pragma region AutoSkill 1
    // Auto Skill 1 On Delete
    int DeleteInterval = 100;
    bool EnableusingSkill1 = false;
	bool usingSkill1 = true;

    void StartusingAutoSkill1()
    {
            HWND hwnd = FindWindowA("MapleStoryClass", NULL);
            LPARAM lParam = (MapVirtualKeyA((UINT)Skill1Key, 0) << 16) + 1;
            while(EnableusingSkill1)
            {

                    usingSkill1 = true;
                    Sleep(1000);
                    PostMessage(hwnd, WM_KEYDOWN, (WPARAM)Skill1Key, lParam);
                    usingSkill1 = false;
                    Sleep(DeleteInterval);
            }
    }

    void Form1::checkBox20_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
    {
            if(this->checkBox20->Checked)

            {
                    if(this->textBox6->Text == "")
                    {
                            this->checkBox6->Checked = false;
                            MessageBoxW(NULL, L"Please insert a value for Auto Skill 1 in seconds.", L"Alert", MB_OK);
                    }
                    else
                    {
                            EnableusingSkill1 = true;
                            DeleteInterval = Convert::ToInt32(this->textBox6->Text);
                            DeleteInterval = DeleteInterval * 1000;
                            CreateThread(NULL, 0, (::LPTHREAD_START_ROUTINE)&StartusingAutoSkill1, NULL, 0, NULL);
                    }
            }
            else
            {
                    EnableusingSkill1 = false;
            }
    }
    #pragma endregion


    #pragma region AutoSkill 2
    // Auto Skill 2 On Home
    int DeleteInterval2 = 100;
    bool EnableusingSkill2 = false;
	bool usingSkill2 = true;

    void StartusingAutoSkill2()
    {
            HWND hwnd = FindWindowA("MapleStoryClass", NULL);
            LPARAM lParam = (MapVirtualKeyA((UINT)Skill2Key, 0) << 16) + 1;
            while(EnableusingSkill2)
            {

                    usingSkill2 = true;
                    Sleep(1000);
                    PostMessage(hwnd, WM_KEYDOWN, (WPARAM)Skill2Key, lParam);
                    usingSkill2 = false;
                    Sleep(DeleteInterval2);
            }
    }

    void Form1::checkBox21_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
    {
            if(this->checkBox21->Checked)

            {
                    if(this->textBox7->Text == "")
                    {
                            this->checkBox21->Checked = false;
                            MessageBoxW(NULL, L"Please insert a value for Auto Skill 2 in seconds.", L"Alert", MB_OK);
                    }
                    else
                    {
                            EnableusingSkill2 = true;
                            DeleteInterval2 = Convert::ToInt32(this->textBox7->Text);
                            DeleteInterval2 = DeleteInterval2 * 1000;
                            CreateThread(NULL, 0, (::LPTHREAD_START_ROUTINE)&StartusingAutoSkill2, NULL, 0, NULL);
                    }
            }
            else
            {
                    EnableusingSkill1 = false;
            }
    }
    #pragma endregion




//Auto Attack
bool AAF = false;

void AutoA(HWND hwnd)
{
    while(!AutoAExit)
    {
		//Wait., Let me delete my kami first.

while(AAF)
        {
HWND hwnd = FindWindow(TEXT("MapleStoryClass"), 0);
//Finds the MapleStory Window, this does not support multi maple.
LPARAM lParam = (MapVirtualKey(0xA2, 0) << 16) + 1; //A2
PostMessage(hwnd, WM_KEYDOWN, 0xA2, lParam);
//Pushes the key
Sleep(50);
PostMessage(hwnd, WM_KEYUP, 0xA2, lParam);
//Releases the key
Sleep(10);

        }
    }
}
//Auto Attack
void Form1::checkBox18_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{
     if(this->checkBox18->Checked)
     {

        AutoAExit = false; // If enabled AutoAttackExit is false.
        AAF = true;
        CreateThread(NULL, 0, (::LPTHREAD_START_ROUTINE)&AutoA, NULL, 0, NULL);
        //Here we create a thread, see the definition for more information.
     }

     else
     {
        AAF = false;
        AutoAExit = true; //If disabled AutoAttackExit is ture
     }
}

//loot
bool ALF = false;

void AutoL(HWND hwnd)
{
	while(!AutoLExit)
	{



while(ALF)
			{
HWND hwnd = FindWindow(TEXT("MapleStoryClass"), 0);
LPARAM lParam = (MapVirtualKey(LootKey, 0) << 16) + 1;
PostMessage(hwnd, WM_KEYDOWN, LootKey, lParam);
Sleep(50);
PostMessage(hwnd, WM_KEYUP, LootKey, lParam);//LootKey
Sleep(10);

		}
	}
}

//Auto LOOT
void Form1::checkBox19_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{
     if(this->checkBox19->Checked)
     {

		AutoLExit = false;
		ALF = true;
CreateThread(NULL, 0, (::LPTHREAD_START_ROUTINE)&AutoL, NULL, 0, NULL);
//Here we create a thread, see the definition for more information.
     }

     else
     {
	    ALF = false;
		AutoLExit = true;
     }
}

    #pragma region AutoPot
// Auto Pot
int UserSetHP = 200;
int UserSetMP = 50;
int PotDelay = 200;
bool HPExit = false;
bool MPExit = false;


void AutoPotHP()
{
	HWND hwnd = FindWindowA("MapleStoryClass", NULL);
	LPARAM lParam = (MapVirtualKeyA((UINT)HPKey, 0) << 16) + 1;
	LPARAM lParam2 = (MapVirtualKeyA((UINT)MPKey, 0) << 16) + 1;
	while(HPExit)
	{
		if(ReadPointer((unsigned long)GUIInfoBase, (int)HP) < UserSetHP)
		{
            PostMessage(hwnd, WM_KEYDOWN, (WPARAM)HPKey, lParam); // Page Up
			Sleep(PotDelay);
		}
		Sleep(10);
	}
}
//Go.
void AutoPotMP()
{
	HWND hwnd = FindWindowA("MapleStoryClass", NULL);
	LPARAM lParam2 = (MapVirtualKeyA((UINT)MPKey, 0) << 16) + 1;
	while(MPExit)
	{
		if(ReadPointer((unsigned long)GUIInfoBase, (int)MP) < UserSetMP)
		{
			PostMessage(hwnd, WM_KEYDOWN, (WPARAM)MPKey, lParam2); // Page Down
			Sleep(PotDelay);
		}
		Sleep(10);
	}
}

    void Form1::textBox4_TextChanged(System::Object^  sender, System::EventArgs^  e)
    {
            UserSetHP = Convert::ToInt32(this->textBox4->Text);
    }

    void Form1::textBox5_TextChanged(System::Object^  sender, System::EventArgs^  e)
    {
            UserSetMP = Convert::ToInt32(this->textBox5->Text);
    }

    void Form1::checkBox16_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
    {
            if(this->checkBox16->Checked)
            {
                    HPExit = true;
                    PotDelay = Convert::ToInt32(this->textBox4->Text);
                    CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)&AutoPotHP, NULL, NULL, NULL);
            }
            else
            {
                    HPExit = false;
            }
    }
    void Form1::checkBox17_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
    {
            if(this->checkBox17->Checked)
            {
                    MPExit = true;
                    PotDelay = Convert::ToInt32(this->textBox5->Text);
                    CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)&AutoPotMP, NULL, NULL, NULL);
            }
            else
            {
                    MPExit = false;
            }
    }
    #pragma endregion


DWORD ssFlyAdyy = 0x009FD306;
DWORD flyReturn = ssFlyAdyy +6;
BYTE disableFLY[] = {0x0F, 0x84, 0x5C, 0x01, 0x00, 0x00};
void __declspec(naked) flyASM()
{
	__asm
	{
	pushad
mov eax,[0x00DC7CB8] // Mouse Pointer
mov eax,[eax+0x978] // Mouse Location
mov eax,[eax+0x8C] // Mouse X
mov ecx,[0x00DC7CB8] // Mouse Pointer
mov ecx,[ecx+0x978] // Mouse Location
mov ecx,[ecx+0x88] // Mouse Y
mov ebx,[0x00DC775C] // Character Base
mov [ebx+0x43D8],eax // Tele X
mov [ebx+0x43DC],ecx // Tele Y
mov [ebx+0x43D0],01 // Teleport Toggle
popad
jmp [flyReturn]
	}
}

void Form1::checkBox22_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
{

	if(checkBox22->Checked)
	{
		*(BYTE*)ssFlyAdyy = 0xE9; //E9 is the JMP byte and we place it on the 1st byte of the cool hack addy
		*(DWORD*)(ssFlyAdyy + 1) = jmp(ssFlyAdyy, flyASM);
	}
	else
	{

		WriteMemory(ssFlyAdyy, 6, 0x0F, 0x84, 0x5C, 0x01, 0x00, 0x00);
	}

}

//HotKey - SS Mouse Fly - CheckBox22
void Form1::SSMouseflyHotKey_Tick(System::Object^  sender, System::EventArgs^  e)
    {
            if(GetAsyncKeyState(0x7B))
            {
                    if(checkBox9->Text == "SS Mouse Fly* (F12): Off")
                    {
                            checkBox22->Checked = true;
                            checkBox22->Text = "SS Mouse Fly* (F12): On";
                    }
                    else
                    {
                            checkBox22->Checked = false;
                            checkBox22->Text = "SS Mouse Fly* (F12): Off";

                    }
            }
    }

// Kami gMS99.01 ths is was i had before, n
// ----------------------------------------
int xMOB, yMOB;
void Form1::statsTimer_Tick(System::Object^  sender, System::EventArgs^  e)
{
								unsigned long Kami1 = GetPointedAddress(MobBase, Mob1);
                                unsigned long Kami2 = GetPointedAddress(Kami1, Mob2);
                                unsigned long Kami3 = GetPointedAddress(Kami2, Mob3);
                                unsigned long Kami4 = GetPointedAddress(Kami3, Mob4);

                                xMOB = ReadPointer1(LPDWORD(Kami4), MobX);
                                yMOB = ReadPointer1(LPDWORD(Kami4), MobY); //this is what you have. Now im gnna get 2 errors
								label2->Text = xMOB.ToString();
								label1->Text = yMOB.ToString();
}


void Form1::checkBox1337_CheckedChanged(System::Object^  sender, System::EventArgs^  e) {
                        static DWORD KamiAddy = 0x009FD306; //0f 84 ? ? ? ? 8b 8e ? ? ? ? 2b c8
                        static BYTE KamiON[] = {0x0F, 0x85};
                        static BYTE KamiOFF[] = {0x0F, 0x84};

                         if(this->checkBox1337->Checked)
                         {
                                Memory((LPVOID)KamiAddy, KamiON, 2);
                                KamiTimer->Interval = System::Convert::ToInt16(textBox3->Text); // Teleport Delay
                                KamiTimer->Enabled = true;
                        }
                       else
                       {
                               Memory((LPVOID)KamiAddy, KamiOFF, 2);
                        }
               }

void Form1::KamiTimer_Tick(System::Object^  sender, System::EventArgs^  e) {
      {
                if(this->checkBox1337->Checked)
                        {


                                WritePointer(CharBase, TeleportX, Convert::ToInt32(this->label2->Text) - Convert::ToInt32(this->textBox1->Text)); // Kami X
                                WritePointer(CharBase, TeleportY, Convert::ToInt32(this->label1->Text) - Convert::ToInt32(this->textBox2->Text)); // Kami Y
                        }

                 }
}

//--------------------------------------
// End Of Kami
//--------------------------------------