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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 模拟服务器 > 查看源码
FriendMgr.cpp
资源名称：SwordOnline.rar　[点击查看]
上传用户：dzyhzl
上传日期：2019-04-29
资源大小：56270k
文件大小：31k
源码类别：

模拟服务器

开发平台：

C/C++

FriendMgr.cpp：源码内容
  1. // FriendMgr.cpp: implementation of the CFriendMgr class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "global.h"
  7. #include "FriendMgr.h"
  8. #include "assert.h"
  9. #include "malloc.h"
  10. #include "S3Relay.h"
  12. #include <list>
  13. #include <map>
  16. //////////////////////////////////////////////////////////////////////
  18. #define STR_NULL _T("")
  20. //////////////////////////////////////////////////////////////////////
  23. //////////////////////////////////////////////////////////////////////
  26. static char file_friendcfg[] = "relay_friendcfg.ini";
  28. const char sec_database[] = "database";
  29. const char key_path[] = "path";
  30. const char key_file[] = "file";
  31. const char key_updateinterval[] = "updateinterval";
  32. const char key_storeplayerperudtdb[] = "storeplayerperudtdb";
  33. const char key_loadplayerperudtdb[] = "loadplayerperudtdb";
  36. //////////////////////////////////////////////////////////////////////
  38. static std::_tstring s_dbpath = gGetPrivateProfileStringEx(sec_database, key_path, file_friendcfg);
  39. static std::_tstring s_dbfile = gGetPrivateProfileStringEx(sec_database, key_file, file_friendcfg);
  41. //////////////////////////////////////////////////////////////////////
  42. // Construction/Destruction
  43. //////////////////////////////////////////////////////////////////////
  45. CFriendMgr::CFriendMgr()
  46. : m_elapseUpdateDB(0), m_tickLast(0),
  47. m_StorePlayerPerUdtDB(0), m_LoadPlayerPerUdtDB(0), 
  48. m_dbFriend(s_dbpath.c_str(), s_dbfile.c_str()),
  49. m_dbFriendRO(s_dbpath.c_str(), s_dbfile.c_str()),
  50. m_cursorBkgrndUdtDB(0)
  51. {
  53. }
  55. CFriendMgr::~CFriendMgr()
  56. {
  58. }
  61. BOOL CFriendMgr::Initialize()
  62. {
  63. //open DB
  64. {{
  65. AUTOLOCKWRITE(m_lockDB);
  67. if (!m_dbFriend.open() || !m_dbFriendRO.open())
  68. return FALSE;
  69. }}
  71. {{
  72. AUTOLOCKWRITE(m_lockFriend);
  74. m_mapPlayers.clear();
  75. }}
  78. m_cursorBkgrndUdtDB = 0;
  80. m_StorePlayerPerUdtDB = (size_t)gGetPrivateProfileIntEx(sec_database, key_storeplayerperudtdb, file_friendcfg, 0);
  81. m_LoadPlayerPerUdtDB = (size_t)gGetPrivateProfileIntEx(sec_database, key_loadplayerperudtdb, file_friendcfg, 0);
  83. m_elapseUpdateDB = (UINT)gGetPrivateProfileIntEx(sec_database, key_updateinterval, file_friendcfg, 0);
  84. if (m_elapseUpdateDB > 0)
  85. {
  86. if (!gStartFriendTimingUpdateDB(m_elapseUpdateDB))
  87. return FALSE;
  88. }
  91. return TRUE;
  92. }
  94. BOOL CFriendMgr::Uninitialize()
  95. {
  96. if (m_elapseUpdateDB > 0)
  97. gStopFriendTimingUpdateDB();
  99. //update DB
  100. {{
  101. AUTOLOCKWRITE(m_lockFriend);
  103. for (PLAYERSMAP::iterator itPlayer = m_mapPlayers.begin(); itPlayer != m_mapPlayers.end(); itPlayer++)
  104. {
  105. std::_tstring someone((*itPlayer).first);
  106. PLAYERINFO& rPlayerInfo = (*itPlayer).second;
  108. if (!rPlayerInfo.loaded)
  109. {
  110. PLAYERSMAP::iterator itLoadPlayer = _LoadSomeone(someone);
  111. assert(itLoadPlayer == itPlayer);
  112. }
  114. _StoreSomeone(itPlayer);
  115. }
  117. m_mapPlayers.clear();
  118. }}
  120. m_cursorBkgrndUdtDB = 0;
  123. //close DB
  124. {{
  125. AUTOLOCKWRITE(m_lockDB);
  127. m_dbFriendRO.close();
  128. m_dbFriend.close();
  129. }}
  131. return TRUE;
  132. }
  135. BOOL CFriendMgr::SomeoneLogin(const std::string& role)
  136. {
  137. //use for notify online friends
  138. typedef std::list<tagPlusSrcInfo> PLAYERLIST;
  139. typedef std::map<DWORD, PLAYERLIST> IP2PLAYERSMAP;
  140. IP2PLAYERSMAP mapIp2Players;
  143. {{
  144. AUTOLOCKWRITE(m_lockFriend);
  146. PLAYERSMAP::iterator itPlayer = _LoadSomeone(role);
  147. if (itPlayer == m_mapPlayers.end())
  148. return FALSE;
  150. PLAYERINFO& rPlayerInfo = (*itPlayer).second;
  151. assert(rPlayerInfo.loaded);
  155. for (FRIENDSMAP::iterator itFriend = rPlayerInfo.friends.begin(); itFriend != rPlayerInfo.friends.end(); itFriend++)
  156. {
  157. std::_tstring dst = (*itFriend).first;
  158. FRIENDINFO& rInfo = (*itFriend).second;
  160. assert(rInfo.pCheated);
  161. if (!rInfo.pCheated)
  162. continue;
  164. assert(!rInfo.cheating || !*rInfo.pCheated);
  165. if (rInfo.cheating && *rInfo.pCheated)
  166. continue;
  169. if (!*rInfo.pCheated)
  170. {//this friend is sincere for someone
  171. CNetConnectDup conndup2;
  172. DWORD nameid2 = 0;
  173. unsigned long param2 = 0;
  174. if (g_HostServer.FindPlayerByRole(NULL, dst, &conndup2, NULL, &nameid2, &param2))
  175. {//this friend is online
  176. tagPlusSrcInfo srcinfo;
  177. srcinfo.nameid = nameid2;
  178. srcinfo.lnID = param2;
  180. PLAYERLIST& rPlayers = mapIp2Players[conndup2.GetIP()];
  181. rPlayers.push_back(srcinfo);
  182. }
  183. }
  184. }
  186. }}
  190. if (!mapIp2Players.empty())
  191. {
  192. char buffer2[max_packagesize];
  193. size_t datasize2 = sizeof(FRIEND_STATE) + role.size() + 2;
  194. size_t basesize2 = sizeof(EXTEND_PASSTOBEVY) + datasize2;
  196. EXTEND_PASSTOBEVY* pEpb2 = (EXTEND_PASSTOBEVY*)buffer2;
  197. pEpb2->ProtocolFamily = pf_extend;
  198. pEpb2->ProtocolID = extend_s2c_passtobevy;
  199. pEpb2->datasize = datasize2;
  200. pEpb2->playercount = 0;
  202. FRIEND_STATE* pFs2 = (FRIEND_STATE*)(pEpb2 + 1);
  203. pFs2->ProtocolFamily = pf_friend;
  204. pFs2->ProtocolID = friend_s2c_friendstate;
  205. pFs2->state = stateOnline;
  207. char* pSrcRole2 = (char*)(pFs2 + 1);
  208. strcpy(pSrcRole2, role.c_str());
  209. pSrcRole2[role.size() + 1] = 0;
  211. tagPlusSrcInfo* pPlayer2 = (tagPlusSrcInfo*)(buffer2 + basesize2);
  214. for (IP2PLAYERSMAP::iterator itIP = mapIp2Players.begin(); itIP != mapIp2Players.end(); itIP++)
  215. {
  216. DWORD ip2 = (*itIP).first;
  217. PLAYERLIST& rPlayers = (*itIP).second;
  219. CNetConnectDup tongconndup2;
  220. tongconndup2 = g_TongServer.FindTongConnectByIP(ip2);
  221. if (!tongconndup2.IsValid())
  222. continue;
  225. size_t cursor2 = basesize2;
  227. for (PLAYERLIST::iterator itPlayer = rPlayers.begin(); itPlayer != rPlayers.end(); itPlayer++)
  228. {
  229. tagPlusSrcInfo& rSrcInfo = *itPlayer;
  232. if (cursor2 + sizeof(tagPlusSrcInfo) > max_packagesize)
  233. {
  234. tongconndup2.SendPackage(buffer2, cursor2);
  236. pEpb2->playercount = 0;
  237. cursor2 = basesize2;
  238. }
  240. pPlayer2[pEpb2->playercount ++] = rSrcInfo;
  241. cursor2 += sizeof(tagPlusSrcInfo);
  242. }
  244. if (cursor2 > basesize2)
  245. {
  246. assert(pEpb2->playercount > 0);
  247. tongconndup2.SendPackage(buffer2, cursor2);
  248. }
  249. }
  250. }
  253. return TRUE;
  254. }
  256. BOOL CFriendMgr::SomeoneLogout(const std::string& role)
  257. {
  258. AUTOLOCKWRITE(m_lockFriend);
  260. PLAYERSMAP::iterator itPlayer = m_mapPlayers.find(role);
  261. if (itPlayer == m_mapPlayers.end())
  262. return FALSE;
  265. PLAYERINFO& rPlayerInfo = (*itPlayer).second;
  266. assert(rPlayerInfo.loaded);
  269. size_t datasize2 = sizeof(FRIEND_STATE) + role.size() + 2;
  270. size_t pckgsize2 = sizeof(EXTEND_PASSTOSOMEONE) + datasize2;
  272. EXTEND_PASSTOSOMEONE* pEps2 = (EXTEND_PASSTOSOMEONE*)_alloca(pckgsize2);
  273. pEps2->ProtocolFamily = pf_extend;
  274. pEps2->ProtocolID = extend_s2c_passtosomeone;
  275. pEps2->datasize = datasize2;
  277. FRIEND_STATE* pFs2 = (FRIEND_STATE*)(pEps2 + 1);
  278. pFs2->ProtocolFamily = pf_friend;
  279. pFs2->ProtocolID = friend_s2c_friendstate;
  280. pFs2->state = stateOffline;
  282. char* pSrcRole2 = (char*)(pFs2 + 1);
  283. strcpy(pSrcRole2, role.c_str());
  284. pSrcRole2[role.size() + 1] = 0;
  287. for (FRIENDSMAP::iterator itFriend = rPlayerInfo.friends.begin(); itFriend != rPlayerInfo.friends.end(); itFriend++)
  288. {
  289. std::_tstring dst = (*itFriend).first;
  290. FRIENDINFO& rInfo = (*itFriend).second;
  292. assert(rInfo.pCheated);
  293. if (!rInfo.pCheated)
  294. continue;
  296. assert(!rInfo.cheating || !*rInfo.pCheated);
  297. if (rInfo.cheating && *rInfo.pCheated)
  298. continue;
  300. if (!*rInfo.pCheated)
  301. {//notify
  302. CNetConnectDup conndup2;
  303. DWORD nameid2 = 0;
  304. unsigned long param2 = -1;
  305. if (g_HostServer.FindPlayerByRole(NULL, dst, &conndup2, NULL, &nameid2, &param2))
  306. {//this friend is online
  307. CNetConnectDup tongconndup2 = g_TongServer.FindTongConnectByIP(conndup2.GetIP());
  308. if (tongconndup2.IsValid())
  309. {
  310. pEps2->nameid = nameid2;
  311. pEps2->lnID = param2;
  313. tongconndup2.SendPackage(pEps2, pckgsize2);
  314. }
  315. }
  316. }
  317. }
  320. //不能并发写，因此这里不写DB
  321. //_StoreSomeone(itPlayer);
  324. return TRUE;
  325. }
  328. BOOL CFriendMgr::SomeoneSyncFriends(const std::string& role, unsigned long param, DWORD nameid, const CNetConnectDup& conndup, BOOL full, BYTE pckgid)
  329. {
  330. typedef std::pair<BYTE, std::_tstring> THEFRIEND; //first: state, second: name
  331. typedef std::list<THEFRIEND> FRIENDLIST;
  332. typedef std::map<std::_tstring, FRIENDLIST, _tstring_less> GRP2FRIENDSMAP;
  334. GRP2FRIENDSMAP mapGrp2Friends;
  336. {{
  337. AUTOLOCKREAD(m_lockFriend);
  339. PLAYERSMAP::iterator itPlayer = m_mapPlayers.find(role);
  340. if (itPlayer == m_mapPlayers.end())
  341. return FALSE;
  343. PLAYERINFO& rPlayerInfo = (*itPlayer).second;
  344. assert(rPlayerInfo.loaded);
  345. if (!rPlayerInfo.loaded)
  346. return FALSE;
  349. for (FRIENDSMAP::iterator itFriend = rPlayerInfo.friends.begin(); itFriend != rPlayerInfo.friends.end(); itFriend++)
  350. {
  351. std::_tstring dst = (*itFriend).first;
  352. FRIENDINFO& rInfo = (*itFriend).second;
  354. assert(rInfo.pCheated);
  355. if (!rInfo.pCheated)
  356. continue;
  358. assert(!rInfo.cheating || !*rInfo.pCheated);
  359. if (rInfo.cheating && *rInfo.pCheated)
  360. continue;
  362. if (!rInfo.cheating)
  363. {
  364. BOOL online = g_HostServer.FindPlayerByRole(NULL, dst, NULL, NULL, NULL, NULL);
  366. if (!online && !full)
  367. continue;
  369. FRIENDLIST& rFriends = mapGrp2Friends[rInfo.group];
  370. rFriends.push_back(THEFRIEND(online ? stateOnline : stateOffline, dst));
  371. }
  372. }
  373. }}
  376. if (!mapGrp2Friends.empty())
  377. {
  378. char buffer[max_packagesize];
  379. size_t basesize = sizeof(EXTEND_PASSTOSOMEONE) + sizeof(REP_SYNCFRIENDLIST);
  381. EXTEND_PASSTOSOMEONE* pEps = (EXTEND_PASSTOSOMEONE*)buffer;
  382. pEps->ProtocolFamily = pf_extend;
  383. pEps->ProtocolID = extend_s2c_passtosomeone;
  384. pEps->nameid = nameid;
  385. pEps->lnID = param;
  387. REP_SYNCFRIENDLIST* pRsfl = (REP_SYNCFRIENDLIST*)(pEps + 1);
  388. pRsfl->ProtocolFamily = pf_friend;
  389. pRsfl->ProtocolID = friend_s2c_repsyncfriendlist;
  390. pRsfl->pckgid = pckgid;
  393. for (GRP2FRIENDSMAP::iterator itGrp = mapGrp2Friends.begin(); itGrp != mapGrp2Friends.end(); itGrp++)
  394. {
  395. size_t basecursor = basesize;
  397. std::_tstring grp = (*itGrp).first;
  398. FRIENDLIST& rFriends = (*itGrp).second;
  400. buffer[basecursor++] = specGroup;
  401. strcpy(buffer + basecursor, grp.c_str());
  402. basecursor += grp.size() + 1;
  405. size_t cursor = basecursor;
  407. for (FRIENDLIST::iterator itFriend = rFriends.begin(); itFriend != rFriends.end(); itFriend++)
  408. {
  409. THEFRIEND theFriend = *itFriend;
  411. // spec state name 0
  412. size_t appendsize = 1 + 1 + theFriend.second.size() + 1;
  414. // item specOver
  415. if (cursor + appendsize + 1 >  max_packagesize)
  416. {
  417. buffer[cursor++] = specOver;
  418. pEps->datasize = cursor - sizeof(EXTEND_PASSTOSOMEONE);
  420. conndup.SendPackage(buffer, cursor);
  422. cursor = basecursor;
  423. }
  425. buffer[cursor + 0] = specRole;
  426. buffer[cursor + 1] = theFriend.first;
  427. strcpy(buffer + cursor + 2, theFriend.second.c_str());
  428. cursor += appendsize;
  429. }
  431. if (cursor > basecursor)
  432. {
  433. buffer[cursor++] = specOver;
  434. pEps->datasize = cursor - sizeof(EXTEND_PASSTOSOMEONE);
  436. conndup.SendPackage(buffer, cursor);
  437. }
  438. }
  439. }
  441. rTRACE("sync friend list: %s (%s)", role.c_str(), full ? "full" : "part");
  444. return TRUE;
  445. }
  448. BOOL CFriendMgr::PlayerAddFriend(const std::_tstring& someone, const std::_tstring& dst)
  449. {
  450. if (_tstring_equal()(someone, dst))
  451. return FALSE;
  453. AUTOLOCKWRITE(m_lockFriend);
  455. PLAYERINFO& rSrcPlayerInfo = m_mapPlayers[someone];
  456. assert(rSrcPlayerInfo.loaded);
  457. FRIENDINFO& rSrcInfo = rSrcPlayerInfo.friends[dst];
  458. rSrcInfo.cheating = false;
  460. PLAYERINFO& rDstPlayerInfo = m_mapPlayers[dst];
  461. FRIENDINFO& rDstInfo = rDstPlayerInfo.friends[someone];
  462. rDstInfo.cheating = false;
  464. //binding
  465. rSrcInfo.pCheated = &rDstInfo.cheating;
  466. rDstInfo.pCheated = &rSrcInfo.cheating;
  469. rTRACE("Player Add Friend: %s [%s]", someone.c_str(), dst.c_str());
  471. return TRUE;
  472. }
  474. BOOL CFriendMgr::PlayerDelFriend(const std::_tstring& someone, const std::_tstring& dst)
  475. {
  476. AUTOLOCKWRITE(m_lockFriend);
  478. PLAYERSMAP::iterator itSrcPlayer = m_mapPlayers.find(someone);
  479. if (itSrcPlayer == m_mapPlayers.end())
  480. return FALSE;
  482. PLAYERINFO& rSrcPlayerInfo = (*itSrcPlayer).second;
  484. assert(rSrcPlayerInfo.loaded);
  485. if (!rSrcPlayerInfo.loaded)
  486. return FALSE;
  488. FRIENDSMAP::iterator itSrcFriend = rSrcPlayerInfo.friends.find(dst);
  489. if (itSrcFriend == rSrcPlayerInfo.friends.end())
  490. return FALSE;
  492. FRIENDINFO& rSrcInfo = (*itSrcFriend).second;
  494. assert(rSrcInfo.pCheated);
  495. if (!rSrcInfo.pCheated)
  496. return FALSE;
  498. //assert(!rSrcInfo.cheating || !*rSrcInfo.pCheated);
  499. //if (rSrcInfo.cheating && *rSrcInfo.pCheated)
  500. // return FALSE;
  502. rSrcInfo.cheating = true;
  503. if (!*rSrcInfo.pCheated)
  504. return TRUE;
  506. //erase...
  507. //dst
  508. PLAYERSMAP::iterator itDstPlayer = m_mapPlayers.find(dst);
  509. if (itDstPlayer != m_mapPlayers.end())
  510. {
  511. PLAYERINFO& rDstPlayerInfo = (*itDstPlayer).second;
  512. if (rDstPlayerInfo.loaded)
  513. rDstPlayerInfo.friends.erase(someone);
  514. else
  515. {
  516. FRIENDSMAP::iterator itDstFriend = rDstPlayerInfo.friends.find(someone);
  517. if (itDstFriend != rDstPlayerInfo.friends.end())
  518. {
  519. FRIENDINFO& rDstInfo = (*itDstFriend).second;
  520. rDstInfo.pCheated = NULL;
  521. }
  522. }
  523. }
  525. //src
  526. rSrcPlayerInfo.friends.erase(itSrcFriend);
  529. rTRACE("Player Del Friend: %s [%s]", someone.c_str(), dst.c_str());
  531. return TRUE;
  532. }
  534. BOOL CFriendMgr::PlayerIsFriend(const std::_tstring& someone, const std::_tstring& dst, BOOL rev)
  535. {
  536. AUTOLOCKREAD(m_lockFriend);
  538. PLAYERSMAP::iterator itPlayer = m_mapPlayers.find(someone);
  539. if (itPlayer == m_mapPlayers.end())
  540. return FALSE;
  542. PLAYERINFO& rPlayerInfo = (*itPlayer).second;
  543. FRIENDSMAP::iterator itFriend = rPlayerInfo.friends.find(dst);
  544. if (itFriend == rPlayerInfo.friends.end())
  545. return FALSE;
  547. FRIENDINFO& rInfo = (*itFriend).second;
  548. if (!rInfo.pCheated)
  549. return FALSE;
  551. return !(rev ? *rInfo.pCheated : rInfo.cheating);
  552. }
  555. BOOL CFriendMgr::SetFriendGroup(const std::_tstring& someone, const std::_tstring& dst, const std::_tstring& group)
  556. {
  557. AUTOLOCKWRITE(m_lockFriend);
  559. PLAYERSMAP::iterator itPlayer = m_mapPlayers.find(someone);
  560. if (itPlayer == m_mapPlayers.end())
  561. return FALSE;
  563. PLAYERINFO& rPlayerInfo = (*itPlayer).second;
  564. FRIENDSMAP::iterator itFriend = rPlayerInfo.friends.find(dst);
  565. if (itFriend == rPlayerInfo.friends.end())
  566. return FALSE;
  568. FRIENDINFO& rInfo = (*itFriend).second;
  569. assert(rInfo.pCheated);
  570. if (rInfo.pCheated == NULL)
  571. return FALSE;
  573. assert(!rInfo.cheating || !*rInfo.pCheated);
  574. if (rInfo.cheating && *rInfo.pCheated)
  575. return FALSE;
  577. rInfo.group = group;
  579. rTRACE("Player Group Friend: %s [%s] (%s)", someone.c_str(), dst.c_str(), group.c_str());
  581. return TRUE;
  582. }
  584. std::_tstring CFriendMgr::GetFriendGroup(const std::_tstring& someone, const std::_tstring& dst)
  585. {
  586. AUTOLOCKREAD(m_lockFriend);
  588. PLAYERSMAP::iterator itPlayer = m_mapPlayers.find(someone);
  589. if (itPlayer == m_mapPlayers.end())
  590. return STR_NULL;
  592. PLAYERINFO& rPlayerInfo = (*itPlayer).second;
  593. FRIENDSMAP::iterator itFriend = rPlayerInfo.friends.find(dst);
  594. if (itFriend == rPlayerInfo.friends.end())
  595. return STR_NULL;
  597. FRIENDINFO& rInfo = (*itFriend).second;
  598. assert(rInfo.pCheated);
  599. if (!rInfo.pCheated)
  600. return STR_NULL;
  601. assert(!rInfo.cheating || !*rInfo.pCheated);
  602. if (rInfo.cheating && *rInfo.pCheated)
  603. return STR_NULL;
  605. return rInfo.group;
  606. }
  609. BOOL CFriendMgr::TrackAddFriend(const std::_tstring& src, const std::_tstring& dst, BYTE id)
  610. {
  611. AUTOLOCKWRITE(m_lockAddFriend);
  613. ADDFRIENDVALUE& rValue = m_mapAddFriends[ADDFRIENDKEY(id, src)];
  614. rValue.dst = dst;
  615. rValue.tick = ::GetTickCount();
  617. return TRUE;
  618. }
  620. BOOL CFriendMgr::ExtractAddFriend(const std::_tstring& src, const std::_tstring& dst, BYTE id)
  621. {
  622. AUTOLOCKWRITE(m_lockAddFriend);
  624. ADDFRIENDMAP::iterator it = m_mapAddFriends.find(ADDFRIENDKEY(id, src));
  625. if (it == m_mapAddFriends.end())
  626. return FALSE;
  628. ADDFRIENDVALUE& rValue = (*it).second;
  629. if (!_tstring_equal()(rValue.dst, dst))
  630. return FALSE;
  632. m_mapAddFriends.erase(it);
  634. return TRUE;
  635. }
  637. BOOL CFriendMgr::TidyAddFriend()
  638. {
  639. return TRUE;
  641. /*
  642. DWORD tick = ::GetTickCount();
  643. if (tick < m_tickLast + TIMEOUT_ADDFRIEND)
  644. return TRUE;
  647. AUTOLOCKWRITE(m_lockAddFriend);
  649. ADDFRIENDMAP::iterator it = m_mapAddFriends.begin();
  650. while (it != m_mapAddFriends.end())
  651. {
  652. ADDFRIENDMAP::iterator itMe = it++;
  654. ADDFRIENDVALUE& rValue = (*itMe).second;
  655. if (tick < rValue.tick + TIMEOUT_ADDFRIEND)
  656. continue;
  658. m_mapAddFriends.erase(itMe);
  659. }
  661. return TRUE;
  662. */
  663. }
  667. CFriendMgr::PLAYERSMAP::iterator CFriendMgr::_LoadSomeone(const std::_tstring& someone)
  668. {
  669. //assert(m_lockFriend._IsWriting());
  671. std::pair<PLAYERSMAP::iterator, bool> insret = m_mapPlayers.insert(PLAYERSMAP::value_type(someone, PLAYERINFO()));
  673. PLAYERINFO& rPlayerInfo = (*insret.first).second;
  674. if (!insret.second) //not insert someone
  675. {
  676. if (rPlayerInfo.loaded)
  677. return insret.first; //already loaded
  678. }
  680. rTRACE("load someone: %s", someone.c_str());
  682. //load from DB
  683. MEM_FRIENDRECORDLIST memFriends;
  684. if (!DB_LoadSomeone(someone, &memFriends))
  685. {
  686. rTRACE("except: load someone fail: %s", someone.c_str());
  687. return m_mapPlayers.end();
  688. }
  690. //update
  691. for (MEM_FRIENDRECORDLIST::iterator itMemFriend = memFriends.begin(); itMemFriend != memFriends.end(); itMemFriend++)
  692. {
  693. MEM_FRIENDRECORD& rmemFriendRec = *itMemFriend;
  695. std::pair<FRIENDSMAP::iterator, bool> insretfriend = rPlayerInfo.friends.insert(FRIENDSMAP::value_type(rmemFriendRec.name, FRIENDINFO()));
  696. FRIENDINFO& rInfo = (*insretfriend.first).second;
  698. if (insretfriend.second) //insert this friend
  699. {
  700. rInfo.group = rmemFriendRec.group;
  701. rInfo.cheating = rmemFriendRec.cheating;
  702. rInfo.orig_cheating = rmemFriendRec.cheating ? FRIENDINFO::cheatTRUE : FRIENDINFO::cheatFALSE;
  703. rInfo.orig_cheated = rmemFriendRec.cheated ? FRIENDINFO::cheatTRUE : FRIENDINFO::cheatFALSE;
  706. PLAYERINFO& rPlayerInfo2 = m_mapPlayers[rmemFriendRec.name];
  707. FRIENDINFO& rInfo2 = rPlayerInfo2.friends[someone];
  708. rInfo2.cheating = rmemFriendRec.cheated;
  710. rInfo.pCheated = &rInfo2.cheating;
  711. rInfo2.pCheated = &rInfo.cheating;
  712. }
  713. else
  714. {
  715. if (rInfo.pCheated == NULL)
  716. {
  717. rPlayerInfo.friends.erase(insretfriend.first);
  719. rPlayerInfo.dirty = TRUE;
  721. continue;
  722. }
  724. rInfo.group = rmemFriendRec.group;
  725. rInfo.orig_cheating = rmemFriendRec.cheating ? FRIENDINFO::cheatTRUE : FRIENDINFO::cheatFALSE;
  726. rInfo.orig_cheated = rmemFriendRec.cheated ? FRIENDINFO::cheatTRUE : FRIENDINFO::cheatFALSE;
  727. }
  729. }
  731. //clearup invalid items
  732. FRIENDSMAP::iterator itFriend = rPlayerInfo.friends.begin();
  733. while (itFriend != rPlayerInfo.friends.end())
  734. {
  735. FRIENDSMAP::iterator itHere = itFriend++;
  737. FRIENDINFO& rInfo = (*itHere).second;
  738. if (rInfo.pCheated == NULL)
  739. {
  740. rPlayerInfo.friends.erase(itHere);
  742. rPlayerInfo.dirty = TRUE;
  743. }
  744. }
  747. rPlayerInfo.loaded = TRUE;
  750. return insret.first;
  751. }
  753. BOOL CFriendMgr::_StoreSomeone(PLAYERSMAP::iterator itSomeone)
  754. {
  755. //assert(m_lockFriend._IsRead());
  757. std::_tstring someone = (*itSomeone).first;
  758. PLAYERINFO& rPlayerInfo = (*itSomeone).second;
  760. assert(rPlayerInfo.loaded);
  761. if (!rPlayerInfo.loaded)
  762. {
  763. rTRACE("except: store someone outof mem: %s", someone.c_str());
  764. return FALSE;
  765. }
  768. rTRACE("store someone: %s", someone.c_str());
  771. BOOL needstore = rPlayerInfo.dirty;
  773. rPlayerInfo.dirty = FALSE;
  776. MEM_FRIENDRECORDLIST memFriends;
  778. for (FRIENDSMAP::iterator itFriend = rPlayerInfo.friends.begin(); itFriend != rPlayerInfo.friends.end(); itFriend++)
  779. {
  780. std::_tstring name = (*itFriend).first;
  781. FRIENDINFO& rInfo = (*itFriend).second;
  783. assert(rInfo.pCheated);
  784. if (!rInfo.pCheated)
  785. continue;
  786. assert(!rInfo.cheating || !*rInfo.pCheated);
  787. if (rInfo.cheating && *rInfo.pCheated)
  788. continue;
  790. MEM_FRIENDRECORD memFriendRec;
  791. memFriendRec.name = name;
  792. memFriendRec.group = rInfo.group;
  793. memFriendRec.cheating = rInfo.cheating;
  794. memFriendRec.cheated = *rInfo.pCheated;
  796. memFriends.push_back(memFriendRec);
  798. if (!needstore
  799. && ((rInfo.cheating ? FRIENDINFO::cheatTRUE : FRIENDINFO::cheatFALSE) != rInfo.orig_cheating
  800. || (*rInfo.pCheated ? FRIENDINFO::cheatTRUE : FRIENDINFO::cheatFALSE) != rInfo.orig_cheated))
  801. {
  802. needstore = TRUE;
  803. }
  805. rInfo.orig_cheating = rInfo.cheating ? FRIENDINFO::cheatTRUE : FRIENDINFO::cheatFALSE;
  806. rInfo.orig_cheated = *rInfo.pCheated ? FRIENDINFO::cheatTRUE : FRIENDINFO::cheatFALSE;
  807. }
  810. if (!needstore) //mem & db is sync
  811. return TRUE;
  813. //store this friend's info into DB
  814. if (!DB_StoreSomeone(someone, memFriends))
  815. {
  816. rPlayerInfo.dirty = TRUE;
  818. rTRACE("error: store someone: %s", someone.c_str());
  820. return FALSE;
  821. }
  823. return TRUE;
  824. }
  827. std::_tstring CFriendMgr::NameToDBKey(const std::_tstring& name)
  828. {
  829. return name;
  830. }
  833. BOOL CFriendMgr::DB_AddSomeone(const std::_tstring& someone, const MEM_FRIENDRECORDLIST& memFriends)
  834. {
  835. return DB_StoreSomeone(someone, memFriends);
  836. }
  838. BOOL CFriendMgr::DB_DeleteSomeone(const std::_tstring& someone)
  839. {
  840. std::_tstring dbkey = NameToDBKey(someone);
  842. AUTOLOCKWRITE(m_lockDB);
  843. m_dbFriend.remove(dbkey.data(), dbkey.size());
  845. return TRUE;
  846. }
  849. BOOL CFriendMgr::DB_LoadSomeone(const std::_tstring& someone, MEM_FRIENDRECORDLIST* pmemFriends)
  850. {
  851. assert(pmemFriends && pmemFriends->empty());
  853. std::_tstring dbkey = NameToDBKey(someone);
  855. int valsize = 0;
  856. char* pValue = m_dbFriendRO.search(dbkey.data(), dbkey.size(), valsize);
  857. if (!pValue)
  858. return TRUE;
  860. DB_FRIENDRECORDLIST* pdbFriendList = (DB_FRIENDRECORDLIST*)pValue;
  861. DB_FRIENDRECORD* pCursor = (DB_FRIENDRECORD*)(pdbFriendList + 1);
  863. for (BYTE i = 0; i < pdbFriendList->count; i++)
  864. {
  865. MEM_FRIENDRECORD memFriend;
  866. memFriend.cheating = pCursor->cheating;
  867. memFriend.cheated = pCursor->cheated;
  869. _BASIC_STR* pName = (_BASIC_STR*)(pCursor + 1);
  870. assert(pName->strlen > 0 && pName->strlen < _NAME_LEN);
  871. char* strName = (char*)(pName + 1);
  872. memFriend.name.assign(strName, pName->strlen);
  874. _BASIC_STR* pGroup = (_BASIC_STR*)(strName + pName->strlen);
  875. assert(pGroup->strlen >= 0 && pGroup->strlen < _NAME_LEN);
  876. char* strGroup = (char*)(pGroup + 1);
  877. memFriend.group.assign(strGroup, pGroup->strlen);
  879. pmemFriends->push_back(memFriend);
  881. pCursor = (DB_FRIENDRECORD*)(strGroup + pGroup->strlen);
  882. }
  884. delete []pValue;
  885. return TRUE;
  886. }
  888. BOOL CFriendMgr::DB_StoreSomeone(const std::_tstring& someone, const MEM_FRIENDRECORDLIST& memFriends)
  889. {
  890. assert(!someone.empty());
  892. size_t cntFriends = memFriends.size();
  894. if (cntFriends <= 0)
  895. {//erase this someone record, because it's empty
  896. DB_DeleteSomeone(someone);
  897. return TRUE;
  898. }
  900. size_t sizeMax = sizeof(DB_FRIENDRECORD) + (sizeof(_BASIC_STR) + _NAME_LEN) * cntFriends;
  902. DB_FRIENDRECORDLIST* pdbFriendList = (DB_FRIENDRECORDLIST*)_alloca(sizeMax);
  903. pdbFriendList->count = cntFriends;
  905. DB_FRIENDRECORD* pCursor = (DB_FRIENDRECORD*)(pdbFriendList + 1);
  906. for (MEM_FRIENDRECORDLIST::const_iterator it = memFriends.begin(); it != memFriends.end(); it++)
  907. {
  908. const MEM_FRIENDRECORD& rmemFriendRec = *it;
  909. assert(rmemFriendRec.name.size() > 0 && rmemFriendRec.name.size() < _NAME_LEN);
  910. assert(rmemFriendRec.group.size() >= 0 && rmemFriendRec.group.size() < _NAME_LEN);
  912. pCursor->cheating = rmemFriendRec.cheating;
  913. pCursor->cheated = rmemFriendRec.cheated;
  915. _BASIC_STR* pName = (_BASIC_STR*)(pCursor + 1);
  916. pName->strlen = rmemFriendRec.name.size();
  917. char* strName = (char*)(pName + 1);
  918. memcpy(strName, rmemFriendRec.name.data(), rmemFriendRec.name.size());
  920. _BASIC_STR* pGroup = (_BASIC_STR*)(strName + rmemFriendRec.name.size());
  921. pGroup->strlen = rmemFriendRec.group.size();
  922. char* strGroup = (char*)(pGroup + 1);
  923. memcpy(strGroup, rmemFriendRec.group.data(), rmemFriendRec.group.size());
  925. pCursor = (DB_FRIENDRECORD*)(strGroup + rmemFriendRec.group.size());
  928. assert((BYTE*)pCursor <= (BYTE*)pdbFriendList + sizeMax);
  929. }
  931. size_t sizeUsed = (BYTE*)pCursor - (BYTE*)pdbFriendList;
  932. assert(sizeUsed > 0);
  934. std::_tstring dbkey = NameToDBKey(someone);
  936. AUTOLOCKWRITE(m_lockDB);
  937. return m_dbFriend.add(dbkey.data(), dbkey.size(), (const char*)pdbFriendList, sizeUsed);
  938. }
  941. BOOL CFriendMgr::BkgrndUpdateDB()
  942. {
  943. if (m_StorePlayerPerUdtDB <= 0)
  944. return TRUE;
  946. ONEPLAYERLIST listOnePlayer;
  948. {{
  949. //dup the data into mem
  951. typedef std::list<std::_tstring> MEMPLAYERS;
  952. MEMPLAYERS memPlayers;
  954. {{
  955. AUTOLOCKREAD(m_lockFriend);
  957. size_t playercount = m_mapPlayers.size();
  959. if (playercount <= 0)
  960. return TRUE;
  962. if (m_cursorBkgrndUdtDB >= playercount)
  963. m_cursorBkgrndUdtDB = 0;
  965. //seek to cursor
  966. PLAYERSMAP::iterator itBase;
  967. if (m_cursorBkgrndUdtDB <= playercount/2)
  968. {
  969. itBase = m_mapPlayers.begin();
  970. for (size_t i = 0; i < m_cursorBkgrndUdtDB; i++)
  971. ++ itBase;
  972. }
  973. else
  974. {
  975. itBase = m_mapPlayers.end();
  976. for (size_t i = playercount; i > m_cursorBkgrndUdtDB; i--)
  977. -- itBase;
  978. }
  980. PLAYERSMAP::iterator itPlayer = itBase;
  981. do
  982. {
  983. //limit store player count
  984. if (m_StorePlayerPerUdtDB != size_t(-1)
  985. && listOnePlayer.size() + memPlayers.size() > m_StorePlayerPerUdtDB)
  986. break;
  988. std::_tstring someone = (*itPlayer).first;
  989. PLAYERINFO& rPlayerInfo = (*itPlayer).second;
  991. if (rPlayerInfo.loaded)
  992. {
  993. listOnePlayer.push_back(ONEPLAYER());
  994. ONEPLAYER& rOnePlayer = listOnePlayer.back();
  997. BOOL needstore = rPlayerInfo.dirty;
  999. rPlayerInfo.dirty = FALSE;
  1002. rOnePlayer.someone = someone;
  1004. for (FRIENDSMAP::iterator itFriend = rPlayerInfo.friends.begin(); itFriend != rPlayerInfo.friends.end(); itFriend++)
  1005. {
  1006. FRIENDINFO& rInfo = (*itFriend).second;
  1007. assert(rInfo.pCheated);
  1008. if (!rInfo.pCheated)
  1009. continue;
  1011. MEM_FRIENDRECORD memFriendRec;
  1012. memFriendRec.name = (*itFriend).first;
  1013. memFriendRec.group = rInfo.group;
  1014. memFriendRec.cheating = rInfo.cheating;
  1015. memFriendRec.cheated = *rInfo.pCheated;
  1017. rOnePlayer.listFriends.push_back(memFriendRec);
  1019. if (!needstore
  1020. && ((rInfo.cheating ? FRIENDINFO::cheatTRUE : FRIENDINFO::cheatFALSE) != rInfo.orig_cheating
  1021. || (*rInfo.pCheated ? FRIENDINFO::cheatTRUE : FRIENDINFO::cheatFALSE) != rInfo.orig_cheated))
  1022. {
  1023. needstore = TRUE;
  1024. }
  1026. rInfo.orig_cheating = rInfo.cheating ? FRIENDINFO::cheatTRUE : FRIENDINFO::cheatFALSE;
  1027. rInfo.orig_cheated = *rInfo.pCheated ? FRIENDINFO::cheatTRUE : FRIENDINFO::cheatFALSE;
  1028. }
  1030. if (!needstore)
  1031. listOnePlayer.pop_back();
  1032. }
  1033. else
  1034. {
  1035. //limit load player count
  1036. if (m_LoadPlayerPerUdtDB != size_t(-1)
  1037. && memPlayers.size() < m_LoadPlayerPerUdtDB)
  1038. memPlayers.push_back(someone);
  1039. }
  1041. ++ itPlayer;
  1042. if (itPlayer == m_mapPlayers.end())
  1043. itPlayer = m_mapPlayers.begin();
  1045. } while (itPlayer != itBase);
  1046. }}
  1048. {{
  1049. if (!memPlayers.empty())
  1050. {
  1051. AUTOLOCKWRITE(m_lockFriend);
  1053. for (MEMPLAYERS::iterator itMemPlayer = memPlayers.begin(); itMemPlayer != memPlayers.end(); itMemPlayer++)
  1054. {
  1055. std::_tstring player = *itMemPlayer;
  1057. PLAYERSMAP::iterator itPlayer = _LoadSomeone(player);
  1058. if (itPlayer != m_mapPlayers.end())
  1059. {
  1060. PLAYERINFO& rPlayerInfo = (*itPlayer).second;
  1063. listOnePlayer.push_back(ONEPLAYER());
  1064. ONEPLAYER& rOnePlayer = listOnePlayer.back();
  1067. BOOL needstore = rPlayerInfo.dirty;
  1069. rPlayerInfo.dirty = FALSE;
  1072. rOnePlayer.someone = player;
  1074. for (FRIENDSMAP::iterator itFriend = rPlayerInfo.friends.begin(); itFriend != rPlayerInfo.friends.end(); itFriend++)
  1075. {
  1076. FRIENDINFO& rInfo = (*itFriend).second;
  1077. assert(rInfo.pCheated);
  1079. MEM_FRIENDRECORD memFriendRec;
  1080. memFriendRec.name = (*itFriend).first;
  1081. memFriendRec.group = rInfo.group;
  1082. memFriendRec.cheating = rInfo.cheating;
  1083. memFriendRec.cheated = *rInfo.pCheated;
  1085. rOnePlayer.listFriends.push_back(memFriendRec);
  1087. if (!needstore
  1088. && ((rInfo.cheating ? FRIENDINFO::cheatTRUE : FRIENDINFO::cheatFALSE) != rInfo.orig_cheating
  1089. || (*rInfo.pCheated ? FRIENDINFO::cheatTRUE : FRIENDINFO::cheatFALSE) != rInfo.orig_cheated))
  1090. {
  1091. needstore = TRUE;
  1092. }
  1094. rInfo.orig_cheating = rInfo.cheating ? FRIENDINFO::cheatTRUE : FRIENDINFO::cheatFALSE;
  1095. rInfo.orig_cheated = *rInfo.pCheated ? FRIENDINFO::cheatTRUE : FRIENDINFO::cheatFALSE;
  1096. }
  1098. if (!needstore)
  1099. listOnePlayer.pop_back();
  1100. }
  1101. }
  1102. }
  1103. }}
  1105. }}
  1107. {{
  1108. //store mem data into DB
  1110. for (ONEPLAYERLIST::iterator itOnePlayer = listOnePlayer.begin(); itOnePlayer != listOnePlayer.end(); itOnePlayer++)
  1111. {
  1112. ONEPLAYER& rOnePlayer = *itOnePlayer;
  1114. if (!DB_StoreSomeone(rOnePlayer.someone, rOnePlayer.listFriends))
  1115. {
  1116. PLAYERINFO& rPlayerInfo = m_mapPlayers[rOnePlayer.someone];
  1118. rPlayerInfo.dirty = TRUE;
  1120. rTRACE("error: bkgrnp store someone: %s", rOnePlayer.someone.c_str());
  1121. }
  1122. }
  1124. }}
  1126. m_cursorBkgrndUdtDB += listOnePlayer.size();
  1129. return TRUE;
  1130. }
  1133. size_t CFriendMgr::GetPlayerCount()
  1134. {
  1135. AUTOLOCKREAD(m_lockFriend);
  1137. return m_mapPlayers.size();
  1138. }
  1140. size_t CFriendMgr::GetAFQSize()
  1141. {
  1142. AUTOLOCKREAD(m_lockAddFriend);
  1144. return m_mapAddFriends.size();
  1145. }
  1149. BOOL CFriendMgr::PlayerAssociate(const std::_tstring& someone, const std::_tstring& dst, const std::_tstring& group, BYTE bidir)
  1150. {
  1151. AUTOLOCKWRITE(m_lockFriend);
  1154. PLAYERINFO& rSrcPlayerInfo = m_mapPlayers[someone];
  1155. assert(rSrcPlayerInfo.loaded);
  1156. FRIENDINFO& rSrcInfo = rSrcPlayerInfo.friends[dst];
  1157. rSrcInfo.cheating = false;
  1158. rSrcInfo.group = group;
  1160. PLAYERINFO& rDstPlayerInfo = m_mapPlayers[dst];
  1161. FRIENDINFO& rDstInfo = rDstPlayerInfo.friends[someone];
  1162. rDstInfo.cheating = bidir ? false : true;
  1163. rDstInfo.group = group;
  1165. //binding
  1166. rSrcInfo.pCheated = &rDstInfo.cheating;
  1167. rDstInfo.pCheated = &rSrcInfo.cheating;
  1170. rTRACE("Player Associate: %s [%s] on <%s>, bidir: %u", someone.c_str(), dst.c_str(), group.c_str(), int(bidir));
  1172. return TRUE;
  1173. }
  1176. BOOL CFriendMgr::PlayerAssociateBevy(const _BEVY& bevy, const std::_tstring& group)
  1177. {
  1178. if (bevy.size() < 2)
  1179. return TRUE;
  1182. AUTOLOCKWRITE(m_lockFriend);
  1185. std::vector<PLAYERSMAP::iterator> vecPlayer;
  1187. for (_BEVY::const_iterator itS = bevy.begin(); itS != bevy.end(); itS++)
  1188. {
  1189. std::string someone = *itS;
  1190. assert(!someone.empty());
  1192. std::pair<PLAYERSMAP::iterator, bool> insit = m_mapPlayers.insert(PLAYERSMAP::value_type(someone, PLAYERINFO()));
  1193. assert(!insit.second && insit.first != m_mapPlayers.end() && (*insit.first).second.loaded);
  1195. vecPlayer.push_back(insit.first);
  1196. }
  1198. if (vecPlayer.size() < 2)
  1199. return TRUE;
  1203. const size_t count = vecPlayer.size();
  1204. const size_t last = count - 1;
  1206. for (size_t idxSrc = 0; idxSrc < last; idxSrc++)
  1207. {
  1208. PLAYERSMAP::iterator itSrc = vecPlayer[idxSrc];
  1209. std::_tstring src = (*itSrc).first;
  1210. PLAYERINFO& rSrcPlayerInfo = (*itSrc).second;
  1213. for (size_t idxDst = idxSrc + 1; idxDst < count; idxDst++)
  1214. {
  1215. PLAYERSMAP::iterator itDst = vecPlayer[idxDst];
  1216. std::_tstring dst = (*itDst).first;
  1217. PLAYERINFO& rDstPlayerInfo = (*itDst).second;
  1219. if (!_tstring_equal()(dst, src))
  1220. {
  1221. FRIENDINFO& rSrcInfo = rSrcPlayerInfo.friends[dst];
  1222. rSrcInfo.cheating = false;
  1223. rSrcInfo.group = group;
  1225. FRIENDINFO& rDstInfo = rDstPlayerInfo.friends[src];
  1226. rDstInfo.cheating = false;
  1227. rDstInfo.group = group;
  1230. //binding
  1231. rSrcInfo.pCheated = &rDstInfo.cheating;
  1232. rDstInfo.pCheated = &rSrcInfo.cheating;
  1233. }
  1234. };
  1235. }
  1238. rTRACE("Players AssociateBevy: %u on <%s>", bevy.size(), group.c_str());
  1241. return TRUE;
  1242. }