API tools faq
paste
Advertisement
Rapptz

Puppet.dll

Rapptz
Nov 19th, 2012
385
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 21.86 KB | None | 0 0
raw download clone embed print report
  1. #include "Form1.h"
  2. #include <Windows.h>
  3. #include "Auto.h"
  4. #include "Define.h"
  5. #include "Functions.h"
  6.  
  7. using namespace Puppet;
  8. void Main(void)
  9. {
  10.     MessageBox:: Show("Created by Regaled. Current Version: 99.2", "Puppet");
  11.     Application::EnableVisualStyles();
  12.     Application::SetCompatibleTextRenderingDefault(false);
  13.     Application::Run(gcnew Form1); //change Form1 this to the name of your Form
  14.     Application::Exit();
  15. }
  16.  
  17. //Program Opacity
  18. void Form1::numericUpDown1_ValueChanged(System::Object^  sender, System::EventArgs^  e)
  19. {
  20.     double iOpacityValue = Convert::ToDouble(this->numericUpDown1->Text);
  21.     double iOpacity = iOpacityValue / 100;
  22.     this->Opacity = iOpacity;
  23. }
  24.  
  25. /**************
  26. *   Hide MS   *
  27. **************/
  28. void Form1::button2_Click(System::Object^  sender, System::EventArgs^  e)
  29. {
  30.     if(this->button2->Text == "Hide MapleStory")
  31.     {
  32.         this->button2->Text = "Show MapleStory";
  33.         HWND hWnd = FindWindowA("MapleStoryClass", NULL);
  34.         ShowWindow(hWnd, SW_HIDE);
  35.     }
  36.     else
  37.     {
  38.         this->button2->Text = "Hide MapleStory";
  39.         HWND hWnd = FindWindowA("MapleStoryClass", NULL);
  40.         ShowWindow(hWnd, SW_SHOW);
  41.     }
  42. }
  43.  
  44.  
  45. DWORD SmegaFilterAddy = 0x00B0A7A7;
  46. BYTE enableSmegaFilter [] = {0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90};
  47. BYTE disableSmegaFilter [] = {0xFF, 0x75, 0x0C, 0xE8, 0x2E, 0x4E, 0x02, 0x00};
  48.  
  49. void Form1::checkBox1_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  50. {
  51.  
  52. unsigned long oldProtect;
  53. VirtualProtect((LPVOID)SmegaFilterAddy, 8, PAGE_EXECUTE_READWRITE, &oldProtect);
  54.  
  55. if(this->checkBox1->Checked)
  56. {
  57.       memcpy((void*)SmegaFilterAddy, enableSmegaFilter, sizeof(enableSmegaFilter));
  58. }
  59. else
  60. {
  61.       memcpy((void*)SmegaFilterAddy, disableSmegaFilter, sizeof(disableSmegaFilter));
  62. }
  63. }
  64. DWORD BlockDmgAddy = 0x00A014E5;
  65. BYTE enableBlockDmg [] = {0x0F, 0x85};
  66. BYTE disableBlockDmg [] = {0x0F, 0x84};
  67.  
  68. void Form1::checkBox2_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  69. {
  70.  
  71. unsigned long oldProtect;
  72. VirtualProtect((LPVOID)BlockDmgAddy, 2, PAGE_EXECUTE_READWRITE, &oldProtect);
  73.  
  74. if(this->checkBox2->Checked)
  75. {
  76.       memcpy((void*)BlockDmgAddy, enableBlockDmg, sizeof(enableBlockDmg));
  77. }
  78. else
  79. {
  80.       memcpy((void*)BlockDmgAddy, disableBlockDmg, sizeof(disableBlockDmg));
  81. }
  82. }
  83. DWORD MissGMAddy = 0x009FF73B;
  84. BYTE enableMissGM [] = {0x0F, 0x85};
  85. BYTE disableMissGM [] = {0x0F, 0x84};
  86.  
  87. void Form1::checkBox3_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  88. {
  89.  
  90. unsigned long oldProtect;
  91. VirtualProtect((LPVOID)MissGMAddy, 2, PAGE_EXECUTE_READWRITE, &oldProtect);
  92.  
  93. if(this->checkBox3->Checked)
  94. {
  95.       memcpy((void*)MissGMAddy, enableMissGM, sizeof(enableMissGM));
  96. }
  97. else
  98. {
  99.       memcpy((void*)MissGMAddy, disableMissGM, sizeof(disableMissGM));
  100. }
  101. }
  102. DWORD FullGMAddy = 0x009FF50C;
  103. BYTE enableFullGM [] = {0x0F, 0x84};
  104. BYTE disableFullGM [] = {0x0F, 0x85};
  105.  
  106. void Form1::checkBox4_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  107. {
  108.  
  109. unsigned long oldProtect;
  110. VirtualProtect((LPVOID)FullGMAddy, 2, PAGE_EXECUTE_READWRITE, &oldProtect);
  111.  
  112. if(this->checkBox4->Checked)
  113. {
  114.       memcpy((void*)FullGMAddy, enableFullGM, sizeof(enableFullGM));
  115. }
  116. else
  117. {
  118.       memcpy((void*)FullGMAddy, disableFullGM, sizeof(disableFullGM));
  119. }
  120. }
  121. DWORD AntiDeathAddy = 0x009CD5C8;
  122. BYTE enableAntiDeath [] = {0x74};
  123. BYTE disableAntiDeath [] = {0xEB};
  124.  
  125. void Form1::checkBox5_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  126. {
  127.  
  128. unsigned long oldProtect;
  129. VirtualProtect((LPVOID)AntiDeathAddy, 1, PAGE_EXECUTE_READWRITE, &oldProtect);
  130.  
  131. if(this->checkBox5->Checked)
  132. {
  133.       memcpy((void*)AntiDeathAddy, enableAntiDeath, sizeof(enableAntiDeath));
  134. }
  135. else
  136. {
  137.       memcpy((void*)AntiDeathAddy, disableAntiDeath, sizeof(disableAntiDeath));
  138. }
  139. }
  140. DWORD BlinkGMAddy = 0x009C202D;
  141. BYTE enableBlinkGM [] = {0xEB, 0x21};
  142. BYTE disableBlinkGM [] = {0x7E, 0x21};
  143.  
  144. void Form1::checkBox6_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  145. {
  146.  
  147. unsigned long oldProtect;
  148. VirtualProtect((LPVOID)BlinkGMAddy, 2, PAGE_EXECUTE_READWRITE, &oldProtect);
  149.  
  150. if(this->checkBox6->Checked)
  151. {
  152.       memcpy((void*)BlinkGMAddy, enableBlinkGM, sizeof(enableBlinkGM));
  153. }
  154. else
  155. {
  156.       memcpy((void*)BlinkGMAddy, disableBlinkGM, sizeof(disableBlinkGM));
  157. }
  158. }
  159. DWORD PicTypeAddy = 0x004F7B65;
  160. BYTE enablePicType [] = {0xEB};
  161. BYTE disablePicType [] = {0x74};
  162.  
  163. void Form1::checkBox7_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  164. {
  165.  
  166. unsigned long oldProtect;
  167. VirtualProtect((LPVOID)PicTypeAddy, 1, PAGE_EXECUTE_READWRITE, &oldProtect);
  168.  
  169. if(this->checkBox7->Checked)
  170. {
  171.       memcpy((void*)PicTypeAddy, enablePicType, sizeof(enablePicType));
  172. }
  173. else
  174. {
  175.       memcpy((void*)PicTypeAddy, disablePicType, sizeof(disablePicType));
  176. }
  177. }
  178. DWORD PicUncAddy = 0x004F9104;
  179. BYTE enablePicUnc [] = {0x85};
  180. BYTE disablePicUnc [] = {0x84};
  181.  
  182. void Form1::checkBox8_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  183. {
  184.  
  185. unsigned long oldProtect;
  186. VirtualProtect((LPVOID)PicUncAddy, 1, PAGE_EXECUTE_READWRITE, &oldProtect);
  187.  
  188. if(this->checkBox8->Checked)
  189. {
  190.       memcpy((void*)PicUncAddy, enablePicUnc, sizeof(enablePicUnc));
  191. }
  192. else
  193. {
  194.       memcpy((void*)PicUncAddy, disablePicUnc, sizeof(disablePicUnc));
  195. }
  196. }
  197. DWORD NoMovementAddy = 0x007A9BDF;
  198. BYTE enableNoMovement [] = {0x90};
  199. BYTE disableNoMovement [] = {0x06};
  200.  
  201. void Form1::checkBox9_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  202. {
  203.  
  204. unsigned long oldProtect;
  205. VirtualProtect((LPVOID)NoMovementAddy, 1, PAGE_EXECUTE_READWRITE, &oldProtect);
  206.  
  207. if(this->checkBox9->Checked)
  208. {
  209.       memcpy((void*)NoMovementAddy, enableNoMovement, sizeof(enableNoMovement));
  210. }
  211. else
  212. {
  213.       memcpy((void*)NoMovementAddy, disableNoMovement, sizeof(disableNoMovement));
  214. }
  215. }
  216. DWORD AntiBreathAddy = 0x004E329C;
  217. BYTE enableAntiBreath [] = {0x7C};
  218. BYTE disableAntiBreath [] = {0x7D};
  219.  
  220. void Form1::checkBox10_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  221. {
  222.  
  223. unsigned long oldProtect;
  224. VirtualProtect((LPVOID)AntiBreathAddy, 1, PAGE_EXECUTE_READWRITE, &oldProtect);
  225.  
  226. if(this->checkBox10->Checked)
  227. {
  228.       memcpy((void*)AntiBreathAddy, enableAntiBreath, sizeof(enableAntiBreath));
  229. }
  230. else
  231. {
  232.       memcpy((void*)AntiBreathAddy, disableAntiBreath, sizeof(disableAntiBreath));
  233. }
  234. }
  235. DWORD UAAddy = 0x009C80F0;
  236. BYTE enableUA [] = {0xEB};
  237. BYTE disableUA [] = {0x7E};
  238.  
  239. void Form1::checkBox11_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  240. {
  241.  
  242. unsigned long oldProtect;
  243. VirtualProtect((LPVOID)UAAddy, 1, PAGE_EXECUTE_READWRITE, &oldProtect);
  244.  
  245. if(this->checkBox11->Checked)
  246. {
  247.       memcpy((void*)UAAddy, enableUA, sizeof(enableUA));
  248. }
  249. else
  250. {
  251.       memcpy((void*)UAAddy, disableUA, sizeof(disableUA));
  252. }
  253. }
  254. DWORD NoKBAddy = 0x007A9BDB;
  255. BYTE enableNoKB [] = {0x00};
  256. BYTE disableNoKB [] = {0x01};
  257.  
  258. void Form1::checkBox12_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  259. {
  260.  
  261. unsigned long oldProtect;
  262. VirtualProtect((LPVOID)NoKBAddy, 1, PAGE_EXECUTE_READWRITE, &oldProtect);
  263.  
  264. if(this->checkBox12->Checked)
  265. {
  266.       memcpy((void*)NoKBAddy, enableNoKB, sizeof(enableNoKB));
  267. }
  268. else
  269. {
  270.       memcpy((void*)NoKBAddy, disableNoKB, sizeof(disableNoKB));
  271. }
  272. }
  273. DWORD FTFAddy = 0x009E7448;
  274. BYTE enableFTF [] = {0x00};
  275. BYTE disableFTF [] = {0x02};
  276.  
  277. void Form1::checkBox13_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  278. {
  279.  
  280. unsigned long oldProtect;
  281. VirtualProtect((LPVOID)FTFAddy, 1, PAGE_EXECUTE_READWRITE, &oldProtect);
  282.  
  283. if(this->checkBox13->Checked)
  284. {
  285.       memcpy((void*)FTFAddy, enableFTF, sizeof(enableFTF));
  286. }
  287. else
  288. {
  289.       memcpy((void*)FTFAddy, disableFTF, sizeof(disableFTF));
  290. }
  291. }
  292. DWORD MapLeftAddy = 0x00A62A1E;
  293. BYTE enableMapLeft [] = {0x74, 0x09};
  294. BYTE disableMapLeft [] = {0x7D, 0x09};
  295.  
  296. void Form1::checkBox14_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  297. {
  298.  
  299. unsigned long oldProtect;
  300. VirtualProtect((LPVOID)MapLeftAddy, 2, PAGE_EXECUTE_READWRITE, &oldProtect);
  301.  
  302. if(this->checkBox14->Checked)
  303. {
  304.       memcpy((void*)MapLeftAddy, enableMapLeft, sizeof(enableMapLeft));
  305. }
  306. else
  307. {
  308.       memcpy((void*)MapLeftAddy, disableMapLeft, sizeof(disableMapLeft));
  309. }
  310. }
  311. DWORD MapRightAddy = 0x00A62A20;
  312. BYTE enableMapRight [] = {0x89, 0x9C, 0x24, 0xB0, 0x00, 0x00, 0x00};
  313. BYTE disableMapRight [] = {0x89, 0x84, 0x24, 0xB0, 0x00, 0x00, 0x00};
  314.  
  315. void Form1::checkBox15_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  316. {
  317.  
  318. unsigned long oldProtect;
  319. VirtualProtect((LPVOID)MapRightAddy, 7, PAGE_EXECUTE_READWRITE, &oldProtect);
  320.  
  321. if(this->checkBox15->Checked)
  322. {
  323.       memcpy((void*)MapRightAddy, enableMapRight, sizeof(enableMapRight));
  324. }
  325. else
  326. {
  327.       memcpy((void*)MapRightAddy, disableMapRight, sizeof(disableMapRight));
  328. }
  329. }
  330. DWORD TubiAddy = 0x004B0DB7;
  331. BYTE enableTubi [] = {0x90, 0x90, 0x90, 0x90, 0x90, 0x90};
  332. BYTE disableTubi [] = {0x89, 0x86, 0xB8, 0x20, 0x00, 0x00};
  333.  
  334. void Form1::checkBox16_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  335. {
  336.  
  337. unsigned long oldProtect;
  338. VirtualProtect((LPVOID)TubiAddy, 2, PAGE_EXECUTE_READWRITE, &oldProtect);
  339.  
  340. if(this->checkBox16->Checked)
  341. {
  342.       memcpy((void*)TubiAddy, enableTubi, sizeof(enableTubi));
  343. }
  344. else
  345. {
  346.       memcpy((void*)TubiAddy, disableTubi, sizeof(disableTubi));
  347. }
  348. }
  349. DWORD RainMobsAddy = 0x006A4E16;
  350. BYTE enableRainMobs [] = {0xD9, 0xC1};
  351. BYTE disableRainMobs [] = {0xD9, 0xC0};
  352.  
  353. void Form1::checkBox18_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  354. {
  355.  
  356. unsigned long oldProtect;
  357. VirtualProtect((LPVOID)RainMobsAddy, 2, PAGE_EXECUTE_READWRITE, &oldProtect);
  358.  
  359. if(this->checkBox18->Checked)
  360. {
  361.       memcpy((void*)RainMobsAddy, enableRainMobs, sizeof(enableRainMobs));
  362. }
  363. else
  364. {
  365.       memcpy((void*)RainMobsAddy, disableRainMobs, sizeof(disableRainMobs));
  366. }
  367. }
  368. DWORD MapSpdAddy = 0x6666EB03;
  369. BYTE enableMapSpd [] = {0x58};
  370. BYTE disableMapSpd [] = {0x08};
  371. void Form1::checkBox19_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  372. {
  373.  
  374. unsigned long oldProtect;
  375. VirtualProtect((LPVOID)MapSpdAddy, 1, PAGE_EXECUTE_READWRITE, &oldProtect);
  376.  
  377. if(this->checkBox19->Checked)
  378. {
  379.       memcpy((void*)MapSpdAddy, enableMapSpd, sizeof(enableMapSpd));
  380. }
  381. else
  382. {
  383.       memcpy((void*)MapSpdAddy, disableMapSpd, sizeof(disableMapSpd));
  384. }
  385. }
  386. DWORD SlowMobAddy = 0x006A52CB;
  387. BYTE enableSlowMob [] = {0xB8, 0x00, 0x00, 0x00, 0x00};
  388. BYTE disableSlowMob [] = {0xB8, 0xE8, 0x03, 0x00, 0x00};
  389.  
  390. void Form1::checkBox20_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  391. {
  392.  
  393. unsigned long oldProtect;
  394. VirtualProtect((LPVOID)SlowMobAddy, 5, PAGE_EXECUTE_READWRITE, &oldProtect);
  395.  
  396. if(this->checkBox20->Checked)
  397. {
  398.       memcpy((void*)SlowMobAddy, enableSlowMob, sizeof(enableSlowMob));
  399. }
  400. else
  401. {
  402.       memcpy((void*)SlowMobAddy, disableSlowMob, sizeof(disableSlowMob));
  403. }
  404. }
  405. DWORD InvMobAddy = 0x0043BD42;
  406. BYTE enableInvMob [] = {0x0F, 0x85};
  407. BYTE disableInvMob [] = {0x0F, 0x84};
  408.  
  409. void Form1::checkBox21_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  410. {
  411.  
  412. unsigned long oldProtect;
  413. VirtualProtect((LPVOID)InvMobAddy, 2, PAGE_EXECUTE_READWRITE, &oldProtect);
  414.  
  415. if(this->checkBox21->Checked)
  416. {
  417.       memcpy((void*)InvMobAddy, enableInvMob, sizeof(enableInvMob));
  418. }
  419. else
  420. {
  421.       memcpy((void*)InvMobAddy, disableInvMob, sizeof(disableInvMob));
  422. }
  423. }
  424. DWORD CSMobAddy = 0x006A628A;
  425. BYTE enableCSMob [] = {0xB8, 0x00};
  426. BYTE disableCSMob [] = {0xB8, 0x01};
  427.  
  428. void Form1::checkBox22_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  429. {
  430.  
  431. unsigned long oldProtect;
  432. VirtualProtect((LPVOID)CSMobAddy, 2, PAGE_EXECUTE_READWRITE, &oldProtect);
  433.  
  434. if(this->checkBox22->Checked)
  435. {
  436.       memcpy((void*)CSMobAddy, enableCSMob, sizeof(enableCSMob));
  437. }
  438. else
  439. {
  440.       memcpy((void*)CSMobAddy, disableCSMob, sizeof(disableCSMob));
  441. }
  442. }
  443. DWORD SSMobAddy = 0x00A05D13;
  444. BYTE enableSSMob [] = {0xB8, 0x00};
  445. BYTE disableSSMob [] = {0xB8, 0x00};
  446.  
  447. void Form1::checkBox23_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  448. {
  449.  
  450. unsigned long oldProtect;
  451. VirtualProtect((LPVOID)SSMobAddy, 2, PAGE_EXECUTE_READWRITE, &oldProtect);
  452.  
  453. if(this->checkBox23->Checked)
  454. {
  455.       memcpy((void*)SSMobAddy, enableSSMob, sizeof(enableSSMob));
  456. }
  457. else
  458. {
  459.       memcpy((void*)SSMobAddy, disableSSMob, sizeof(disableSSMob));
  460. }
  461. }
  462. DWORD MobKBAddy = 0x00695882;
  463. BYTE enableMobKB [] = {0x75};
  464. BYTE disableMobKB [] = {0x74};
  465.  
  466. void Form1::checkBox24_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  467. {
  468.  
  469. unsigned long oldProtect;
  470. VirtualProtect((LPVOID)MobKBAddy, 1, PAGE_EXECUTE_READWRITE, &oldProtect);
  471.  
  472. if(this->checkBox24->Checked)
  473. {
  474.       memcpy((void*)MobKBAddy, enableMobKB, sizeof(enableMobKB));
  475. }
  476. else
  477. {
  478.       memcpy((void*)MobKBAddy, disableMobKB, sizeof(disableMobKB));
  479. }
  480. }
  481. DWORD SitHackAddy = 0x009CD5EE;
  482. BYTE enableSitHack [] = {0x75};
  483. BYTE disableSitHack [] = {0x74};
  484.  
  485. void Form1::checkBox25_CheckedChanged(System::Object^ sender, System::EventArgs^ e)
  486. {
  487.  
  488. unsigned long oldProtect;
  489. VirtualProtect((LPVOID)SitHackAddy, 1, PAGE_EXECUTE_READWRITE, &oldProtect);
  490.  
  491. if(this->checkBox25->Checked)
  492. {
  493.       memcpy((void*)SitHackAddy, enableSitHack, sizeof(enableSitHack));
  494. }
  495. else
  496. {
  497.       memcpy((void*)SitHackAddy, disableSitHack, sizeof(disableSitHack));
  498. }
  499. }
  500. /*/Auto Bot
  501. ***************************
  502. ***************************
  503. ***************************/
  504.  
  505. //HP Auto Potter ComboBox
  506. void Form1::comboBox1_SelectedIndexChanged(System::Object^  sender, System::EventArgs^  e)
  507. {
  508.     HPKey = GetKey(this->comboBox1->SelectedIndex);
  509. }
  510.  
  511. // MP Auto Potter ComboBox Body
  512. void Form1::comboBox2_SelectedIndexChanged(System::Object^  sender, System::EventArgs^  e)
  513. {
  514.     MPKey = GetKey(this->comboBox2->SelectedIndex);
  515. }
  516.  
  517. //Auto Attack Combobox
  518. void Form1::comboBox3_SelectedIndexChanged(System::Object^  sender, System::EventArgs^  e)
  519. {
  520.     AttackKey = GetKey(this->comboBox3->SelectedIndex);
  521. }
  522. //Auto Loot ComboBox
  523. void Form1::comboBox4_SelectedIndexChanged(System::Object^  sender, System::EventArgs^  e)
  524. {
  525.     LootKey = GetKey(this->comboBox4->SelectedIndex);
  526. }
  527. //Auto Skill 1 ComboBox
  528. void Form1::comboBox5_SelectedIndexChanged(System::Object^  sender, System::EventArgs^  e)
  529. {
  530.     Skill1Key = GetKey(this->comboBox5->SelectedIndex);
  531. }
  532.  
  533. //Auto skill 2 ComboBox
  534. void Form1::comboBox6_SelectedIndexChanged(System::Object^  sender, System::EventArgs^  e)
  535. {
  536.     Skill2Key = GetKey(this->comboBox6->SelectedIndex);
  537. }
  538.  
  539.  
  540.  
  541.  
  542. //Auto Skill 1
  543. void Form1::textBox5_TextChanged(System::Object^  sender, System::EventArgs^  e) //Delay textbox
  544. {
  545.     UserSetAutoSkillDelay1 = Convert::ToInt32(this->textBox5->Text)*1000; //Default delay
  546. }
  547.  
  548. //Auto Skill 2
  549. void Form1::textBox6_TextChanged(System::Object^  sender, System::EventArgs^  e)// Delay textbox
  550. {
  551.     UserSetAutoSkillDelay2 = Convert::ToInt32(this->textBox6->Text)*1000; //Default delay
  552. }
  553.  
  554.  
  555.  
  556.  
  557.  
  558.     #pragma region AutoSkill 1
  559.     // Auto Skill 1 On Delete
  560.     int DeleteInterval = 100;
  561.     bool EnableusingSkill1 = false;
  562.     bool usingSkill1 = true;
  563.      
  564.     void StartusingAutoSkill1()
  565.     {
  566.             HWND hwnd = FindWindowA("MapleStoryClass", NULL);
  567.             LPARAM lParam = (MapVirtualKeyA((UINT)Skill1Key, 0) << 16) + 1;
  568.             while(EnableusingSkill1)
  569.             {
  570.      
  571.                     usingSkill1 = true;
  572.                     Sleep(1000);
  573.                     PostMessage(hwnd, WM_KEYDOWN, (WPARAM)Skill1Key, lParam);
  574.                     usingSkill1 = false;
  575.                     Sleep(DeleteInterval);
  576.             }
  577.     }
  578.      
  579.     void Form1::checkBox29_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
  580.     {
  581.             if(this->checkBox29->Checked)
  582.      
  583.             {
  584.                     if(this->textBox5->Text == "")
  585.                     {
  586.                             this->checkBox29->Checked = false;
  587.                             MessageBoxW(NULL, L"Please insert a value for Auto Skill in seconds.", L"Alert", MB_OK);
  588.                     }
  589.                     else
  590.                     {
  591.                             EnableusingSkill1 = true;
  592.                             DeleteInterval = Convert::ToInt32(this->textBox5->Text);
  593.                             DeleteInterval = DeleteInterval * 1000;
  594.                             CreateThread(NULL, 0, (::LPTHREAD_START_ROUTINE)&StartusingAutoSkill1, NULL, 0, NULL);
  595.                     }
  596.             }
  597.             else
  598.             {
  599.                     EnableusingSkill1 = false;
  600.             }
  601.     }
  602.     #pragma endregion
  603.  
  604.  
  605.     #pragma region AutoSkill 2
  606.     // Auto Skill 2 On Home
  607.     int DeleteInterval2 = 100;
  608.     bool EnableusingSkill2 = false;
  609.     bool usingSkill2 = true;
  610.      
  611.     void StartusingAutoSkill2()
  612.     {
  613.             HWND hwnd = FindWindowA("MapleStoryClass", NULL);
  614.             LPARAM lParam = (MapVirtualKeyA((UINT)Skill2Key, 0) << 16) + 1;
  615.             while(EnableusingSkill2)
  616.             {
  617.      
  618.                     usingSkill2 = true;
  619.                     Sleep(1000);
  620.                     PostMessage(hwnd, WM_KEYDOWN, (WPARAM)Skill2Key, lParam);
  621.                     usingSkill2 = false;
  622.                     Sleep(DeleteInterval2);
  623.             }
  624.     }
  625.      
  626.     void Form1::checkBox31_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
  627.     {
  628.             if(this->checkBox31->Checked)
  629.      
  630.             {
  631.                     if(this->textBox6->Text == "")
  632.                     {
  633.                             this->checkBox31->Checked = false;
  634.                             MessageBoxW(NULL, L"Please insert a value for Auto Skill in seconds.", L"Alert", MB_OK);
  635.                     }
  636.                     else
  637.                     {
  638.                             EnableusingSkill2 = true;
  639.                             DeleteInterval2 = Convert::ToInt32(this->textBox6->Text);
  640.                             DeleteInterval2 = DeleteInterval2 * 1000;
  641.                             CreateThread(NULL, 0, (::LPTHREAD_START_ROUTINE)&StartusingAutoSkill2, NULL, 0, NULL);
  642.                     }
  643.             }
  644.             else
  645.             {
  646.                     EnableusingSkill1 = false;
  647.             }
  648.     }
  649.     #pragma endregion
  650.  
  651.  
  652.  
  653.  
  654. //Auto Attack
  655. bool AAF = false;
  656.  
  657. void AutoA(HWND hwnd)
  658. {
  659.     while(!AutoAExit)
  660.     {
  661.         //Wait., Let me delete my kami first.
  662.        
  663. while(AAF)
  664.         {
  665. HWND hwnd = FindWindow(TEXT("MapleStoryClass"), 0);
  666. //Finds the MapleStory Window, this does not support multi maple.
  667. LPARAM lParam = (MapVirtualKey(0xA2, 0) << 16) + 1; //A2
  668. PostMessage(hwnd, WM_KEYDOWN, 0xA2, lParam);
  669. //Pushes the key
  670. Sleep(50);
  671. PostMessage(hwnd, WM_KEYUP, 0xA2, lParam);
  672. //Releases the key
  673. Sleep(10);
  674.        
  675.         }
  676.     }
  677. }
  678. //Auto Attack
  679. void Form1::checkBox28_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
  680. {
  681.      if(this->checkBox28->Checked)
  682.      {
  683.  
  684.         AutoAExit = false; // If enabled AutoAttackExit is false.
  685.         AAF = true;
  686.         CreateThread(NULL, 0, (::LPTHREAD_START_ROUTINE)&AutoA, NULL, 0, NULL);
  687.         //Here we create a thread, see the definition for more information.
  688.      }
  689.  
  690.      else
  691.      {
  692.         AAF = false;
  693.         AutoAExit = true; //If disabled AutoAttackExit is ture
  694.      }
  695. }
  696.  
  697. //loot
  698. bool ALF = false;
  699.  
  700. void AutoL(HWND hwnd)
  701. {
  702.     while(!AutoLExit)
  703.     {
  704.  
  705.  
  706.        
  707. while(ALF)
  708.             {
  709. HWND hwnd = FindWindow(TEXT("MapleStoryClass"), 0);
  710. LPARAM lParam = (MapVirtualKey(LootKey, 0) << 16) + 1;
  711. PostMessage(hwnd, WM_KEYDOWN, LootKey, lParam);
  712. Sleep(50);
  713. PostMessage(hwnd, WM_KEYUP, LootKey, lParam);//LootKey
  714. Sleep(10);
  715.        
  716.         }
  717.     }
  718. }
  719.  
  720. //Auto LOOT
  721. void Form1::checkBox30_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
  722. {
  723.      if(this->checkBox30->Checked)
  724.      {
  725.    
  726.         AutoLExit = false;
  727.         ALF = true;
  728. CreateThread(NULL, 0, (::LPTHREAD_START_ROUTINE)&AutoL, NULL, 0, NULL);
  729. //Here we create a thread, see the definition for more information.
  730.      }
  731.  
  732.      else
  733.      {
  734.         ALF = false;
  735.         AutoLExit = true;
  736.      }
  737. }
  738.  
  739.     #pragma region AutoPot
  740. // Auto Pot
  741. int UserSetHP = 200;
  742. int UserSetMP = 50;
  743. int PotDelay = 200;
  744. bool HPExit = false;
  745. bool MPExit = false;
  746.  
  747.  
  748. void AutoPotHP()
  749. {
  750.     HWND hwnd = FindWindowA("MapleStoryClass", NULL);
  751.     LPARAM lParam = (MapVirtualKeyA((UINT)HPKey, 0) << 16) + 1;
  752.     LPARAM lParam2 = (MapVirtualKeyA((UINT)MPKey, 0) << 16) + 1;
  753.     while(HPExit)
  754.     {
  755.         if(ReadPointer((unsigned long)GUIInfoBase, (int)HP) < UserSetHP)
  756.         {
  757.             PostMessage(hwnd, WM_KEYDOWN, (WPARAM)HPKey, lParam); // Page Up
  758.             Sleep(PotDelay);
  759.         }
  760.         Sleep(10);
  761.     }
  762. }
  763. //Go.
  764. void AutoPotMP()
  765. {
  766.     HWND hwnd = FindWindowA("MapleStoryClass", NULL);
  767.     LPARAM lParam2 = (MapVirtualKeyA((UINT)MPKey, 0) << 16) + 1;
  768.     while(MPExit)
  769.     {
  770.         if(ReadPointer((unsigned long)GUIInfoBase, (int)MP) < UserSetMP)
  771.         {
  772.             PostMessage(hwnd, WM_KEYDOWN, (WPARAM)MPKey, lParam2); // Page Down
  773.             Sleep(PotDelay);
  774.         }
  775.         Sleep(10);
  776.     }
  777. }
  778.      
  779.     void Form1::textBox1_TextChanged_1(System::Object^  sender, System::EventArgs^  e)
  780.     {
  781.             UserSetHP = Convert::ToInt32(this->textBox1->Text);
  782.     }
  783.      
  784.     void Form1::textBox2_TextChanged(System::Object^  sender, System::EventArgs^  e)
  785.     {
  786.             UserSetMP = Convert::ToInt32(this->textBox2->Text);
  787.     }
  788.      
  789.     void Form1::checkBox26_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
  790.     {
  791.             if(this->checkBox26->Checked)
  792.             {
  793.                     HPExit = true;
  794.                     PotDelay = Convert::ToInt32(this->textBox1->Text);
  795.                     CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)&AutoPotHP, NULL, NULL, NULL);
  796.             }
  797.             else
  798.             {
  799.                     HPExit = false;
  800.             }
  801.     }
  802.     void Form1::checkBox27_CheckedChanged(System::Object^  sender, System::EventArgs^  e)
  803.     {
  804.             if(this->checkBox27->Checked)
  805.             {
  806.                     MPExit = true;
  807.                     PotDelay = Convert::ToInt32(this->textBox2->Text);
  808.                     CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)&AutoPotMP, NULL, NULL, NULL);
  809.             }
  810.             else
  811.             {
  812.                     MPExit = false;
  813.             }
  814.     }
  815.     #pragma endregion
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!