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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
UserInfo.cpp
资源名称：evil’s illusion Server Codes.rar　[点击查看]
上传用户：tt_chan
上传日期：2009-12-03
资源大小：4523k
文件大小：29k
源码类别：

模拟服务器

开发平台：

Visual C++

UserInfo.cpp：源码内容
  1. #include "stdafx.h"
  3. void UpdateStatusBarUsers(BOOL fGrow);
  4. void SendRDBSocket(int nCertification, char *pszData1, char *pszData2, int nData2Len);
  6. CUserInfo::CUserInfo()
  7. {
  8. m_bEmpty = true;
  10. m_pxPlayerObject = NULL;
  11. m_pGateInfo = NULL;
  13. m_nNumOfMagics = 0;
  14. m_nNumOfGenItems = 0;
  15. m_nNumOfItems = 0;
  17. m_lpTMagicErgumSkill = NULL;
  18. m_lpTMagicBanwolSkill = NULL;
  19. m_lpTMagicFireSwordSkill = NULL;
  20. m_lpTMagicOneSwordSkill = NULL;
  21. m_lpTMagicIlkwangSkill = NULL;
  22. m_lpTMagicPowerHitSkill = NULL;
  24. m_fLongHitSkill = FALSE;
  25. m_fWideHitSkill = FALSE;
  26. m_fFireHitSkill = FALSE;
  28. m_dwLatestFireHitTime = 0;
  29. }
  31. bool CUserInfo::IsEmpty()
  32. {
  33. return m_bEmpty;
  34. }
  35. /*
  36. void CUserInfo::RandomUpgradeItem(WORD wStdMode, _LPTMAKEITEMRCD lpMakeItemRcd)
  37. {
  38. if (wStdMode == 5 || wStdMode == 6)
  39. g_pStdItemWeapon[lpMakeItemRcd->nStdIndex - 1].UpgradeRandomItem(lpMakeItemRcd);
  40. else if (wStdMode == 10 || wStdMode == 11)
  41. g_pStdItemArmor[lpMakeItemRcd->nStdIndex - 1].UpgradeRandomItem(lpMakeItemRcd);
  42. else if (wStdMode >= 21 && wStdMode <= 50)
  43. g_pStdItemAccessory[lpMakeItemRcd->nStdIndex - 1].UpgradeRandomItem(lpMakeItemRcd);
  44. }
  45. */
  46. void CUserInfo::AddNewItem(char *pszItemName)
  47. {
  48. int i;
  49. // WORD wStdMode;
  51. _TMAKEITEMRCD MakeItemRcd;
  53. if (m_lpTItemRcd.GetCount() + m_lpTGenItemRcd.GetCount() > USERITEMMAX) return;
  55. int nLen = memlen(pszItemName) - 1;
  56. int nCmpLen;
  58. for (i = 0; i < g_nStdItemSpecial; i++)
  59. {
  60. nCmpLen = memlen(g_pStdItemSpecial[i].szName) - 1;
  62. if (nCmpLen == nLen)
  63. {
  64. if (memcmp(g_pStdItemSpecial[i].szName, pszItemName, nLen) == 0)
  65. {
  66. ZeroMemory(MakeItemRcd.btValue, sizeof(MakeItemRcd.btValue));
  68. MakeItemRcd.nStdIndex = i;
  70. switch (g_pStdItemSpecial[i].btType)
  71. {
  72. case 0:
  73. MakeItemRcd.szStdType = 'A';
  74. break;
  75. case 1:
  76. MakeItemRcd.szStdType = 'B';
  77. break;
  78. case 2:
  79. MakeItemRcd.szStdType = 'C';
  80. break;
  81. }
  83. MakeItemRcd.nDura = g_pStdItemSpecial[i].wDuraMax;
  84. MakeItemRcd.nDuraMax = g_pStdItemSpecial[i].wDuraMax;
  86. // wStdMode = g_pStdItemSpecial[i].wStdMode;
  88. if (rand() % 10 == 0)
  89. g_pStdItemSpecial[i].UpgradeRandomItem(MakeItemRcd.btValue, MakeItemRcd.nDura, MakeItemRcd.nDuraMax);
  91. MakeItemToDB((int)this, m_szUserID, m_szCharName, &MakeItemRcd);
  92. }
  93. }
  94. }
  96. for (i = 0; i < g_nStdItemEtc; i++)
  97. {
  98. nCmpLen = memlen(g_pStdItemEtc[i].szName) - 1;
  100. if (nCmpLen == nLen)
  101. {
  102. if (memcmp(g_pStdItemEtc[i].szName, pszItemName, nLen) == 0)
  103. {
  104. _LPTGENERALITEMRCD lptGenItemRcd = new _TGENERALITEMRCD;
  106. if (lptGenItemRcd)
  107. {
  108. // lptGenItemRcd->szStdType = g_pStdItemEtc[i].m_btType;
  109. lptGenItemRcd->nStdIndex = i;
  110. lptGenItemRcd->nDura = g_pStdItemEtc[i].wDuraMax;
  111. lptGenItemRcd->nDuraMax = g_pStdItemEtc[i].dwRSource;
  113. MakeGenItem(lptGenItemRcd);
  114. }
  116. return;
  117. }
  118. }
  119. }
  120. }
  122. void CUserInfo::MakeGenItem(_LPTGENERALITEMRCD lptGenItemRcd)
  123. {
  124. if (m_pxPlayerObject)
  125. {
  126. // Make Item on Server
  127. _TGENITEMRCD GenItemRcd;
  129. sprintf(GenItemRcd.szItem, "G%03d%04d%04d", lptGenItemRcd->nStdIndex, lptGenItemRcd->nDura, lptGenItemRcd->nDuraMax);
  131. memcpy(lptGenItemRcd->szMakeIndex, GenItemRcd.szItem, 12);
  133. m_lpTGenItemRcd.AddNewNode(lptGenItemRcd);
  135. _TCLIENTITEMRCD tClientItemRcd;
  136. _TDEFAULTMESSAGE SendDefMsg;
  137. char szEncodeMsg[256];
  139. fnMakeDefMessage(&SendDefMsg, SM_ADDITEM, (int)m_pxPlayerObject, 0, 0, 1);
  141. // Get Standard General Item (STDITEM_ETC)
  142. g_pStdItemEtc[lptGenItemRcd->nStdIndex].GetStandardItem(&tClientItemRcd);
  144. memcpy(tClientItemRcd.szMakeIndex, lptGenItemRcd->szMakeIndex, 12);
  145. tClientItemRcd.nDura = lptGenItemRcd->nDura;
  146. tClientItemRcd.nDuraMax = lptGenItemRcd->nDuraMax;
  148. int nIdx =  fnEncode6BitBufA((unsigned char *)&tClientItemRcd, szEncodeMsg, sizeof(_TCLIENTITEMRCD), sizeof(szEncodeMsg));
  149. szEncodeMsg[nIdx] = '';
  151. m_pxPlayerObject->SendSocket(&SendDefMsg, szEncodeMsg);
  152. }
  153. }
  155. int CUserInfo::GetDressFeature()
  156. {
  157. if (m_lpTItemRcd.GetCount())
  158. {
  159. PLISTNODE pListNode = m_lpTItemRcd.GetHead();
  161. while (pListNode)
  162. {
  163. _LPTUSERITEMRCD lpTItemRcd = m_lpTItemRcd.GetData(pListNode);
  165. if (memcmp(m_THumanRcd.szTakeItem[U_DRESS], lpTItemRcd->szMakeIndex, _MAKEITEMINDEX) == 0)
  166. return g_pStdItemSpecial[lpTItemRcd->nStdIndex].wShape;
  168. pListNode = m_lpTItemRcd.GetNext(pListNode);
  169. }
  170. }
  172. return 0;
  173. }
  175. int CUserInfo::GetWeaponFeature()
  176. {
  177. if (m_lpTItemRcd.GetCount())
  178. {
  179. PLISTNODE pListNode = m_lpTItemRcd.GetHead();
  181. while (pListNode)
  182. {
  183. _LPTUSERITEMRCD lpTItemRcd = m_lpTItemRcd.GetData(pListNode);
  185. if (memcmp(m_THumanRcd.szTakeItem[U_WEAPON], lpTItemRcd->szMakeIndex, _MAKEITEMINDEX) == 0)
  186. return g_pStdItemSpecial[lpTItemRcd->nStdIndex].wShape;
  188. pListNode = m_lpTItemRcd.GetNext(pListNode);
  189. }
  190. }
  192. return 0;
  193. }
  195. _LPTUSERITEMRCD CUserInfo::GetItem(char *pszMakeIndex)
  196. {
  197. if (m_lpTItemRcd.GetCount())
  198. {
  199. PLISTNODE pListNode = m_lpTItemRcd.GetHead();
  201. while (pListNode)
  202. {
  203. _LPTUSERITEMRCD lpTItemRcd = m_lpTItemRcd.GetData(pListNode);
  205. if (memcmp(pszMakeIndex, lpTItemRcd->szMakeIndex, _MAKEITEMINDEX) == 0)
  206. return lpTItemRcd;
  208. pListNode = m_lpTItemRcd.GetNext(pListNode);
  209. }
  210. }
  212. return NULL;
  213. }
  215. _LPTGENERALITEMRCD CUserInfo::GetUseGenItem(char *pszMakeItemID)
  216. {
  217. if (m_lpTGenItemRcd.GetCount())
  218. {
  219. PLISTNODE pListNode = m_lpTGenItemRcd.GetHead();
  221. while (pListNode)
  222. {
  223. _LPTGENERALITEMRCD lpTItemRcd = m_lpTGenItemRcd.GetData(pListNode);
  225. if (memcmp(pszMakeItemID, lpTItemRcd->szMakeIndex, _MAKEITEMINDEX) == 0)
  226. return lpTItemRcd;
  228. pListNode = m_lpTGenItemRcd.GetNext(pListNode);
  229. }
  230. }
  232. return NULL;
  233. }
  235. BOOL CUserInfo::IsMyMagic(int nIndex)
  236. {
  237. if (m_lpTMagicRcd.GetCount())
  238. {
  239. _LPTHUMANMAGICRCD lptUserMagicRcd;
  241. PLISTNODE pListNode = m_lpTMagicRcd.GetHead();
  243. while (pListNode)
  244. {
  245. lptUserMagicRcd = m_lpTMagicRcd.GetData(pListNode);
  247. if (lptUserMagicRcd->btMagicID == nIndex)
  248. return TRUE;
  250. pListNode = m_lpTMagicRcd.GetNext(pListNode);
  251. }
  252. }
  254. return FALSE;
  255. }
  257. int CUserInfo::EncodeMyMagicToServer(char *pszEncodeMsg, int nBuffSize, int& nPos)
  258. {
  259. int nCnt = 0;
  261. if (m_lpTMagicRcd.GetCount())
  262. {
  263. _LPTHUMANMAGICRCD lptUserMagicRcd;
  265. PLISTNODE pListNode = m_lpTMagicRcd.GetHead();
  267. while (pListNode)
  268. {
  269. lptUserMagicRcd = m_lpTMagicRcd.GetData(pListNode);
  271. if (lptUserMagicRcd)
  272. {
  273. nPos += fnEncode6BitBufA((unsigned char *)lptUserMagicRcd, pszEncodeMsg + nPos, sizeof(_THUMANMAGICRCD), nBuffSize - nPos);
  275. *(pszEncodeMsg + nPos) = '/';
  277. nPos++;
  278. nCnt++;
  279. }
  281. pListNode = m_lpTMagicRcd.GetNext(pListNode);
  282. }
  283. }
  285. return nCnt;
  286. }
  288. int CUserInfo::EncodeMyMagic(char *pszEncodeMsg, int nBuffSize, int& nPos)
  289. {
  290. int nCnt = 0;
  292. if (m_lpTMagicRcd.GetCount())
  293. {
  294. _LPTHUMANMAGICRCD lptUserMagicRcd;
  295. _TCLIENTMAGICRCD tClientMagicRcd;
  297. PLISTNODE pListNode = m_lpTMagicRcd.GetHead();
  299. while (pListNode)
  300. {
  301. lptUserMagicRcd = m_lpTMagicRcd.GetData(pListNode);
  303. if (lptUserMagicRcd)
  304. {
  305. tClientMagicRcd.btMagicID = lptUserMagicRcd->btMagicID;
  306. tClientMagicRcd.btLevel = lptUserMagicRcd->btLevel;
  307. tClientMagicRcd.btUseKey = lptUserMagicRcd->btUseKey;
  308. tClientMagicRcd.nCurrTrain = lptUserMagicRcd->nCurrTrain;
  310. tClientMagicRcd.tStdMagic.btEffect = (BYTE)g_pMagicInfo[lptUserMagicRcd->btMagicID].sEffect;
  311. tClientMagicRcd.tStdMagic.btEffectType = (BYTE)g_pMagicInfo[lptUserMagicRcd->btMagicID].sEffectType;
  312. memcpy(&tClientMagicRcd.tStdMagic.sNeed, g_pMagicInfo[lptUserMagicRcd->btMagicID].sNeed, sizeof(tClientMagicRcd.tStdMagic.sNeed));
  313. memcpy(&tClientMagicRcd.tStdMagic.nTrain, g_pMagicInfo[lptUserMagicRcd->btMagicID].nTrain, sizeof(tClientMagicRcd.tStdMagic.nTrain));
  314. tClientMagicRcd.tStdMagic.btDefSpell = (BYTE)g_pMagicInfo[lptUserMagicRcd->btMagicID].sDefSpell;
  315. tClientMagicRcd.tStdMagic.nDelayTime = g_pMagicInfo[lptUserMagicRcd->btMagicID].sDelay;
  317. nPos += fnEncode6BitBufA((unsigned char *)&tClientMagicRcd, pszEncodeMsg + nPos, sizeof(_TCLIENTMAGICRCD), nBuffSize - nPos);
  319. *(pszEncodeMsg + nPos) = '/';
  321. nPos++;
  322. nCnt++;
  323. }
  325. pListNode = m_lpTMagicRcd.GetNext(pListNode);
  326. }
  327. }
  329. return nCnt;
  330. }
  332. void CUserInfo::RemoveGenItem(_LPTGENERALITEMRCD lptItemRcd)
  333. {
  334. if (m_lpTGenItemRcd.GetCount())
  335. {
  336. _LPTGENERALITEMRCD lptGenItemRcd;
  338. PLISTNODE pListNode = m_lpTGenItemRcd.GetHead();
  340. while (pListNode)
  341. {
  342. lptGenItemRcd = m_lpTGenItemRcd.GetData(pListNode);
  344. if (lptGenItemRcd == lptItemRcd)
  345. {
  346. m_lpTGenItemRcd.RemoveNode(pListNode);
  347. delete lptGenItemRcd;
  348. lptGenItemRcd = NULL;
  349. return;
  350. }
  352. pListNode = m_lpTGenItemRcd.GetNext(pListNode);
  353. }
  354. }
  355. }
  357. int CUserInfo::EncodeGenItem(char *pszEncodeMsg, int nBuffSize, int& nPos)
  358. {
  359. int nCnt = 0;
  361. if (m_lpTGenItemRcd.GetCount())
  362. {
  363. _LPTGENERALITEMRCD lptGenItemRcd;
  364. _TGENITEMRCD GenItemRcd;
  365. TCHAR wszItem[13];
  367. PLISTNODE pListNode = m_lpTGenItemRcd.GetHead();
  369. while (pListNode)
  370. {
  371. lptGenItemRcd = m_lpTGenItemRcd.GetData(pListNode);
  373. if (lptGenItemRcd)
  374. {
  375. wsprintf(wszItem, _TEXT("G%03d%04d%04d"), lptGenItemRcd->nStdIndex, lptGenItemRcd->nDura, lptGenItemRcd->nDuraMax);
  376. WideCharToMultiByte(CP_ACP, 0, wszItem, -1, GenItemRcd.szItem, sizeof(GenItemRcd.szItem), NULL, NULL);
  378. nPos += fnEncode6BitBufA((unsigned char *)&GenItemRcd, pszEncodeMsg + nPos, sizeof(_TGENITEMRCD), nBuffSize - nPos);
  380. *(pszEncodeMsg + nPos) = '/';
  382. nPos++;
  383. nCnt++;
  384. }
  386. pListNode = m_lpTGenItemRcd.GetNext(pListNode);
  387. }
  388. }
  390. return nCnt;
  391. }
  393. void CUserInfo::AllowLongHitSkill(BOOL fFlag)
  394. {
  395. TCHAR szText[64];
  396. char szMsg[64];
  398. m_fLongHitSkill = fFlag;
  400. if (m_fLongHitSkill)
  401. LoadString(g_hInst, IDS_ALLOW_LONGHIT, szText, sizeof(szText)/sizeof(TCHAR));
  402. else
  403. LoadString(g_hInst, IDS_NOTALLOW_LONGHIT, szText, sizeof(szText)/sizeof(TCHAR));
  405. WideCharToMultiByte(CP_ACP, 0, szText, -1, szMsg, sizeof(szMsg), NULL, NULL);
  407. m_pxPlayerObject->SysMsg(szMsg, 1);
  408. }
  410. void CUserInfo::AllowWideHitSkill(BOOL fFlag)
  411. {
  412. TCHAR szText[64];
  413. char szMsg[64];
  415. m_fWideHitSkill = fFlag;
  417. if (m_fWideHitSkill)
  418. LoadString(g_hInst, IDS_ALLOW_WIDEHIT, szText, sizeof(szText)/sizeof(TCHAR));
  419. else
  420. LoadString(g_hInst, IDS_NOTALLOW_WIDEHIT, szText, sizeof(szText)/sizeof(TCHAR));
  422. WideCharToMultiByte(CP_ACP, 0, szText, -1, szMsg, sizeof(szMsg), NULL, NULL);
  424. m_pxPlayerObject->SysMsg(szMsg, 1);
  425. }
  427. BOOL CUserInfo::AllowFireHitSkill()
  428. {
  429. TCHAR szText[128];
  430. char szMsg[128];
  432. if (GetTickCount() - m_dwLatestFireHitTime > 10 * 1000)
  433. {
  434. m_fFireHitSkill = TRUE;
  435. m_dwLatestFireHitTime = GetTickCount();
  437. LoadString(g_hInst, IDS_ALLOW_FIREHIT, szText, sizeof(szText)/sizeof(TCHAR));
  438. WideCharToMultiByte(CP_ACP, 0, szText, -1, szMsg, sizeof(szMsg), NULL, NULL);
  440. m_pxPlayerObject->SysMsg(szMsg, 1);
  442. return TRUE;
  443. }
  444. else
  445. {
  446. LoadString(g_hInst, IDS_NOTALLOW_FIREHIT, szText, sizeof(szText)/sizeof(TCHAR));
  447. WideCharToMultiByte(CP_ACP, 0, szText, -1, szMsg, sizeof(szMsg), NULL, NULL);
  449. m_pxPlayerObject->SysMsg(szMsg, 0);
  450. }
  452. return FALSE;
  453. }
  455. int CUserInfo::GetGenItemStdIdx(char *pszMakeIndex)
  456. {
  457. char szStdIdx[5];
  459. ZeroMemory(szStdIdx, sizeof(szStdIdx));
  460. memmove(szStdIdx, &pszMakeIndex[1], 3);
  462. return AnsiStrToVal(szStdIdx);
  463. }
  465. int CUserInfo::GetGenItemVal1(char *pszMakeIndex)
  466. {
  467. char szVal1[5];
  469. ZeroMemory(szVal1, sizeof(szVal1));
  470. memmove(szVal1, &pszMakeIndex[4], 4);
  472. return AnsiStrToVal(szVal1);
  473. }
  475. int CUserInfo::GetGenItemVal2(char *pszMakeIndex)
  476. {
  477. char szVal2[5];
  479. ZeroMemory(szVal2, sizeof(szVal2));
  480. memmove(szVal2, &pszMakeIndex[8], 4);
  482. return AnsiStrToVal(szVal2);
  483. }
  485. int CUserInfo::CalcBagWeight()
  486. {
  487. int nWeight = 0;
  489. if (m_lpTItemRcd.GetCount())
  490. {
  491. PLISTNODE pListNode = m_lpTItemRcd.GetHead();
  493. while (pListNode)
  494. {
  495. _LPTUSERITEMRCD lpTItemRcd = m_lpTItemRcd.GetData(pListNode);
  497. if (lpTItemRcd)
  498. nWeight += g_pStdItemSpecial[lpTItemRcd->nStdIndex].wWeight;
  500. pListNode = m_lpTItemRcd.GetNext(pListNode);
  501. }
  502. }
  504. if (m_lpTGenItemRcd.GetCount())
  505. {
  506. _LPTGENERALITEMRCD lptGenItemRcd;
  508. PLISTNODE pListNode = m_lpTGenItemRcd.GetHead();
  510. while (pListNode)
  511. {
  512. lptGenItemRcd = m_lpTGenItemRcd.GetData(pListNode);
  514. if (lptGenItemRcd)
  515. nWeight += g_pStdItemEtc[lptGenItemRcd->nStdIndex].wWeight;
  517. pListNode = m_lpTGenItemRcd.GetNext(pListNode);
  518. }
  519. }
  521. return nWeight;
  522. }
  524. int CUserInfo::CalcWearWeightEx(int nIndex)
  525. {
  526. _LPTUSERITEMRCD lptItemRcd;
  527. int nWeight = 0;
  529. for (int i = 0; i < 8; i++)
  530. {
  531. if ((i != nIndex) && (i != U_WEAPON) && (i != U_RIGHTHAND))
  532. {
  533. lptItemRcd = GetUseItem(i);
  535. if (lptItemRcd)
  536. nWeight += g_pStdItemSpecial[lptItemRcd->nStdIndex].wWeight;
  537. }
  538. }
  540. return nWeight;
  541. }
  543. BOOL CUserInfo::UserDropItem(int nItemIndex, char *pszMakeIndex)
  544. {
  545. if (!m_pxPlayerObject) return FALSE;
  547. if (m_lpTItemRcd.GetCount())
  548. {
  549. PLISTNODE pListNode = m_lpTItemRcd.GetHead();
  551. while (pListNode)
  552. {
  553. _LPTUSERITEMRCD lpTItemRcd = m_lpTItemRcd.GetData(pListNode);
  555. if (memcmp(pszMakeIndex, lpTItemRcd->szMakeIndex, _MAKEITEMINDEX) == 0)
  556. {
  557. if (m_pxPlayerObject->DropItemDown(lpTItemRcd, 2, FALSE))
  558. {
  559. m_pxPlayerObject->UpdateItemToDB(lpTItemRcd, _ITEM_ACTION_THROW);
  561. // delete lpTItemRcd;
  562. m_lpTItemRcd.RemoveNode(pListNode);
  564. m_pxPlayerObject->WeightChanged();
  566. return TRUE;
  567. }
  568. }
  570. pListNode = m_lpTItemRcd.GetNext(pListNode);
  571. }
  572. }
  574. return FALSE;
  575. }
  577. BOOL CUserInfo::UserDropGenItem(int nItemIndex, char *pszMakeIndex)
  578. {
  579. if (!m_pxPlayerObject) return FALSE;
  581. if (m_lpTGenItemRcd.GetCount())
  582. {
  583. PLISTNODE pListNode = m_lpTGenItemRcd.GetHead();
  585. while (pListNode)
  586. {
  587. _LPTGENERALITEMRCD lpTItemRcd = m_lpTGenItemRcd.GetData(pListNode);
  589. if (memcmp(pszMakeIndex, lpTItemRcd->szMakeIndex, _MAKEITEMINDEX) == 0)
  590. {
  591. if (m_pxPlayerObject->DropItemDown((_LPTUSERITEMRCD)lpTItemRcd, 2, TRUE))
  592. {
  593. // delete lpTItemRcd;
  594. m_lpTGenItemRcd.RemoveNode(pListNode);
  596. m_pxPlayerObject->WeightChanged();
  598. return TRUE;
  599. }
  600. }
  602. pListNode = m_lpTGenItemRcd.GetNext(pListNode);
  603. }
  604. }
  606. return FALSE;
  607. }
  609. BOOL CUserInfo::IncGold(int nGold)
  610. {
  611. if (m_THumanRcd.dwGold + nGold <= BAGGOLD)
  612. {
  613. m_THumanRcd.dwGold  += nGold;
  614. return TRUE;
  615. }
  617. return FALSE;
  618. }
  620. BOOL CUserInfo::DecGold(int nGold)
  621. {
  622. if (m_THumanRcd.dwGold - nGold >= 0)
  623. {
  624. m_THumanRcd.dwGold  -= nGold;
  625. return TRUE;
  626. }
  628. return FALSE;
  629. }
  631. _LPTHUMANMAGICRCD CUserInfo::GetMagicRcdByKey(int nKey)
  632. {
  633. PLISTNODE pListNode = m_lpTMagicRcd.GetHead();
  635. while (pListNode)
  636. {
  637. _LPTHUMANMAGICRCD lptUserMagicRcd = m_lpTMagicRcd.GetData(pListNode);
  639. if (lptUserMagicRcd)
  640. {
  641. if (lptUserMagicRcd->btUseKey == nKey)
  642. return lptUserMagicRcd;
  643. }
  645. pListNode = m_lpTMagicRcd.GetNext(pListNode);
  646. }
  648. return NULL;
  649. }
  651. _LPTHUMANMAGICRCD CUserInfo::GetMagicRcdByID(int nID)
  652. {
  653. PLISTNODE pListNode = m_lpTMagicRcd.GetHead();
  655. while (pListNode)
  656. {
  657. _LPTHUMANMAGICRCD lptUserMagicRcd = m_lpTMagicRcd.GetData(pListNode);
  659. if (lptUserMagicRcd)
  660. {
  661. if (lptUserMagicRcd->btMagicID == nID)
  662. return lptUserMagicRcd;
  663. }
  665. pListNode = m_lpTMagicRcd.GetNext(pListNode);
  666. }
  668. return NULL;
  669. }
  671. _LPTGENERALITEMRCD CUserInfo::CanUseBujuk()
  672. {
  673. _LPTGENERALITEMRCD lptItem = GetUseGenItem(m_THumanRcd.szTakeItem[U_ARMRINGL]);
  675. if (lptItem)
  676. {
  677. if (lptItem->szMakeIndex[0] == 'G')
  678. {
  679. int nIndex = GetGenItemStdIdx(lptItem->szMakeIndex);
  681. if (g_pStdItemEtc[nIndex].wStdMode == 25 || g_pStdItemEtc[nIndex].wStdMode == 5)
  682. return lptItem;
  683. }
  684. }
  686. return NULL;
  687. }
  689. void CUserInfo::ProcessUserMessage(char *pszPacket)
  690. {
  691. _LPTDEFAULTMESSAGE lpDefMsg = (_LPTDEFAULTMESSAGE)pszPacket;
  693. if (m_pxPlayerObject->m_fIsCapture)
  694. {
  695. if (m_pxPlayerObject->m_hCaptureFile)
  696. {
  697. DWORD dwWrite = 0;
  699. fprintf(m_pxPlayerObject->m_hCaptureFile, "%d, %d, %d, %d, %drn", lpDefMsg->wIdent, lpDefMsg->nRecog, lpDefMsg->wParam, lpDefMsg->wTag, lpDefMsg->wSeries);
  701. switch (lpDefMsg->wIdent)
  702. {
  703. case CM_SAY:
  704. case CM_PICKUP:
  705. {
  706. char szDecodeMsg[512];
  707. int nPos = fnDecode6BitBufA(pszPacket + sizeof(_TDEFAULTMESSAGE), szDecodeMsg, sizeof(szDecodeMsg));
  708. szDecodeMsg[nPos] = '';
  710. fprintf(m_pxPlayerObject->m_hCaptureFile, "%srn", szDecodeMsg);
  711. }
  712. }
  713. }
  714. }
  716. switch (lpDefMsg->wIdent)
  717. {
  718. case CM_HIT:
  719. case CM_POWERHIT:
  720. case CM_LONGHIT:
  721. case CM_WIDEHIT:
  722. case CM_HEAVYHIT:
  723. case CM_BIGHIT:
  724. case CM_FIREHIT:
  725. m_pxPlayerObject->AddProcess(m_pxPlayerObject, lpDefMsg->wIdent, lpDefMsg->wTag, LOWORD(lpDefMsg->nRecog), HIWORD(lpDefMsg->nRecog), lpDefMsg->wParam, NULL);
  726. break;
  727. case CM_TURN:
  728. case CM_WALK:
  729. case CM_RUN:
  730. case CM_SITDOWN:
  731. case CM_RIDE:
  732. m_pxPlayerObject->AddProcess(m_pxPlayerObject, lpDefMsg->wIdent, lpDefMsg->wTag, LOWORD(lpDefMsg->nRecog), HIWORD(lpDefMsg->nRecog), NULL);
  733. break;
  734. case CM_SAY:
  735. m_pxPlayerObject->AddProcess(m_pxPlayerObject, lpDefMsg->wIdent, 0, 0, 0, 0, pszPacket + sizeof(_TDEFAULTMESSAGE));
  736. break;
  737. case CM_SPELL:
  738. m_pxPlayerObject->AddProcess(m_pxPlayerObject, lpDefMsg->wIdent, 
  739. lpDefMsg->wTag/*MagicID*/, LOWORD(lpDefMsg->nRecog)/*TargetX*/, HIWORD(lpDefMsg->nRecog)/*TargetY*/, 
  740. MAKELONG(lpDefMsg->wSeries, lpDefMsg->wParam)/*TargetObj*/, NULL);
  741. break;
  742. case CM_TAKEONITEM:
  743. case CM_TAKEOFFITEM:
  744. m_pxPlayerObject->AddProcess(m_pxPlayerObject, lpDefMsg->wIdent, lpDefMsg->wSeries, lpDefMsg->nRecog, lpDefMsg->wParam, lpDefMsg->wTag, pszPacket + sizeof(_TDEFAULTMESSAGE));
  745. break;
  746.         case CM_QUERYUSERNAME:
  747. m_pxPlayerObject->AddProcess(m_pxPlayerObject, lpDefMsg->wIdent, 0, lpDefMsg->nRecog, lpDefMsg->wParam, lpDefMsg->wTag, NULL);
  748. break;
  749. case CM_EAT:
  750. case CM_DROPITEM:
  751. m_pxPlayerObject->AddProcess(m_pxPlayerObject, lpDefMsg->wIdent, lpDefMsg->wSeries, 0, 0, 0, pszPacket + sizeof(_TDEFAULTMESSAGE));
  752. break;
  753. case CM_PICKUP:
  754. m_pxPlayerObject->AddProcess(m_pxPlayerObject, lpDefMsg->wIdent, lpDefMsg->wSeries, lpDefMsg->nRecog, lpDefMsg->wTag, lpDefMsg->wParam);
  755. break;
  756. default:
  757. m_pxPlayerObject->AddProcess(m_pxPlayerObject, lpDefMsg->wIdent, lpDefMsg->wSeries, lpDefMsg->nRecog, lpDefMsg->wTag, NULL);
  758. }
  759. /* case CM_QUERYUSERNAME:
  760.             begin
  761.                hum.SendMsg (hum, pmsg.Ident, 0, pmsg.Recog, pmsg.Param{x}, pmsg.Tag{y}, '');
  762.             end;
  764.          //string 颇扼皋磐啊 乐澜.
  765. case CM_DROPITEM:
  766. case CM_TAKEOFFITEM:
  767. case CM_EXCHGTAKEONITEM:
  768. case CM_MERCHANTDLGSELECT:
  769. case CM_MERCHANTQUERYSELLPRICE:
  770. case CM_MERCHANTQUERYREPAIRCOST:
  771. case CM_USERSELLITEM:
  772. case CM_USERREPAIRITEM:
  773. case CM_USERSTORAGEITEM:
  774. case CM_USERBUYITEM:
  775. case CM_USERGETDETAILITEM:
  776. case CM_CREATEGROUP:
  777. case CM_ADDGROUPMEMBER:
  778. case CM_DELGROUPMEMBER:
  779. case CM_DEALTRY:
  780. case CM_DEALADDITEM:
  781. case CM_DEALDELITEM:
  782. case CM_USERTAKEBACKSTORAGEITEM:
  783. case CM_USERMAKEDRUGITEM:
  784. case CM_GUILDADDMEMBER:
  785. case CM_GUILDDELMEMBER:
  786. case CM_GUILDUPDATENOTICE:
  787. case CM_GUILDUPDATERANKINFO:
  788.          :
  789.             begin
  790.                hum.SendMsg (hum, pmsg.Ident, pmsg.Series, pmsg.Recog, pmsg.Param, pmsg.Tag, DecodeString(body));
  791.             end;
  792. case CM_ADJUST_BONUS:
  793.          :
  794.             begin
  795.                hum.SendMsg (hum, pmsg.Ident, pmsg.Series, pmsg.Recog, pmsg.Param, pmsg.Tag, body);
  796.             end;
  797.          else
  798.             hum.SendMsg (hum, pmsg.Ident, pmsg.Series, pmsg.Recog, pmsg.Param, pmsg.Tag, '');
  799.       end;
  800. }
  801. /*
  802. char szEncodeMsg[256];
  804. switch (lpDefMsg->wIdent)
  805. {
  806. case CM_TURN:
  807. {
  808. if (pUserInfo->m_pxPlayerObject->TurnXY(lpDefMsg->wTag, LOWORD(lpDefMsg->nRecog), HIWORD(lpDefMsg->nRecog)))
  809. memmove(szEncodeMsg, _MSG_GOOD, sizeof(_MSG_GOOD));
  810. else
  811. memmove(szEncodeMsg, _MSG_FAIL, sizeof(_MSG_FAIL));
  813. ValToAnsiStr(GetTickCount(), &szEncodeMsg[sizeof(_MSG_GOOD) - 1]);
  814. pUserInfo->m_pxPlayerObject->SendSocket(NULL, szEncodeMsg);
  815. break;
  816. }
  817. case CM_WALK:
  818. {
  819. if (pUserInfo->m_pxPlayerObject->WalkTo(lpDefMsg->wTag))
  820. memmove(szEncodeMsg, _MSG_GOOD, sizeof(_MSG_GOOD));
  821. else
  822. memmove(szEncodeMsg, _MSG_FAIL, sizeof(_MSG_FAIL));
  824. ValToAnsiStr(GetTickCount(), &szEncodeMsg[sizeof(_MSG_GOOD) - 1]);
  825. pUserInfo->m_pxPlayerObject->SendSocket(NULL, szEncodeMsg);
  826. break;
  827. }
  828. case CM_RUN:
  829. {
  830. if (pUserInfo->m_pxPlayerObject->RunTo(lpDefMsg->wTag))
  831. memmove(szEncodeMsg, _MSG_GOOD, sizeof(_MSG_GOOD));
  832. else
  833. memmove(szEncodeMsg, _MSG_FAIL, sizeof(_MSG_FAIL));
  835. ValToAnsiStr(GetTickCount(), &szEncodeMsg[sizeof(_MSG_GOOD) - 1]);
  836. pUserInfo->m_pxPlayerObject->SendSocket(NULL, szEncodeMsg);
  837. break;
  838. }
  839. /* case CM_HIT:
  840. {
  841. if (HitXY(lpProcessMsg->wIdent, lpProcessMsg->lParam1, lpProcessMsg->lParam2, lpProcessMsg->wParam))
  842. memmove(szEncodeMsg, _MSG_GOOD, sizeof(_MSG_GOOD));
  843. else
  844. memmove(szEncodeMsg, _MSG_FAIL, sizeof(_MSG_FAIL));
  846. ValToAnsiStr(GetTickCount(), &szEncodeMsg[sizeof(_MSG_GOOD) - 1]);
  847. SendSocket(NULL, szEncodeMsg);
  848. break;
  849. }
  850. case CM_RIDE:
  851. {
  852. if (DoRideHorse(lpProcessMsg->wParam, lpProcessMsg->lParam1))
  853. memmove(szEncodeMsg, _MSG_GOOD, sizeof(_MSG_GOOD));
  854. else
  855. memmove(szEncodeMsg, _MSG_FAIL, sizeof(_MSG_FAIL));
  857. ValToAnsiStr(GetTickCount(), &szEncodeMsg[sizeof(_MSG_GOOD) - 1]);
  858. SendSocket(NULL, szEncodeMsg);
  860. break;
  861. }
  862. case CM_SAY:
  863. {
  864. if (lpProcessMsg->pszData)
  865. ProcessForUserSaid(lpProcessMsg);
  866. break;
  867. }
  868. case CM_SPELL:
  869. {
  870. if (SpellXY(lpProcessMsg->wParam, lpProcessMsg->lParam1, lpProcessMsg->lParam2, lpProcessMsg->lParam3))
  871. memmove(szEncodeMsg, _MSG_GOOD, sizeof(_MSG_GOOD));
  872. else
  873. memmove(szEncodeMsg, _MSG_FAIL, sizeof(_MSG_FAIL));
  875. ValToAnsiStr(GetTickCount(), &szEncodeMsg[sizeof(_MSG_GOOD) - 1]);
  876. SendSocket(NULL, szEncodeMsg);
  878. break;
  879. }
  880. case CM_TAKEONITEM:
  881. {
  882. lpProcessMsg->pCharObject->m_tFeature.btGender = lpProcessMsg->wParam;
  883. lpProcessMsg->pCharObject->m_tFeature.btWear = HIBYTE(lpProcessMsg->lParam1);
  884. lpProcessMsg->pCharObject->m_tFeature.btHair = LOBYTE(lpProcessMsg->lParam1);
  885. lpProcessMsg->pCharObject->m_tFeature.btWeapon = lpProcessMsg->lParam2;
  887. //AddRefMsg(
  888. break;
  889. }
  890. } */
  891. }
  893. void CUserInfo::Operate()
  894. {
  895. if (GetTickCount() - m_pxPlayerObject->m_dwSearchTime >= m_pxPlayerObject->m_dwSearchTick)
  896. {
  897. m_pxPlayerObject->m_dwSearchTime = GetTickCount();
  898. m_pxPlayerObject->SearchViewRange();
  900. if (m_pxPlayerObject->m_btBright != g_nMirDayTime)
  901. {
  902. m_pxPlayerObject->m_btBright = g_nMirDayTime;
  903. m_pxPlayerObject->AddProcess(m_pxPlayerObject, RM_DAYCHANGING, 0, 0, 0, 0, NULL);
  904. }
  905. }
  907. m_pxPlayerObject->Operate();
  908. }
  910. void CUserInfo::CloseUserHuman()
  911. {
  912. Lock();
  914. if (m_pxPlayerObject)
  915. {
  916. m_THumanRcd.nCX = m_pxPlayerObject->m_nCurrX;
  917. m_THumanRcd.nCY = m_pxPlayerObject->m_nCurrY;
  919. if (m_pxPlayerObject->m_nDirection >= 0 && m_pxPlayerObject->m_nDirection <= 7)
  920. m_THumanRcd.nDirection = m_pxPlayerObject->m_nDirection;
  921. else
  922. m_THumanRcd.nDirection = 4;
  924. if (m_pxPlayerObject->m_pMap)
  925. {
  926. ZeroMemory(m_THumanRcd.szMapName, sizeof(m_THumanRcd.szMapName));
  927. memcpy(m_THumanRcd.szMapName, m_pxPlayerObject->m_pMap->m_szMapName, memlen(m_pxPlayerObject->m_pMap->m_szMapName));
  928. }
  930. m_THumanRcd.szLevel = m_pxPlayerObject->m_Ability.Level;
  931. m_THumanRcd.nExp = m_pxPlayerObject->m_Ability.Exp;
  932. m_THumanRcd.nExp = m_pxPlayerObject->m_Ability.Exp;
  934. // Save Player Information Data
  935. SaveHumanToDB("192.168.0.200");
  936. }
  938. if (m_pxPlayerObject)
  939. {   
  940. PLISTNODE pVisibleObjListNode = m_pxPlayerObject->m_xVisibleObjectList.GetHead();
  942. while (pVisibleObjListNode)
  943. {
  944. CVisibleObject* pVisibleObject = m_pxPlayerObject->m_xVisibleObjectList.GetData(pVisibleObjListNode);
  946. if (pVisibleObject) 
  947. {
  948. delete pVisibleObject;
  949. pVisibleObject = NULL;
  950. }
  952. pVisibleObjListNode = m_pxPlayerObject->m_xVisibleObjectList.RemoveNode(pVisibleObjListNode);
  953. }
  955. m_pxPlayerObject->m_pMap->RemoveObject(m_pxPlayerObject->m_nCurrX,m_pxPlayerObject->m_nCurrY,
  956. OS_MOVINGOBJECT, m_pxPlayerObject);
  958. m_pxPlayerObject->m_fIsAlive = FALSE;
  959. }
  961. PLISTNODE pListNode;
  963. // Remove User Item
  964. if (m_lpTItemRcd.GetCount())
  965. {
  966. pListNode = m_lpTItemRcd.GetHead();
  968. while (pListNode)
  969. {
  970. _LPTUSERITEMRCD lpUserItemRcd = m_lpTItemRcd.GetData(pListNode);
  972. if (lpUserItemRcd) 
  973. {
  974. delete lpUserItemRcd;
  975. lpUserItemRcd = NULL;
  976. }
  978. pListNode = m_lpTItemRcd.RemoveNode(pListNode);
  979. }
  980. }
  982. // Remove General User Item
  983. if (m_lpTGenItemRcd.GetCount())
  984. {
  985. pListNode = m_lpTGenItemRcd.GetHead();
  987. while (pListNode)
  988. {
  989. _LPTGENERALITEMRCD lpGenItemRcd = m_lpTGenItemRcd.GetData(pListNode);
  991. if (lpGenItemRcd) 
  992. {
  993. delete lpGenItemRcd;
  994. lpGenItemRcd = NULL;
  995. }
  997. pListNode = m_lpTGenItemRcd.RemoveNode(pListNode);
  998. }
  999. }
  1001. // Remove User Magic Information
  1002. if (m_lpTMagicRcd.GetCount())
  1003. {
  1004. pListNode = m_lpTMagicRcd.GetHead();
  1006. while (pListNode)
  1007. {
  1008. _LPTHUMANMAGICRCD lpMagicRcd = m_lpTMagicRcd.GetData(pListNode);
  1010. if (lpMagicRcd) 
  1011. {
  1012. delete lpMagicRcd;
  1013. lpMagicRcd = NULL;
  1014. }
  1016. pListNode = m_lpTMagicRcd.RemoveNode(pListNode);
  1017. }
  1018. }
  1020. if (m_pxPlayerObject)
  1021. CloseAccount(m_szUserID, m_nCertification);
  1023. m_bEmpty = true;
  1024. Unlock();
  1026. UpdateStatusBarUsers(FALSE);
  1027. }
  1029. void CUserInfo::SaveHumanToDB(char *pszUserAddr)
  1030. {
  1031. _TDEFAULTMESSAGE Def;
  1032. _TLOADHUMAN tLoadHuman;
  1033. char szEncodeMsg1[24];
  1034. char szEncodeMsg2[8192];
  1036. fnMakeDefMessage(&Def, DB_SAVEHUMANRCD, (int)this, m_lpTMagicRcd.GetCount(), m_lpTGenItemRcd.GetCount(), 0);
  1038. memcpy(tLoadHuman.szUserID, m_szUserID, memlen(m_szUserID));
  1039. memcpy(tLoadHuman.szCharName, m_szCharName, memlen(m_szCharName));
  1040. memcpy(tLoadHuman.szUserAddr, pszUserAddr, memlen(pszUserAddr));
  1041. tLoadHuman.nCertification = m_nCertification;
  1043. int nPos = fnEncodeMessageA(&Def, szEncodeMsg1, sizeof(szEncodeMsg1));
  1044. szEncodeMsg1[nPos] = '';
  1045. nPos = fnEncode6BitBufA((unsigned char *)&tLoadHuman, szEncodeMsg2, sizeof(_TLOADHUMAN), sizeof(szEncodeMsg2));
  1046. nPos += fnEncode6BitBufA((unsigned char *)&m_THumanRcd, &szEncodeMsg2[nPos], sizeof(_THUMANRCD), sizeof(szEncodeMsg2) - nPos);
  1048. // BEGIN:Add Magic Information
  1049. EncodeMyMagicToServer(szEncodeMsg2, sizeof(szEncodeMsg2) - nPos, nPos);
  1050. // END
  1052. // BEGIN:Add General Item Information
  1053. EncodeGenItem(szEncodeMsg2, sizeof(szEncodeMsg2) - nPos, nPos);
  1054. // END
  1056. szEncodeMsg2[nPos] = '';
  1058. SendRDBSocket(tLoadHuman.nCertification, szEncodeMsg1, szEncodeMsg2, nPos);
  1059. }
  1061. void CUserInfo::CloseAccount(char *pszName, int nCertification)
  1062. {
  1063. char szMsg[256];
  1064. int nLen = memlen(pszName) - 1;
  1066. szMsg[0] = '%';
  1067. szMsg[1] = 'S';
  1069. memcpy(&szMsg[2], pszName, nLen);
  1071. szMsg[nLen + 2] = '/';
  1073. char *pszPos = ValToAnsiStr(nCertification, &szMsg[nLen + 3]);
  1075. *pszPos++ = '$';
  1076. *pszPos = '';
  1078. send(g_clsock, szMsg, memlen(szMsg) - 1, 0);
  1079. }
  1081. void CUserInfo::DoClientCertification(char *pszPacket)
  1082. {
  1083. char szDecodePacket[64];
  1084. char *pszDecodePacket = &szDecodePacket[0];
  1085. char *pszPos;
  1087. if (m_btCurrentMode == USERMODE_NOTICE)
  1088. {
  1089. int nLen = memlen(pszPacket);
  1091. if (pszPos = (char *)memchr(pszPacket, '!', nLen))
  1092. {
  1093. *pszPos = '';
  1095. //             uid  chr  cer  ver  startnew
  1096. // pszPacket **SSSS/SSSS/SSSS/SSSS/1
  1097. nLen = fnDecode6BitBufA(pszPacket + 2, szDecodePacket, sizeof(szDecodePacket));
  1098. szDecodePacket[nLen] = '';
  1100. if (*pszDecodePacket == '*' && *(pszDecodePacket + 1) == '*')
  1101. {
  1102. pszDecodePacket += 2;
  1104. if (!(pszPos = (char *)memchr(pszDecodePacket, '/', nLen))) return;
  1106. *pszPos++ = '';
  1107. nLen -= (pszPos - pszDecodePacket);
  1108. memmove(m_szUserID, pszDecodePacket, (pszPos - pszDecodePacket));
  1109. pszDecodePacket = pszPos;
  1111. if (!(pszPos = (char *)memchr(pszDecodePacket, '/', nLen))) return;
  1113. *pszPos++ = '';
  1114. nLen -= (pszPos - pszDecodePacket);
  1115. memmove(m_szCharName, pszDecodePacket, (pszPos - pszDecodePacket));
  1116. pszDecodePacket = pszPos;
  1118. if (!(pszPos = (char *)memchr(pszDecodePacket, '/', nLen))) return;
  1120. *pszPos++ = '';
  1121. nLen -= (pszPos - pszDecodePacket);
  1122. m_nCertification = AnsiStrToVal(pszDecodePacket);
  1123. pszDecodePacket = pszPos;
  1125. if (!(pszPos = (char *)memchr(pszDecodePacket, '/', nLen))) return;
  1127. *pszPos++ = '';
  1128. nLen -= (pszPos - pszDecodePacket);
  1129. m_nClientVersion = AnsiStrToVal(pszDecodePacket);
  1130. pszDecodePacket = pszPos;
  1132. m_btCurrentMode = USERMODE_LOGIN;
  1133. // (*pszDecodePacket == '0' ? StartNew = TRUE : StartNew = FALSE);
  1135. // INSERT:Check pay bill.
  1137. // if (pUserInfo->m_nCertification >= 30)
  1138. // {
  1140. // LoadPlayer(pUserInfo);
  1141. // }
  1142. /* else
  1143. {
  1144. // INSERT:Close User
  1145. } */
  1146. }
  1147. }
  1148. }
  1149. }