开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 外挂编程 > 查看源码
ROADefs.h
资源名称：ROA3.40.rar　[点击查看]
上传用户：tianheyiqi
上传日期：2010-04-16
资源大小：282k
文件大小：24k
源码类别：

外挂编程

开发平台：

Visual C++

ROADefs.h：源码内容
  1. #if !defined(AFX_ROADEFS_H__B246916D_8303_42EE_AF13_20D988742F4D__INCLUDED_)
  2. #define AFX_ROADEFS_H__B246916D_8303_42EE_AF13_20D988742F4D__INCLUDED_
  4. #if _MSC_VER > 1000
  5. #pragma once
  6. #endif // _MSC_VER > 1000
  8. #include "ROAMap.h"
  9. #include "ROAField.h"
  11. typedef int (WINAPI *HOOKAPI)(DWORD ProcID, LPCTSTR dll);
  12. CString utlParseString(CString& str);
  14. const CString strWelcome[] = 
  15. {
  16. "*******************************************************",
  17. "*           仙境传说 - ROA   (Version: 3.40)          *",
  18. "*-----------------------------------------------------*",
  19. "*  请勿在官方服务器上使用本程序，如不同意请马上退出   *",
  20. "*-----------------------------------------------------*",
  21. "* Author: Outman  QQ: 298668119  outman_@hotmail.com  *",
  22. "*******************************************************"
  23. };
  24. #define ROA_HEADER "[ROA]: "
  25. #define ROA_PORT (2350)
  26. #define MAX_BUFFER_LEN (32768)
  27. #define MAX_SKILL 337
  29. #define ROA_INI2_FILENAME _T(".\roa2.ini")
  30. #define ROA_INI2_OPTION _T("OPTION")
  31. #define ROA_INI2_OPT_TESTSVR _T("TestServer")
  32. #define ROA_INI2_OPT_PARTYCHAT _T("UsePartyChat")
  33. #define ROA_INI2_OPT_AUTOPICKUP _T("AutoPickup")
  34. #define ROA_INI2_OPT_BOSSINFO _T("InformBossTime")
  35. #define ROA_INI2_OPT_MOVEPICKUP _T("MovePickup")
  36. #define ROA_INI2_OPT_LAUNCHER _T("Launcher")
  37. #define ROA_INI2_OPT_LAUNCHERPAPRAM _T("LaunchParam")
  38. #define ROA_INI2_OPT_EMOTION _T("Emotion")
  39. #define ROA_INI2_OPT_AUTOCONT _T("AutoContinue")
  40. #define ROA_INI2_OPT_WELCOMEDELAY _T("WelcomeDelay")
  41. #define ROA_INI2_OPT_SEARCHDELAY _T("AutoSearchDelay")
  42. #define ROA_INI2_OPT_PICKUPDISTANCE _T("PickupDistance")
  43. #define ROA_INI2_OPT_ATTACKPERS _T("AttackPerSecond")
  44. #define ROA_INI2_OPT_HPITEMS _T("HPRecoverItems")
  45. #define ROA_INI2_OPT_SPITEMS _T("SPRecoverItems")
  46. #define ROA_INI2_OPT_ITEMUSEINT _T("ItemUseInterval")
  48. #define ROA_INI2_SETTING_CMN _T("CommonSetting")
  49. #define ROA_INI2_SETTING_MVP _T("MvpSetting")
  50. #define ROA_INI2_SETTING_PVP _T("PvpSetting")
  51. #define ROA_INI2_SETTING_GVG _T("GvgSetting")
  52. #define ROA_INI2_SETTING_KEY _T("ShortcutKey")
  54. #define ROA_INI2_BOSSINFO _T("BossInfo")
  56. #define ROA_MAP_ITEMTYPES "..\tables\itemtypes.txt"
  57. #define ROA_MAP_EQUIPTYPES  "..\tables\equiptypes.txt"
  58. #define ROA_MAP_MAPNAME "..\tables\maps.txt"
  59. #define ROA_MAP_JOB "..\tables\jobs.txt"
  60. #define ROA_MAP_SEX "..\tables\sex.txt"
  61. #define ROA_MAP_SKILL "..\tables\skills.txt"
  62. #define ROA_MAP_STATUS011F "..\tables\status011f.txt"
  63. #define ROA_MAP_STATUS0119 "..\tables\status0119.txt"
  64. #define ROA_MAP_SKILLSST "..\tables\skillsst.txt"
  65. #define ROA_MAP_ITEMS "..\tables\items.txt"
  66. #define ROA_AVOID_AIDS "..\tables\avoidaid.txt"
  67. #define ROA_MAP_MVPMONSTER "..\tables\mvpmonster.txt"
  68. #define ROA_MAP_MONSTER "..\tables\monsters.txt"
  69. #define ROA_MAP_ELEMENTS "..\tables\elements.txt"
  71. #define MAX_NAME_LENGTH 24
  72. #define MAX_CHAT_MSG 1024
  74. const CString ATTACKSKILL[] = 
  75. {
  76. _T("停止攻击"),
  77. _T("普通物理攻击"),
  78. _T("狂击"),
  79. _T("怒爆"),
  80. _T("连刺攻击"),
  81. _T("骑乘攻击"),
  82. _T("长矛刺击"),
  83. _T("投掷长矛攻击"),
  84. _T("怪物互击"),
  85. _T("二连矢"),
  86. _T("箭雨"),
  87. _T("闪电冲击"),
  88. _T("金钱攻击"),
  89. _T("手推车攻击"),
  90. _T("音速投掷"),
  91. // _T("背刺"),
  92. _T("圣十字攻击"),
  93. _T("缠箭投掷"),
  94. _T("乐器攻击"),
  95. _T("盾击"),
  96. _T("回旋盾击"),
  97. _T("治愈术"),
  98. _T("转生术"),
  99. _T("神圣之光"),
  100. _T("天使之怒"),
  101. };
  102. const int ATTACKSKILLNUM = sizeof(ATTACKSKILL) / sizeof(ATTACKSKILL[0]);
  104. const CString PROTECTSKILL[] = 
  105. {
  106. _T("光之障壁"),
  107. _T("暗之障壁")
  108. };
  109. const int PROTECTSKILLNUM = sizeof(PROTECTSKILL) / sizeof(PROTECTSKILL[0]);
  111. const CString PROTECTSTATE[] = 
  112. {
  113. _T("光之障壁"),
  114. _T("暗之障壁")
  115. };
  116. const int PROTECTSTATENUM = sizeof(PROTECTSTATE) / sizeof(PROTECTSTATE[0]);
  118. enum
  119. {
  120. eItemName = 0,
  121. eItemSlots = 1,
  122. eItemPriority =2,
  123. eItemMax
  124. };
  126. enum
  127. {
  128. eModeNormal = 0,
  129. eModeMvp = eModeNormal + 1,
  130. eModePvp = eModeMvp + 1,
  131. eModeGvg = eModePvp + 1,
  132. eModeMax = eModeGvg + 1,
  133. };
  135. enum
  136. {
  137. eSkillName = 0,
  138. eSkillAlias = 1,
  139. eSkillMax
  140. };
  142. typedef enum tagLogLevel
  143. {
  144. eLogNone = -1,
  145. eLogError = 0,
  146. eLogCommon = 1,
  147. eLogInfo = 2,
  148. eLogDebug = 3
  149. }LOG_LEVEL;
  151. typedef enum tagItemPriority
  152. {
  153. eIpGrab = 0,
  154. eIpGather = 1,
  155. eIpPickup = 2,
  156. eIpIgnore = 3,
  157. eIpMax
  158. }ITEMPRIORITY;
  160. class INVENTORY
  161. {
  162. public:
  163. INVENTORY()
  164. {
  165. init();
  166. }
  167. DWORD dwIndex;
  168. WORD wAmount;
  169. DWORD dwId;
  170. BOOL bIdentified;
  171. BYTE byAttrib;
  172. BYTE byRefine;
  173. WORD wCard[4];
  174. WORD wEquipType;
  175. WORD wType;
  176. WORD wEquipped;
  177. BYTE byElement;
  178. BYTE byStar;
  179. void init()
  180. {
  181. dwIndex = 0;
  182. wAmount = 0;
  183. dwId = 0;
  184. bIdentified = false;
  185. byAttrib = 0;
  186. byRefine = 0;
  187. wCard[0] = wCard[1] = wCard[2] = wCard[3] = 0;
  188. wEquipType = 0;
  189. wType = 0;
  190. wEquipped = 0;
  191. byElement = 0;
  192. byStar = 0;
  193. }
  194. };
  196. class ITEM
  197. {
  198. public:
  199. ITEM()
  200. {
  201. init();
  202. }
  203. DWORD dwId;
  204. DWORD dwAppearTime;
  205. WORD wAmount;
  206. WORD wType;
  207. POINT pntPos;
  208. int nPickupFailed;
  209. ITEMPRIORITY ePriority;
  210. void init()
  211. {
  212. dwAppearTime = 0;
  213. wAmount = 0;
  214. wType = 0;
  215. pntPos.x = 0;
  216. pntPos.y = 0;
  217. nPickupFailed = 0;
  218. ePriority = eIpGrab;
  219. }
  220. };
  222. class SPELL
  223. {
  224. public:
  225. SPELL()
  226. {
  227. init();
  228. }
  229. DWORD dwId;
  230. DWORD dwSourceId;
  231. POINT pntPos;
  232. WORD wSkill;
  233. void init()
  234. {
  235. dwId = 0;
  236. dwSourceId = 0;
  237. pntPos.x = 0;
  238. pntPos.y = 0;
  239. wSkill = 0;
  240. }
  241. };
  243. class MONSTER
  244. {
  245. public:
  246. MONSTER()
  247. {
  248. init();
  249. }
  250. DWORD dwId;
  251. WORD wType;
  252. POINT pntPos;
  253. POINT pntTo;
  254. BYTE byLookHead;
  255. BYTE byLookBody;
  256. char cName[MAX_NAME_LENGTH+1];
  257. int nProtecting;
  258. WORD wFrozen;
  259. void init()
  260. {
  261. dwId = 0;
  262. wType = 0;
  263. pntPos.x = 0;
  264. pntPos.y = 0;
  265. pntTo.x = 0;
  266. pntTo.y = 0;
  267. byLookHead = 0;
  268. byLookBody = 0;
  269. memset(cName, 0, MAX_NAME_LENGTH+1);
  270. nProtecting = 0;
  271. wFrozen = 0;
  272. }
  273. };
  275. class PLAYER
  276. {
  277. public:
  278. PLAYER()
  279. {
  280. init();
  281. }
  282. DWORD dwId;
  283. DWORD dwAppearTime;
  284. char cName[MAX_NAME_LENGTH+1];
  285. char cGuild[MAX_NAME_LENGTH+1];
  286. BYTE bySex;
  287. POINT pntPos;
  288. POINT pntTo;
  289. WORD wType;
  290. BOOL bSit;
  291. BYTE byLookHead;
  292. BYTE byLookBody;
  293. int nProtecting;
  294. BOOL bDied;
  295. WORD wStatus0119_01;
  296. WORD wStatus0119_02;
  297. WORD wStatus0119_03;
  298. void init()
  299. {
  300. pntPos.x = 0;
  301. pntPos.y = 0;
  302. pntTo.x = 0;
  303. pntTo.y = 0;
  304. dwId = 0;
  305. dwAppearTime = 0;
  306. memset(cName, 0, MAX_NAME_LENGTH);
  307. memset(cGuild, 0, MAX_NAME_LENGTH);
  308. bySex = 0;
  309. wType = 0;
  310. bSit = false;
  311. byLookHead = 0;
  312. byLookBody = 0;
  313. nProtecting = 0;
  314. bDied = false;
  316. wStatus0119_01 = wStatus0119_02 = wStatus0119_03 = 0;
  317. }
  318. };
  320. class YOU
  321. {
  322. public:
  323. YOU()
  324. {
  325. init();
  326. }
  327. char cName[MAX_NAME_LENGTH+1];
  328. char cGuild[MAX_NAME_LENGTH+1];
  329. char cJob[MAX_NAME_LENGTH+1];
  330. WORD wLevel;
  331. WORD wJobLevel;
  332. WORD wHp;
  333. WORD wHpMax;
  334. WORD wSp;
  335. WORD wSpMax;
  336. DWORD dwExp;
  337. DWORD dwExpMax;
  338. DWORD dwJobExp;
  339. DWORD dwJobExpMax;
  340. DWORD dwZenny;
  341. DWORD dwWeight;
  342. DWORD dwWeightMax;
  343. POINT pntPos;
  344. POINT pntTo;
  345. BYTE byLookHead;
  346. BYTE byLookBody;
  347. /* BYTE byStr;
  348. BYTE byAgi;
  349. BYTE byVit;
  350. BYTE byInt;
  351. BYTE byDex;
  352. BYTE byLuk;
  353. */ BOOL bSit;
  354. // BOOL bTwoHandsQuiken;
  355. BOOL bDied;
  356. WORD wStatus0119_01;
  357. WORD wStatus0119_02;
  358. WORD wStatus0119_03;
  359. int nProtecting;
  360. void init()
  361. {
  362. memset(cName, 0, sizeof(MAX_NAME_LENGTH+1));
  363. memset(cGuild, 0, sizeof(MAX_NAME_LENGTH+1));
  364. memset(cJob, 0, sizeof(MAX_NAME_LENGTH+1));
  365. wLevel = 0;
  366. wJobLevel = 0;
  367. wHp = 0;
  368. wHpMax = 0;
  369. wSp = 0;
  370. wSpMax = 0;
  371. dwExp = 0;
  372. dwExpMax = 0;
  373. dwJobExp = 0;
  374. dwJobExpMax = 0;
  375. dwZenny = 0;
  376. dwWeight = 0;
  377. dwWeightMax = 0;
  378. pntPos.x = 0;
  379. pntPos.y = 0;
  380. pntTo.x = 0;
  381. pntTo.y = 0;
  382. byLookHead = 0;
  383. byLookBody = 0;
  384. bSit = false;
  385. // bTwoHandsQuiken = false;
  386. bDied = false;
  388. wStatus0119_01 = wStatus0119_02 = wStatus0119_03 = 0;
  389. }
  390. };
  392. class PORTAL
  393. {
  394. public:
  395. PORTAL()
  396. {
  397. init();
  398. }
  399. DWORD dwId;
  400. DWORD dwAppearTime;
  401. WORD wType;
  402. POINT pntPos;
  403. void init()
  404. {
  405. dwId = 0;
  406. dwAppearTime = 0;
  407. wType = 0;
  408. pntPos.x = 0;
  409. pntPos.y = 0;
  410. }
  412. };
  414. class SKILL
  415. {
  416. public:
  417. SKILL()
  418. {
  419. init();
  420. }
  421. DWORD dwIndex;
  422. DWORD dwId;
  423. WORD wLevel;
  424. void init()
  425. {
  426. dwIndex = 0;
  427. dwId = 0;
  428. wLevel = 0;
  429. };
  430. };
  432. template<class TYPE, class ARG_TYPE>
  433. class CIdArray : public CArray<TYPE, ARG_TYPE>
  434. {
  435. public:
  436. int FindIndex(LPCTSTR lpszIndex)
  437. {
  438. DWORD dwIndex;
  439. sscanf(lpszIndex, "%d" , &dwIndex);
  440. return(FindIndex(dwIndex));
  441. }
  442. int FindIndex(DWORD nIndex)
  443. {
  444. int nRtn = -1;
  445. for(int i=0; i<GetSize(); i++)
  446. {
  447. if(nIndex == GetAt(i).dwIndex)
  448. {
  449. nRtn = i;
  450. break;
  451. }
  452. }
  453. return(nRtn);
  454. }
  455. int FindId(DWORD nId)
  456. {
  457. int nRtn = -1;
  458. for(int i=0; i<GetSize(); i++)
  459. {
  460. if(nId == GetAt(i).dwId)
  461. {
  462. nRtn = i;
  463. break;
  464. }
  465. }
  466. return(nRtn);
  467. }
  468. int FindId(LPCTSTR lpszId)
  469. {
  470. DWORD dwId;
  471. sscanf(lpszId, "%X" , &dwId);
  472. return(FindId(dwId));
  473. }
  474. // Damage
  475. int GetDamage(DWORD dwId1, DWORD dwId2)
  476. {
  477. int nIndex = FindDamage(dwId1, dwId2);
  478. int nRtn = 0;
  479. if(-1 != nIndex)
  480. {
  481. nRtn = GetAt(nIndex).dwDamage;
  482. }
  483. return(nRtn);
  484. }
  485. int FindDamage(DWORD dwId1, DWORD dwId2)
  486. {
  487. int nRtn = -1;
  488. for(int i=0; i<GetSize(); i++)
  489. {
  490. if(dwId1 == GetAt(i).dwId1 && dwId2 == GetAt(i).dwId2)
  491. {
  492. nRtn = i;
  493. break;
  494. }
  495. }
  496. return(nRtn);
  497. }
  498. BOOL FindDamageFrom(DWORD dwId, CString& strName, DWORD& dwDamage)
  499. {
  500. BOOL bRtn = false;
  501. int nCnt = 0;
  502. strName = "";
  503. dwDamage = 0;
  504. for(int i=0; i<GetSize(); i++)
  505. {
  506. if(GetAt(i).dwId2 == dwId)
  507. {
  508. dwDamage += GetAt(i).dwDamage;
  509. strName = utlFindTarget(GetAt(i).dwId1);
  510. nCnt++;
  511. }
  512. }
  513. if(nCnt > 0)
  514. bRtn = true;
  515. if(nCnt > 1)
  516. strName += "*";
  518. return(bRtn);
  519. }
  520. BOOL FindDamageTo(DWORD dwId, CString& strName, DWORD& dwDamage)
  521. {
  522. BOOL bRtn = false;
  523. int nCnt = 0;
  524. strName = "";
  525. dwDamage = 0;
  526. for(int i=0; i<GetSize(); i++)
  527. {
  528. if(GetAt(i).dwId1 == dwId)
  529. {
  530. dwDamage += GetAt(i).dwDamage;
  531. strName = utlFindTarget(GetAt(i).dwId2);
  532. nCnt++;
  533. }
  534. }
  535. if(nCnt > 0)
  536. bRtn = true;
  537. if(nCnt > 1)
  538. strName += "*";
  540. return(bRtn);
  541. }
  542. BOOL FindDamageFrom(DWORD dwId, CDWordArray &dwTargetArray, CDWordArray &dwDamageArray)
  543. {
  544. BOOL bRtn = false;
  545. DWORD dwDamage = 0;
  546. DWORD dwTarget = 0;
  547. dwTargetArray.RemoveAll();
  548. dwDamageArray.RemoveAll();
  549. for(int i=0; i<GetSize(); i++)
  550. {
  551. if(GetAt(i).dwId2 == dwId)
  552. {
  553. dwDamage = GetAt(i).dwDamage;
  554. dwTarget = GetAt(i).dwId1;
  555. dwTargetArray.Add(dwTarget);
  556. dwDamageArray.Add(dwDamage);
  557. bRtn = true;
  558. }
  559. }
  560. return(bRtn);
  561. }
  562. BOOL FindDamageTo(DWORD dwId, CDWordArray &dwTargetArray, CDWordArray &dwDamageArray)
  563. {
  564. BOOL bRtn = false;
  565. DWORD dwDamage = 0;
  566. DWORD dwTarget = 0;
  567. dwTargetArray.RemoveAll();
  568. dwDamageArray.RemoveAll();
  569. for(int i=0; i<GetSize(); i++)
  570. {
  571. if(GetAt(i).dwId1 == dwId)
  572. {
  573. dwDamage = GetAt(i).dwDamage;
  574. dwTarget = GetAt(i).dwId2;
  575. dwTargetArray.Add(dwTarget);
  576. dwDamageArray.Add(dwDamage);
  577. bRtn = true;
  578. }
  579. }
  580. return(bRtn);
  581. }
  582. void RemoveDamage(DWORD dwId)
  583. {
  584. BOOL bFinish = false;
  586. while(!bFinish)
  587. {
  588. bFinish = true;
  589. for(int i=0; i<GetSize(); i++)
  590. {
  591. if(GetAt(i).dwId1 == dwId || GetAt(i).dwId2 == dwId)
  592. {
  593. RemoveAt(i);
  594. bFinish = false;
  595. break;
  596. }
  597. }
  598. }
  599. }
  600. };
  602. class DAMAGE
  603. {
  604. public:
  605. DAMAGE()
  606. {
  607. init();
  608. }
  609. DWORD dwIndex; //DUMMY
  610. DWORD dwId1; // Damage from
  611. DWORD dwId2; // Damage to
  612. DWORD dwDamage;
  613. DWORD dwStart;
  614. DWORD dwHits[MAX_SKILL];
  615. DWORD dwDamage2[MAX_SKILL];
  616. DWORD dwMiss[MAX_SKILL];
  617. DWORD dwDamageMin[MAX_SKILL];
  618. DWORD dwDamageMax[MAX_SKILL];
  619. void init()
  620. {
  621. int i;
  622. dwId1 = 0;
  623. dwId2 = 0;
  624. dwDamage = 0;
  625. dwStart = 0;
  626. for(i=0; i<MAX_SKILL; i++)
  627. {
  628. dwHits[i] = 0;
  629. dwDamage2[i] = 0;
  630. dwMiss[i] = 0;
  631. dwDamageMin[i] = 99999;
  632. dwDamageMax[i] = 0;
  633. }
  634. }
  635. };
  637. class AUTOHEAL2
  638. {
  639. public:
  640. AUTOHEAL2() {init();}
  641. BOOL bHP;
  642. int nHP1Lower;
  643. int nHP1Upper;
  644. CString strHP1Item;
  645. int nHP2Lower;
  646. int nHP2Upper;
  648. BOOL bSP;
  649. int nSPUpper;
  650. CString strSPItem;
  652. BOOL bHPTele;
  653. int nHPTeleUpper;
  655. void init()
  656. {
  657. bHP = false;
  658. nHP1Lower = 1;
  659. nHP1Upper = 2000;
  660. strHP1Item = _T("未知物品");
  661. nHP2Lower = 1;
  662. nHP2Upper = 2000;
  664. bSP = false;
  665. nSPUpper = 30;
  666. strSPItem = _T("未知物品");
  668. bHPTele = false;
  669. nHPTeleUpper = 100;
  670. }
  671. AUTOHEAL2& operator= (const AUTOHEAL2& that)
  672. {
  673. bHP = that.bHP;
  674. nHP1Lower = that.nHP1Lower;
  675. nHP1Upper = that.nHP1Upper;
  676. strHP1Item = that.strHP1Item;
  677. nHP2Lower = that.nHP2Lower;
  678. nHP2Upper = that.nHP2Upper;
  680. bSP = that.bSP;
  681. nSPUpper = that.nSPUpper;
  682. strSPItem = that.strSPItem;
  684. bHPTele = that.bHPTele;
  685. nHPTeleUpper = that.nHPTeleUpper;
  687. return(*this);
  688. }
  689. CString GetProfileString()
  690. {
  691. CString strRtn, strTemp;
  693. strTemp.Format(_T("%d,%d,%d,%s,%d,%d"), bHP, nHP1Lower, nHP1Upper, strHP1Item, nHP2Lower, nHP2Upper);
  694. strRtn = strTemp;
  696. strTemp.Format(_T(",%d,%d,%s,%d,%d"), bSP, nSPUpper, strSPItem, bHPTele, nHPTeleUpper);
  697. strRtn += strTemp;
  699. return strRtn;
  700. }
  702. void ParseProfileString(CString& strProfile)
  703. {
  704. CString strTemp, nIndex;
  706. strTemp = utlParseString(strProfile); bHP = atoi(strTemp);
  707. strTemp = utlParseString(strProfile); nHP1Lower = atoi(strTemp);
  708. strTemp = utlParseString(strProfile); nHP1Upper = atoi(strTemp);
  709. strTemp = utlParseString(strProfile); strHP1Item = strTemp;
  710. strTemp = utlParseString(strProfile); nHP2Lower = atoi(strTemp);
  711. strTemp = utlParseString(strProfile); nHP2Upper = atoi(strTemp);
  712. strTemp = utlParseString(strProfile); bSP = atoi(strTemp);
  713. strTemp = utlParseString(strProfile); nSPUpper = atoi(strTemp);
  714. strTemp = utlParseString(strProfile); strSPItem = strTemp;
  715. strTemp = utlParseString(strProfile); bHPTele = atoi(strTemp);
  716. strTemp = utlParseString(strProfile); nHPTeleUpper = atoi(strTemp);
  717. }
  718. };
  720. class SETTING_CMN
  721. {
  722. public:
  723. SETTING_CMN() {init();}
  724. AUTOHEAL2 autoheal;
  725. CString strSavePoint;
  727. void init()
  728. {
  729. autoheal.init();
  730. strSavePoint.Empty();
  731. }
  733. SETTING_CMN& operator= (const SETTING_CMN& that)
  734. {
  735. autoheal = that.autoheal;
  736. strSavePoint = that.strSavePoint;
  738. return(*this);
  739. }
  741. CString GetProfileString()
  742. {
  743. CString strRtn, strTemp;
  745. strTemp.Format(_T("%s"), autoheal.GetProfileString());
  746. strRtn = strTemp;
  748. strTemp.Format(_T(",%s"), strSavePoint);
  749. strRtn += strTemp;
  751. return strRtn;
  752. }
  753. void ParseProfileString(CString& strProfile)
  754. {
  755. CString strTemp, nIndex;
  757. autoheal.ParseProfileString(strProfile);
  759. if(strProfile.GetLength() > 0 && strProfile[0] == _T(','))
  760. strProfile = strProfile.Mid(1);
  761. strSavePoint = strProfile;
  762. }
  763. };
  765. class SETTING_MVP
  766. {
  767. public:
  768. SETTING_MVP() {init();}
  769. AUTOHEAL2 autoheal;
  770. BOOL bAttack;
  771. CString strAttackSkill;
  772. BOOL bFollow;
  773. BOOL bRegionAtk;
  774. CString strRegionAtkSkill;
  775. int nRegionAtkNum;
  776. BOOL bAttack2;
  777. CString strAttack2Cond;
  778. CString strAttack2Skill;
  779. BOOL bProtect;
  780. CString strProtectSkill;
  781. BOOL bAntiBless;
  783. void init()
  784. {
  785. autoheal.init();
  786. bAttack = false;
  787. strAttackSkill.Empty();
  788. bFollow = false;
  789. bRegionAtk = false;
  790. strRegionAtkSkill.Empty();
  791. nRegionAtkNum = 4;
  792. bAttack2 = false;
  793. strAttack2Cond.Empty();
  794. strAttack2Skill.Empty();
  795. bProtect = false;
  796. strProtectSkill.Empty();
  797. bAntiBless = false;
  798. }
  800. SETTING_MVP& operator= (const SETTING_MVP& that)
  801. {
  802. autoheal = that.autoheal;
  804. bAttack = that.bAttack;
  805. strAttackSkill = that.strAttackSkill;
  806. bFollow = that.bFollow;
  808. bRegionAtk = that.bRegionAtk;
  809. strRegionAtkSkill = that.strRegionAtkSkill;
  810. nRegionAtkNum = that.nRegionAtkNum;
  812. bAttack2 = that.bAttack2;
  813. strAttack2Cond = that.strAttack2Cond;
  814. strAttack2Skill = that.strAttack2Skill;
  816. bProtect = that.bProtect;
  817. strProtectSkill = that.strProtectSkill;
  819. bAntiBless = that.bAntiBless;
  821. return(*this);
  822. }
  824. CString GetProfileString()
  825. {
  826. CString strRtn, strTemp;
  828. strTemp.Format(_T("%s"), autoheal.GetProfileString());
  829. strRtn = strTemp;
  831. strTemp.Format(_T("%d,%s,%d"), bAttack, strAttackSkill, bFollow);
  832. strRtn += _T(",");
  833. strRtn += strTemp;
  835. strTemp.Format(_T("%d,%s,%d"), bRegionAtk, strRegionAtkSkill, nRegionAtkNum);
  836. strRtn += _T(",");
  837. strRtn += strTemp;
  839. strTemp.Format(_T("%d,%s,%s"), bAttack2, strAttack2Cond, strAttack2Skill);
  840. strRtn += _T(",");
  841. strRtn += strTemp;
  843. strTemp.Format(_T("%d,%s,%d"), bProtect, strProtectSkill, bAntiBless);
  844. strRtn += _T(",");
  845. strRtn += strTemp;
  847. return strRtn;
  848. }
  849. void ParseProfileString(CString& strProfile)
  850. {
  851. CString strTemp, nIndex;
  853. autoheal.ParseProfileString(strProfile);
  855. if(strProfile.GetLength() > 0 && strProfile[0] == _T(','))
  856. strProfile = strProfile.Mid(1);
  858. strTemp = utlParseString(strProfile); bAttack = atoi(strTemp);
  859. strTemp = utlParseString(strProfile); strAttackSkill = strTemp;
  860. strTemp = utlParseString(strProfile); bFollow = atoi(strTemp);
  862. strTemp = utlParseString(strProfile); bRegionAtk = atoi(strTemp);
  863. strTemp = utlParseString(strProfile); strRegionAtkSkill = strTemp;
  864. strTemp = utlParseString(strProfile); nRegionAtkNum = atoi(strTemp);
  865. strTemp = utlParseString(strProfile); bAttack2 = atoi(strTemp);
  866. strTemp = utlParseString(strProfile); strAttack2Cond = strTemp;
  867. strTemp = utlParseString(strProfile); strAttack2Skill = strTemp;
  868. strTemp = utlParseString(strProfile); bProtect = atoi(strTemp);
  869. strTemp = utlParseString(strProfile); strProtectSkill = strTemp;
  870. strTemp = utlParseString(strProfile); bAntiBless = atoi(strTemp);
  871. }
  872. };
  874. class BOSSINFO
  875. {
  876. public:
  877. BOSSINFO()
  878. {
  879. init();
  880. }
  881. CString strBossName;
  882. CTime tmBossTime;
  883. BOOL bWaring[5];
  884. void init()
  885. {
  886. strBossName = _T("");
  887. reset();
  888. }
  889. void reset()
  890. {
  891. for(int i=0; i<5; i++)
  892. bWaring[i] = false;
  893. }
  894. };
  897. typedef void (*FUNCCALL)(DWORD dwPara);
  899. void ufDummy(DWORD dwPara);
  900. void ufAutoAttackMvp(DWORD dwPara);
  901. void ufAutoSearchMvp(DWORD dwPara);
  902. void ufUseSkillWhen(DWORD dwPara);
  903. void ufUseSkillOnMvp(DWORD dwPara);
  904. void ufTeleport(DWORD dwPara);
  905. void ufRuwach(DWORD dwPara);
  906. void ufAngelus(DWORD dwPara);
  907. void ufMagnificat(DWORD dwPara);
  908. void ufGloria(DWORD dwPara);
  909. void ufEndure(DWORD dwPara);
  910. void ufHome(DWORD dwPara);
  911. void ufBossList(DWORD dwPara);
  912. void ufPartyChat(DWORD dwPara);
  913. void ufTakeItem(DWORD dwPara);
  914. void ufShowStatus(DWORD dwPara);
  915. void ufLoud(DWORD dwPara);
  916. void ufMaximize(DWORD dwPara);
  917. void ufOverthrust(DWORD dwPara);
  918. void ufAdrenaline(DWORD dwPara);
  919. void ufWeaponperfect(DWORD dwPara);
  920. void ufSpeedUp(DWORD dwPara);
  921. void ufSpeedDown(DWORD dwPara);
  922. void ufSight(DWORD dwPara);
  923. void ufConcentration(DWORD dwPara);
  924. void ufEnergyCoat(DWORD dwPara);
  925. void ufAppleIdun(DWORD dwPara);
  926. void ufAssassinCross(DWORD dwPara);
  927. void ufFrostJoke(DWORD dwPara);
  928. void ufDissonance(DWORD dwPara);
  929. void ufUglyDance(DWORD dwPara);
  930. void ufScream(DWORD dwPara);
  931. void ufAutoSaClassChange(DWORD dwPara);
  932. void ufPopupRoaWindow(DWORD dwPara);
  933. void ufShowServerIp(DWORD dwPara);
  935. void ufShowPlayers(DWORD dwPara);
  936. void ufShowCarts(DWORD dwPara);
  937. void ufShowInventory(DWORD dwPara);
  938. void ufShowMonsters(DWORD dwPara);
  939. void ufShowSkills(DWORD dwPara);
  940. void ufShowEmotion(DWORD dwPara);
  942. typedef enum
  943. {
  944. eDummy = 0,
  945. eAutoAttackMvp,
  946. eAutoSearchMvp,
  947. eUseSkillWhen,
  948. eUseSkillOnMvp,
  949. eHome,
  950. eBossList,
  951. ePartyChat,
  952. eTakeItem,
  953. eTeleport,
  954. eRuwach,
  955. eAngelus,
  956. eMagnificat,
  957. eGloria,
  958. eEndure,
  959. eLoud,
  960. eMaximize,
  961. eOverthrust,
  962. eAdrenaline,
  963. eWeaponperfect,
  964. eSight,
  965. eConcentration,
  966. eEnergyCoat,
  967. eAppleIdun,
  968. eAssassinCross,
  969. eFrostJoke,
  970. eDissonance,
  971. eUglyDance,
  972. eScream,
  973. eAutoSaClassChange,
  974. eUFMax
  975. }USERFUNCTION;
  977. extern CString UFDESC[];
  978. extern FUNCCALL UFENTRY[];
  979. extern USERFUNCTION userfuncs[12];
  980. const int UFNUM = int(eUFMax);
  982. class OPTION
  983. {
  984. public:
  985. OPTION() { init(); }
  986. BOOL bTestServer;
  987. BOOL bUsePartyChat;
  988. BOOL bAutoPickup;
  989. BOOL bMovePickup;
  990. BOOL bBossInfo;
  991. CString strLauncher;
  992. CString strLaunchParam;
  993. BOOL bNpcTalkContinue;
  994. int nWelcomeDelay;
  995. int nAutoSearchDelay;
  996. int nAttackPerSecond;
  997. int nPickupDistance;
  998. CString strHPRecoverItems;
  999. CString strSPRecoverItems;
  1000. int nItemUseInterval;
  1002. void init()
  1003. {
  1004. bTestServer = false;
  1005. bUsePartyChat = false;
  1006. bAutoPickup = true;
  1007. bMovePickup = false;
  1008. bBossInfo = true;
  1009. strLauncher.Empty();
  1010. strLaunchParam.Empty();
  1011. bNpcTalkContinue = true;
  1012. nWelcomeDelay = 15000;
  1013. nAutoSearchDelay = 300;
  1014. nAttackPerSecond = 1;
  1015. nPickupDistance = 5;
  1016. strHPRecoverItems = _T("红色药水|赤色药水|黄色药水|白色药水");
  1017. strSPRecoverItems = _T("蜂蜜|蓝色药水|蓝色药草|葡萄|葡萄汁|蜂胶");
  1018. nItemUseInterval = 200;
  1019. }
  1020. OPTION& operator= (const OPTION& that)
  1021. {
  1022. bTestServer = that.bTestServer;
  1023. bUsePartyChat = that.bUsePartyChat;
  1024. bAutoPickup = that.bAutoPickup;
  1025. bMovePickup = that.bMovePickup;
  1026. bBossInfo = that.bBossInfo;
  1027. strLauncher = that.strLauncher;
  1028. strLaunchParam = that.strLaunchParam;
  1029. bNpcTalkContinue = that.bNpcTalkContinue;
  1030. nWelcomeDelay = that.nWelcomeDelay;
  1031. nAutoSearchDelay = that.nAutoSearchDelay;
  1032. nAttackPerSecond = that.nAttackPerSecond;
  1033. nPickupDistance = that.nPickupDistance;
  1034. strHPRecoverItems = that.strHPRecoverItems;
  1035. strSPRecoverItems = that.strSPRecoverItems;
  1036. nItemUseInterval = that.nItemUseInterval;
  1038. return(*this);
  1039. }
  1040. };
  1041. typedef CIdArray<INVENTORY, INVENTORY> INVENTORYARRAY;
  1042. typedef CIdArray<MONSTER, MONSTER> MONSTERARRAY;
  1043. typedef CIdArray<PLAYER, PLAYER> PLAYERARRAY;
  1044. typedef CIdArray<PORTAL, PORTAL> PORTALARRAY;
  1045. typedef CIdArray<ITEM, ITEM> ITEMARRAY;
  1046. typedef CIdArray<SKILL, SKILL> SKILLARRAY;
  1047. typedef CIdArray<DAMAGE, DAMAGE> DAMAGEARRAY;
  1048. typedef CArray<BOSSINFO, BOSSINFO> BOSSINFOARRAY;
  1049. typedef CIdArray<SPELL, SPELL> SPELLARRAY;
  1051. extern CSocket sockInject;
  1052. extern CSocket sockServer;
  1053. extern int nConnState;
  1054. extern DWORD dwAccountId;
  1055. extern DWORD dwCharId;
  1056. extern DWORD dwSessionId;
  1057. extern BOOL bWelcomeSent;
  1058. extern CFile fLog;
  1059. extern YOU youTemp[3];
  1060. extern int nCharSelected;
  1062. extern INVENTORYARRAY inventory;
  1063. extern MONSTERARRAY monsters;
  1064. extern YOU you;
  1065. extern PLAYERARRAY players;
  1066. extern PLAYERARRAY partners;
  1067. extern PORTALARRAY portals;
  1068. extern ITEMARRAY items;
  1069. extern INVENTORYARRAY cart;
  1070. extern SKILLARRAY skills;
  1071. extern DAMAGEARRAY damages;
  1072. extern BOSSINFOARRAY bossinfo;
  1073. extern SPELLARRAY spells;
  1075. extern CWinThread *pWorkingThread;
  1076. extern int nThreadTerm;
  1077. extern BOOL bConnected;
  1079. extern LOG_LEVEL llFile;
  1080. extern LOG_LEVEL llDlg;
  1081. extern LOG_LEVEL llRo;
  1083. extern CROAMap mapItem;
  1084. extern CROAMap mapItemType;
  1085. extern CROAMap mapEquipType;
  1086. extern CROAMap mapMapName;
  1087. extern CROAMap mapJob;
  1088. extern CROAMap mapSex;
  1089. extern CROAMap mapSkill;
  1090. extern CROAMap mapMvpMonster;
  1091. extern CROAMap mapMonster;
  1092. extern CROAMap mapStatus011f;
  1093. extern CROAMap mapStatus0119;
  1094. extern CROAMap mapElements;
  1095. extern CROAMap mapSkillsst;
  1097. extern CROAField field;
  1099. //extern CRITICAL_SECTION criticalSection;
  1100. extern OPTION option;
  1101. extern SETTING_CMN settingcmn;
  1102. extern SETTING_MVP settingmvp;
  1104. extern BOOL bFlyUsed;
  1105. extern BOOL bAutoSearch;
  1106. extern CString strAutoSearchMap;
  1107. extern DWORD dwAutoSearchTick;
  1108. extern BOOL bAutoSa;
  1109. extern DWORD dwAutoSaTick;
  1111. extern BOOL bProfileLoaded;
  1112. extern HHOOK hHook;
  1113. extern HINSTANCE hInstDll;
  1114. extern FUNCCALL curFunc;
  1115. extern DWORD curFuncPara;
  1117. extern BOOL bAiEnabled;
  1119. extern CString EMOTIONDEF[];
  1120. extern CString emotions[10];
  1121. const int EMNUM = 48;
  1124. //#define TIMEOUT_AUTOSEARCH 200
  1125. #define TIMEOUT_SIT 2000
  1126. #define TIMEOUT_STAND 2000
  1127. #define TIMEOUT_PICKUP 6000
  1128. #define TIMEOUT_ATTACK 5000
  1129. #define TIMEOUT_MOVE 3000
  1130. #define SECOND_PER_BLOCK 100
  1132. extern DWORD dwUseItemTick;
  1133. extern DWORD dwAttackTick;
  1134. extern CROAMap mapAvoidAid;
  1136. extern BYTE mode;
  1137. extern DWORD dwMvpId;
  1139. extern char cSendKey[MAX_PATH];
  1141. extern CStringArray HPITEMS;
  1142. extern CStringArray SPITEMS;
  1144. enum
  1145. {
  1146. eUnknown,
  1147. eRagexe,
  1148. eSakexe,
  1149. eSfExe
  1150. };
  1152. enum
  1153. {
  1154. eWindowBattle,
  1155. eWindowOption
  1156. };
  1158. extern CRITICAL_SECTION csShortcutFuncs;
  1159. extern BOOL bIsModal;
  1160. extern BYTE serverip[3][6];
  1162. //LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam);
  1163. #endif //AFX_ROADEFS_H__B246916D_8303_42EE_AF13_20D988742F4D__INCLUDED_