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

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

模拟服务器

开发平台：

C/C++

ChannelMgr.cpp：源码内容
  1. // ChannelMgr.cpp: implementation of the CChannelMgr class.
  2. //
  3. //////////////////////////////////////////////////////////////////////
  5. #include "stdafx.h"
  6. #include "Global.h"
  7. #include "ChannelMgr.h"
  8. #include "S3Relay.h"
  9. #include "time.h"
  10. #include "malloc.h"
  12. #include <list>
  13. #include <map>
  15. /////////////////////////////////////////////////////
  17. static const size_t MAX_SENTLEN = 256;
  19. static const char NUMBER_CHARS[] = "0123456789";
  20. static const char NULL_STR[] = "";
  22. /////////////////////////////////////////////////////
  25. const char file_channcfg[] = "relay_channcfg.ini";
  27. const char sec_system[] = "system";
  28. const char key_nameGM[] = "nameGM";
  29. const char key_charEsc[] = "charEsc";
  30. const char key_charSplt[] = "charSplt";
  31. const char key_defCost[] = "defCost";
  33. const char sec_team[] = "team";
  34. const char sec_faction[] = "faction";
  35. const char sec_tong[] = "tong";
  36. const char sec_screen[] = "screen";
  37. const char sec_broadcast[] = "broadcast";
  38. const char key_escSpec[] = "escSpec";
  39. const char key_minID[] = "minID";
  40. const char key_maxID[] = "maxID";
  45. const char file_relaychann[] = "relay_channel.ini";
  46. const char key_cost[] = "cost";
  50. //////////////////////////////////////////////////////////////////////
  51. // Construction/Destruction
  52. //////////////////////////////////////////////////////////////////////
  54. CChannelMgr::CChannelMgr()
  55. : m_lastChannID(0), m_channidGM(-1),
  56. m_chChannEsc(0), m_chChannSplt(0),
  57. m_chChannTEAM(0), m_chChannFAC(0), m_chChannTONG(0), m_chChannSCRN(0),
  58. m_minTeamID(0), m_maxTeamID(-1), m_minFacID(0), m_maxFacID(-1), m_minTongID(0), m_maxTongID(-1),
  59. m_defCost(0),
  60. m_costTeam(0), m_costFac(0), m_costTong(0), m_costScrn(0), m_costBc(0)
  61. {
  63. }
  65. CChannelMgr::~CChannelMgr()
  66. {
  68. }
  71. BOOL CChannelMgr::Initialize()
  72. {
  73. DUMMY_AUTOLOCKWRITE(m_lockChannel);
  75. m_chChannEsc  = gGetPrivateProfileCharEx(sec_system, key_charEsc, file_channcfg, defCHANN_esc);
  76. m_chChannSplt = gGetPrivateProfileCharEx(sec_system, key_charSplt, file_channcfg, defCHANN_splt);
  78. m_chChannTEAM = gGetPrivateProfileCharEx(sec_team, key_escSpec, file_channcfg, defCHANN_TEAM);
  79. m_chChannFAC  = gGetPrivateProfileCharEx(sec_faction, key_escSpec, file_channcfg, defCHANN_FAC);
  80. m_chChannTONG = gGetPrivateProfileCharEx(sec_tong, key_escSpec, file_channcfg, defCHANN_TONG);
  81. m_chChannSCRN = gGetPrivateProfileCharEx(sec_screen, key_escSpec, file_channcfg, defCHANN_SCRN);
  82. m_chChannBC   = gGetPrivateProfileCharEx(sec_broadcast, key_escSpec, file_channcfg, defCHANN_BC);
  84. m_minTeamID = gGetPrivateProfileIntEx(sec_team, key_minID, file_channcfg, 0);
  85. m_maxTeamID = gGetPrivateProfileIntEx(sec_team, key_maxID, file_channcfg, -1);
  86. m_minFacID = gGetPrivateProfileIntEx(sec_faction, key_minID, file_channcfg, 0);
  87. m_maxFacID = gGetPrivateProfileIntEx(sec_faction, key_maxID, file_channcfg, -1);
  88. m_minTongID = gGetPrivateProfileIntEx(sec_tong, key_minID, file_channcfg, 0);
  89. m_maxTongID = gGetPrivateProfileIntEx(sec_tong, key_maxID, file_channcfg, -1);
  91. m_defCost = (BYTE)gGetPrivateProfileIntEx(sec_system, key_defCost, file_channcfg, 0);
  93. m_costTeam = (BYTE)gGetPrivateProfileIntEx(sec_team, key_cost, file_channcfg, (INT)(UINT)m_defCost);
  94. m_costFac  = (BYTE)gGetPrivateProfileIntEx(sec_faction, key_cost, file_channcfg, (INT)(UINT)m_defCost);
  95. m_costTong = (BYTE)gGetPrivateProfileIntEx(sec_tong, key_cost, file_channcfg, (INT)(UINT)m_defCost);
  96. m_costScrn = (BYTE)gGetPrivateProfileIntEx(sec_screen, key_cost, file_channcfg, (INT)(UINT)m_defCost);
  97. m_costBc   = (BYTE)gGetPrivateProfileIntEx(sec_broadcast, key_cost, file_channcfg, (INT)(UINT)m_defCost);
  99. std::_tstring nameChannGM = gGetPrivateProfileStringEx(sec_system, key_nameGM, file_channcfg);
  100. if (!nameChannGM.empty())
  101. {
  102. //create the channel
  103. m_channidGM = GenChannID();
  104. if (m_channidGM == DWORD(-1))
  105. return FALSE;
  107. m_mapChann2ID[nameChannGM] = m_channidGM;
  109. CHANNINFO& rChannInfo = m_mapChannid2Info[m_channidGM];
  111. rChannInfo.god = TRUE;
  112. rChannInfo.stock = TRUE;
  113. rChannInfo.channname = nameChannGM;
  114. rChannInfo.gmuse = FALSE;
  115. rChannInfo.gmsub = FALSE;
  116. rChannInfo.cost = (BYTE)gGetPrivateProfileIntEx(nameChannGM.c_str(), key_cost, file_relaychann, (INT)(UINT)m_defCost);
  118. rTRACE("Create Channel: [Stock, GM] <%08X> %s", m_channidGM, nameChannGM.c_str());
  119. }
  122. const std::vector<std::_tstring>& rVecChann = gGetPrivateProfileSectionNamesEx(file_relaychann);
  124. for (std::vector<std::_tstring>::const_iterator it = rVecChann.begin(); it != rVecChann.end(); it++)
  125. {
  126. std::_tstring channname = *it;
  127. assert(!channname.empty());
  129. if (_tstring_equal()(channname, nameChannGM)) //gm, created already
  130. continue;
  132. DWORD channid = GenChannID();
  133. if (channid == DWORD(-1))
  134. return FALSE;
  136. m_mapChann2ID[channname] = channid;
  138. CHANNINFO& rChannInfo = m_mapChannid2Info[channid];
  139. rChannInfo.god = FALSE;
  140. rChannInfo.stock = TRUE;
  141. rChannInfo.channname = channname;
  142. rChannInfo.gmuse = FALSE;
  143. rChannInfo.gmsub = FALSE;
  144. rChannInfo.cost = (BYTE)gGetPrivateProfileIntEx(channname.c_str(), key_cost, file_relaychann, (INT)(UINT)m_defCost);
  146. rTRACE("Create Channel: [Stock] <%08X> %s", channid, channname.c_str());
  147. }
  149. return TRUE;
  150. }
  152. BOOL CChannelMgr::Uninitialize()
  153. {
  154. DUMMY_AUTOLOCKWRITE(m_lockChannel);
  156. m_mapChann2ID.clear();
  157. m_mapChannid2Info.clear();
  160. m_defCost = 0;
  162. m_costTeam = 0;
  163. m_costFac  = 0;
  164. m_costTong = 0;
  165. m_costScrn = 0;
  166. m_costBc   = 0;
  169. m_channidGM = -1;
  171. m_chChannEsc = 0;
  172. m_chChannSplt = 0;
  173. m_chChannTEAM = 0;
  174. m_chChannFAC = 0;
  175. m_chChannSCRN = 0;
  176. m_chChannBC = 0;
  178. m_minTeamID = 0;
  179. m_maxTeamID = -1;
  180. m_minFacID = 0;
  181. m_maxFacID = -1;
  182. m_minTongID = 0;
  183. m_maxTongID = -1;
  185. return TRUE;
  186. }
  189. DWORD CChannelMgr::GenChannID()
  190. {
  191. //assert(m_lockChannel._IsWriting());
  193. if (m_lastChannID != DWORD(-1))
  194. return m_lastChannID++;
  196. //no base idle, then search idle
  197. DWORD id = 0;
  198. for (CHANNID2INFOMAP::iterator it = m_mapChannid2Info.begin(); it != m_mapChannid2Info.end(); it++)
  199. {
  200. if ((*it).first != id)
  201. return id;
  202. id ++;
  203. }
  204. return id;
  205. }
  209. std::_tstring CChannelMgr::GetChannelName(DWORD channelid, BOOL adv)
  210. {
  211. DUMMY_AUTOLOCKREAD(m_lockChannel);
  213. CHANNID2INFOMAP::const_iterator it = m_mapChannid2Info.find(channelid);
  214. if (it == m_mapChannid2Info.end())
  215. return NULL_STR;
  217. std::_tstring channname = (*it).second.channname;
  219. return adv ? channname : ReduceChannelName(channname);
  220. }
  222. DWORD CChannelMgr::GetChannelID(const std::_tstring& channname, DWORD advIP)
  223. {
  224. std::_tstring advChannName = advIP == 0 ? channname : MakeChannelName(channname, advIP);
  225. if (advChannName.empty())
  226. return -1;
  228. DUMMY_AUTOLOCKREAD(m_lockChannel);
  230. CHANN2IDMAP::iterator it = m_mapChann2ID.find(advChannName);
  231. if (it == m_mapChann2ID.end())
  232. return -1;
  234. return (*it).second;
  235. }
  238. BOOL CChannelMgr::IsSubscribed(DWORD ip, unsigned long param, DWORD channid)
  239. {
  240. DUMMY_AUTOLOCKREAD(m_lockChannel);
  242. CHANNID2INFOMAP::iterator itChannid = m_mapChannid2Info.find(channid);
  243. if (itChannid == m_mapChannid2Info.end())
  244. return FALSE;
  246. CHANNINFO& rChannInfo = (*itChannid).second;
  248. IP2PLAYERSMAP::iterator itIP = rChannInfo.mapIp2Players.find(ip);
  249. if (itIP == rChannInfo.mapIp2Players.end())
  250. return FALSE;
  252. PLAYERSMAP& rPlayers = (*itIP).second;
  253. PLAYERSMAP::iterator itRole = rPlayers.find(param);
  254. if (itRole == rPlayers.end())
  255. return FALSE;
  257. PLAYERINFO& rInfo = (*itRole).second;
  258. return rInfo.subed;
  259. }
  262. BOOL CChannelMgr::GmSubscribe(DWORD channid)
  263. {
  264. if (channid == -1)
  265. return FALSE;
  267. DUMMY_AUTOLOCKWRITE(m_lockChannel);
  269. if (channid == m_channidGM)
  270. return TRUE;
  272. CHANNID2INFOMAP::iterator it = m_mapChannid2Info.find(channid);
  273. if (it == m_mapChannid2Info.end())
  274. return FALSE;
  276. CHANNINFO& rChannInfo = (*it).second;
  277. if (!rChannInfo.gmuse)
  278. return FALSE;
  280. rChannInfo.gmsub = TRUE;
  282. return TRUE;
  283. }
  285. BOOL CChannelMgr::GmUnsubscribe(DWORD channid)
  286. {
  287. if (channid == m_channidGM)
  288. return FALSE;
  290. DUMMY_AUTOLOCKWRITE(m_lockChannel);
  292. CHANNID2INFOMAP::iterator it = m_mapChannid2Info.find(channid);
  293. if (it == m_mapChannid2Info.end())
  294. return FALSE;
  296. CHANNINFO& rChannInfo = (*it).second;
  297. if (!rChannInfo.gmuse)
  298. return FALSE;
  300. rChannInfo.gmsub = FALSE;
  302. return TRUE;
  303. }
  305. BOOL CChannelMgr::IsGmSubscribed(DWORD channid)
  306. {
  307. if (channid == m_channidGM)
  308. return TRUE;
  310. DUMMY_AUTOLOCKREAD(m_lockChannel);
  312. CHANNID2INFOMAP::iterator it = m_mapChannid2Info.find(channid);
  313. if (it == m_mapChannid2Info.end())
  314. return FALSE;
  316. CHANNINFO& rChannInfo = (*it).second;
  318. return rChannInfo.gmsub;
  319. }
  321. BOOL CChannelMgr::GmQueryChannelID(const std::_tstring& channel, BOOL force)
  322. {
  323. DUMMY_AUTOLOCKWRITE(m_lockChannel);
  325. DWORD theChannID = -1;
  326. BYTE cost = 0;
  328. CHANN2IDMAP::iterator it = m_mapChann2ID.find(channel);
  329. if (it != m_mapChann2ID.end())
  330. {//channel exist
  331. DWORD channid = (*it).second;
  333. CHANNINFO& rChannInfo = m_mapChannid2Info[channid];
  335. rChannInfo.gmuse = TRUE;
  337. theChannID = channid;
  338. cost = rChannInfo.cost;
  339. }
  340. else
  341. {
  342. if (force)
  343. {
  344. //erase the channel
  345. DWORD channid = GenChannID();
  346. if (channid != DWORD(-1))
  347. {
  348. m_mapChann2ID[channel] = channid;
  350. CHANNINFO& rChannInfo = m_mapChannid2Info[channid];
  351. rChannInfo.god = FALSE;
  352. rChannInfo.stock = FALSE;
  353. rChannInfo.channname = channel;
  354. rChannInfo.gmuse = TRUE;
  355. rChannInfo.gmsub = FALSE;
  356. rChannInfo.cost = GainPreCost(channel);
  358. rTRACE("GM Create Channel: <%08X> %s", channid, channel.c_str());
  360. theChannID = channid;
  361. cost = rChannInfo.cost;
  362. }
  363. }
  365. }
  367. {{
  368. size_t pckgsize = sizeof(RELAY_ASKWAY_DATA) + sizeof(PLAYERCOMM_NOTIFYCHANNELID);
  370. RELAY_ASKWAY_DATA* pAskWayData = (RELAY_ASKWAY_DATA*)_alloca(pckgsize);
  371. pAskWayData->ProtocolFamily = pf_relay;
  372. pAskWayData->ProtocolID = relay_c2c_askwaydata;
  373. pAskWayData->nFromIP = 0;
  374. pAskWayData->nFromRelayID = -1;
  375. pAskWayData->seekRelayCount = 0;
  376. pAskWayData->seekMethod = rm_gm;
  377. pAskWayData->wMethodDataLength = 0;
  378. pAskWayData->routeDateLength = sizeof(PLAYERCOMM_NOTIFYCHANNELID);
  380. PLAYERCOMM_NOTIFYCHANNELID* pPlayerCommNotiChannID = (PLAYERCOMM_NOTIFYCHANNELID*)(pAskWayData + 1);
  381. pPlayerCommNotiChannID->ProtocolFamily = pf_playercommunity;
  382. pPlayerCommNotiChannID->ProtocolID = playercomm_s2c_notifychannelid;
  383. strcpy(pPlayerCommNotiChannID->channel, channel.c_str());
  384. pPlayerCommNotiChannID->channelid = theChannID;
  385. pPlayerCommNotiChannID->cost = cost;
  387. g_RootClient.SendPackage(pAskWayData, pckgsize);
  388. }}
  390. return TRUE;
  391. }
  393. BOOL CChannelMgr::GmFreeChannID(DWORD channid)
  394. {
  395. DUMMY_AUTOLOCKWRITE(m_lockChannel);
  397. CHANNID2INFOMAP::iterator it = m_mapChannid2Info.find(channid);
  398. if (it == m_mapChannid2Info.end())
  399. return FALSE;
  401. CHANNINFO& rChannInfo = (*it).second;
  403. //ensure
  404. assert(!rChannInfo.gmsub);
  405. rChannInfo.gmsub = FALSE;
  407. rChannInfo.gmuse = FALSE;
  409. if (!rChannInfo.stock
  410. && rChannInfo.mapIp2Players.empty())
  411. {
  412. rTRACE("GM Destroy Channel: <%08X> %s", channid, rChannInfo.channname.c_str());
  414. m_mapChann2ID.erase(rChannInfo.channname);
  415. m_mapChannid2Info.erase(it);
  416. }
  418. return TRUE;
  419. }
  421. BOOL CChannelMgr::IsUsed(DWORD ip, unsigned long param, DWORD channid)
  422. {
  423. DUMMY_AUTOLOCKREAD(m_lockChannel);
  425. CHANNID2INFOMAP::iterator itChannid = m_mapChannid2Info.find(channid);
  426. if (itChannid == m_mapChannid2Info.end())
  427. return FALSE;
  429. CHANNINFO& rChannInfo = (*itChannid).second;
  431. IP2PLAYERSMAP::iterator itIP = rChannInfo.mapIp2Players.find(ip);
  432. if (itIP == rChannInfo.mapIp2Players.end())
  433. return FALSE;
  435. PLAYERSMAP& rPlayers = (*itIP).second;
  436. PLAYERSMAP::iterator itRole = rPlayers.find(param);
  438. return itRole != rPlayers.end();
  439. }
  441. BOOL CChannelMgr::IsGmUsed(DWORD channid)
  442. {
  443. DUMMY_AUTOLOCKREAD(m_lockChannel);
  445. CHANNID2INFOMAP::iterator it = m_mapChannid2Info.find(channid);
  446. if (it == m_mapChannid2Info.end())
  447. return FALSE;
  449. CHANNINFO& rChannInfo = (*it).second;
  451. return rChannInfo.gmuse;
  452. }
  455. std::_tstring CChannelMgr::MakeChannelName(const std::_tstring& chann, DWORD ip)
  456. {
  457. if (chann.empty())
  458. return NULL_STR;
  460. if (chann[0] != m_chChannEsc)
  461. return chann;
  463. if (chann.size() < 2)
  464. return NULL_STR;
  466. if (chann[1] == m_chChannTEAM
  467. || chann[1] == m_chChannFAC
  468. || chann[1] == m_chChannTONG)
  469. {
  470. if (chann.size() <= 2)
  471. return NULL_STR;
  472. if (chann.find_last_not_of(NUMBER_CHARS) > 1)
  473. return NULL_STR;
  475. DWORD id = _ttol(chann.c_str() + 2);
  477. if (chann[1] == m_chChannFAC)
  478. return IsValidFacID(id) ? chann : NULL_STR;
  479. if (chann[1] == m_chChannTONG)
  480. return IsValidTongID(id) ? chann : NULL_STR;
  482. if (ip == 0 || !IsValidTeamID(id))
  483. return NULL_STR;
  485. char buffer[16];
  486. std::_tstring channname(chann);
  487. channname += m_chChannSplt;
  488. channname += _ultot(ip, buffer, 10);
  490. return channname;
  491. }
  492. else if (chann[1] == m_chChannSCRN
  493. || chann[1] == m_chChannBC)
  494. {
  495. if (chann.size() > 2)
  496. return NULL_STR;
  498. char buffer[16];
  499. std::_tstring channname(chann);
  500. channname += _ultot(ip, buffer, 10);
  502. return channname;
  503. }
  505. return NULL_STR;
  506. }
  508. std::_tstring CChannelMgr::ReduceChannelName(const std::_tstring& chann)
  509. {
  510. if (chann.empty())
  511. return NULL_STR;
  513. if (chann[0] != m_chChannEsc)
  514. return chann;
  516. if (chann.size() < 2)
  517. return NULL_STR;
  519. if (chann[1] == m_chChannTEAM)
  520. {
  521. int spltpos = chann.find_last_of(m_chChannSplt);
  522. if (spltpos == -1)
  523. return NULL_STR;
  524. return std::_tstring(chann.c_str(), spltpos);
  525. }
  526. if (chann[1] == m_chChannFAC
  527. || chann[1] == m_chChannTONG)
  528. {
  529. return chann;
  530. }
  531. if (chann[1] == m_chChannSCRN
  532. || chann[1] == m_chChannBC)
  533. {
  534. return std::_tstring(chann.c_str(), 2);
  535. }
  537. assert(FALSE);
  538. return NULL_STR;
  539. }
  541. DWORD CChannelMgr::ParseChannelName(const std::_tstring& chann, DWORD* pIP)
  542. {
  543. if (pIP != NULL)
  544. *pIP = 0;
  546. if (chann.empty())
  547. return -1;
  549. if (chann[0] != m_chChannEsc)
  550. return -1;
  552. if (chann.size() < 2)
  553. return -1;
  555. std::_tstring basechann;
  556. if (chann[1] == m_chChannTEAM)
  557. {
  558. int spltpos = chann.find_last_of(m_chChannSplt);
  559. if (spltpos == -1)
  560. return -1;
  562. if (pIP != NULL)
  563. *pIP = _ttol(chann.c_str() + spltpos + 1);
  564. return _ttol(chann.c_str() + 2);
  565. }
  566. if (chann[1] == m_chChannFAC
  567. || chann[1] == m_chChannTONG)
  568. {
  569. return _ttol(chann.c_str() + 2);
  570. }
  571. if (chann[1] == m_chChannSCRN
  572. || chann[1] == m_chChannBC)
  573. {
  574. if (pIP != NULL)
  575. *pIP = _ttol(chann.c_str() + 2);
  576. return 0;
  577. }
  579. return -1;
  580. }
  583. BYTE CChannelMgr::GainPreCost(const std::_tstring& channel)
  584. {
  585. if (channel.size() >= 2 && channel[0] == m_chChannEsc)
  586. {
  587. if (channel[1] == m_chChannTEAM)
  588. return m_costTeam;
  589. else if (channel[1] == m_chChannFAC)
  590. return m_costFac;
  591. else if (channel[1] == m_chChannTONG)
  592. return m_costTong;
  593. else if (channel[1] == m_chChannSCRN)
  594. return m_costScrn;
  595. else if (channel[1] == m_chChannBC)
  596. return m_costBc;
  597. }
  599. return m_defCost;
  600. }
  603. DWORD CChannelMgr::GetGMChannID()
  604. {
  605. return m_channidGM;
  606. }
  608. BOOL CChannelMgr::IsGodChannel(DWORD channid)
  609. {
  610. DUMMY_AUTOLOCKREAD(m_lockChannel);
  612. CHANNID2INFOMAP::const_iterator it = m_mapChannid2Info.find(channid);
  613. if (it == m_mapChannid2Info.end())
  614. return FALSE;
  616. const CHANNINFO& rChannInfo = (*it).second;
  618. return rChannInfo.god;
  619. }
  621. BOOL CChannelMgr::IsStockChannel(DWORD channid)
  622. {
  623. DUMMY_AUTOLOCKREAD(m_lockChannel);
  625. CHANNID2INFOMAP::const_iterator it = m_mapChannid2Info.find(channid);
  626. if (it == m_mapChannid2Info.end())
  627. return FALSE;
  629. const CHANNINFO& rChannInfo = (*it).second;
  631. return rChannInfo.stock;
  632. }
  634. BOOL CChannelMgr::PassToSpecMan(DWORD ToIP, unsigned long ToRelayID, DWORD ToNameID, const void* pData, size_t size)
  635. {
  636. CNetConnectDup conndup = g_ChatServer.FindChatConnectByIP(ToIP);
  637. if (!conndup.IsValid())
  638. return FALSE;
  640. size_t pckgsize = sizeof(CHAT_SPECMAN) + size;
  642. CHAT_SPECMAN* pCsm = (CHAT_SPECMAN*)_alloca(pckgsize);
  643. pCsm->ProtocolType = chat_specman;
  644. pCsm->wSize = pckgsize - 1;
  645. pCsm->nameid = ToNameID;
  646. pCsm->lnID = ToRelayID;
  647. pCsm->wChatLength = size;
  649. void* pExPckg = pCsm + 1;
  650. memcpy(pExPckg, pData, size);
  652. conndup.SendPackage(pCsm, pckgsize);
  654. return TRUE;
  655. }
  657. BOOL CChannelMgr::PassToGroupMan(DWORD ToIP, BOOL verify, const MANLIST& mans, const void* pData, size_t size)
  658. {
  659. if (mans.empty())
  660. return TRUE;
  662. const size_t playerlen = verify ? sizeof(tagPlusSrcInfo) : sizeof(WORD);
  663. size_t basesize = sizeof(CHAT_GROUPMAN) + size;
  664. if (basesize + playerlen > max_packagesize)
  665. return FALSE;
  667. CNetConnectDup conndup = g_ChatServer.FindChatConnectByIP(ToIP);
  668. if (!conndup.IsValid())
  669. return FALSE;
  672. BYTE buffer[max_packagesize];
  674. CHAT_GROUPMAN* pCgm = (CHAT_GROUPMAN*)buffer;
  675. pCgm->ProtocolType = chat_groupman;
  676. pCgm->wChatLength = size;
  677. pCgm->byHasIdentify = (BYTE)verify;
  679. void* pExPckg = pCgm + 1;
  680. memcpy(pExPckg, pData, size);
  683. size_t cursor = basesize;
  685. for (MANLIST::const_iterator it = mans.begin(); it != mans.end(); it++)
  686. {
  687. if (verify)
  688. *(tagPlusSrcInfo*)(buffer + cursor) = *it;
  689. else
  690. *(WORD*)(buffer + cursor)= (WORD)(*it).lnID;
  691. cursor += playerlen;
  693. if (cursor + playerlen > max_packagesize)
  694. {
  695. assert((cursor - basesize) % playerlen == 0);
  697. pCgm->wSize = cursor - 1;
  698. pCgm->wPlayerCount = (cursor - basesize) / playerlen;
  700. conndup.SendPackage(buffer, cursor);
  702. cursor = basesize;
  703. }
  704. }
  706. if (cursor > basesize)
  707. {
  708. assert((cursor - basesize) % playerlen == 0);
  710. pCgm->wSize = cursor - 1;
  711. pCgm->wPlayerCount = (cursor - basesize) / playerlen;
  713. conndup.SendPackage(buffer, cursor);
  714. }
  716. return TRUE;
  717. }
  720. BOOL CChannelMgr::PassToGM(const void* pData, size_t size)
  721. {
  722. size_t pckgsize = sizeof(RELAY_ASKWAY_DATA) + size;
  724. RELAY_ASKWAY_DATA* pAskWayData = (RELAY_ASKWAY_DATA*)_alloca(pckgsize);
  725. pAskWayData->ProtocolFamily = pf_relay;
  726. pAskWayData->ProtocolID = relay_c2c_askwaydata;
  727. pAskWayData->nFromIP = 0;
  728. pAskWayData->nFromRelayID = 0;
  729. pAskWayData->seekRelayCount = 0;
  730. pAskWayData->seekMethod = rm_gm;
  731. pAskWayData->wMethodDataLength = 0;
  732. pAskWayData->routeDateLength = size;
  734. void* pExPckg = pAskWayData + 1;
  735. memcpy(pExPckg, pData, size);
  737. g_RootClient.SendPackage(pAskWayData, pckgsize);
  739. return TRUE;
  740. }
  742. BOOL CChannelMgr::IsValidTeamID(DWORD idTeam)
  743. {
  744. if (m_minTeamID > m_maxTeamID)
  745. return TRUE;
  747. return idTeam >= m_minTeamID && idTeam <= m_maxTeamID;
  748. }
  750. BOOL CChannelMgr::IsValidFacID(DWORD idFac)
  751. {
  752. if (m_minFacID > m_maxFacID)
  753. return TRUE;
  755. return idFac >= m_minFacID && idFac <= m_maxFacID;
  756. }
  758. BOOL CChannelMgr::IsValidTongID(DWORD idTong)
  759. {
  760. if (m_minTongID > m_maxTongID)
  761. return TRUE;
  763. return idTong >= m_minTongID && idTong <= m_maxTongID;
  764. }
  767. BOOL CChannelMgr::SomeoneChat(DWORD srcIP, const tagPlusSrcInfo& SrcInfo, const CHAT_SOMEONECHAT_CMD* pSomeoneChatCmd)
  768. {
  769. if (pSomeoneChatCmd->sentlen <= 0 || pSomeoneChatCmd->sentlen > MAX_SENTLEN)
  770. return FALSE;
  771. if (!gIsLegalString(pSomeoneChatCmd->someone, 1, _NAME_LEN))
  772. return FALSE;
  774. std::_tstring srcrole;
  775. if (!g_HostServer.FindPlayerByIpParam(NULL, srcIP, SrcInfo.lnID, NULL, NULL, &srcrole, NULL))
  776. return FALSE;
  779. BOOL sent = FALSE;
  781. CNetConnectDup hostconndup;
  782. DWORD nameid = 0;
  783. unsigned long param = 0;
  784. if (g_HostServer.FindPlayerByRole(NULL, std::_tstring(pSomeoneChatCmd->someone), &hostconndup, NULL, &nameid, &param))
  785. {
  786. size_t syncsize = sizeof(CHAT_SOMEONECHAT_SYNC) + pSomeoneChatCmd->sentlen;
  787. CHAT_SOMEONECHAT_SYNC* pCscSync = (CHAT_SOMEONECHAT_SYNC*)_alloca(syncsize);
  788. pCscSync->ProtocolType = chat_someonechat;
  789. pCscSync->wSize = syncsize - 1;
  790. pCscSync->packageID = pSomeoneChatCmd->packageID;
  791. strcpy(pCscSync->someone, srcrole.c_str());
  792. pCscSync->sentlen = pSomeoneChatCmd->sentlen;
  793. memcpy(pCscSync + 1, pSomeoneChatCmd + 1, pSomeoneChatCmd->sentlen);
  795. if (PassToSpecMan(hostconndup.GetIP(), param, nameid, pCscSync, syncsize))
  796. sent = TRUE;
  797. }
  800. {{
  801. size_t _exsize = sizeof(DWORD) + _NAME_LEN + sizeof(BYTE) + pSomeoneChatCmd->sentlen; ////X
  802. size_t feedbacksize = sizeof(CHAT_FEEDBACK) + _exsize;
  803. CHAT_FEEDBACK* pCfb = (CHAT_FEEDBACK*)_alloca(feedbacksize);
  804. pCfb->ProtocolType = chat_feedback;
  805. pCfb->packageID = pSomeoneChatCmd->packageID;
  806. pCfb->code = sent ? codeSucc : codeFail;
  808. ////X
  809. DWORD* pChannelid = (DWORD*)(pCfb + 1);
  810. *pChannelid = -1;
  811. char* pDstName = (char*)(pChannelid + 1);
  812. strcpy(pDstName, pSomeoneChatCmd->someone);
  813. BYTE* pSentlen = (BYTE*)(pDstName + _NAME_LEN);
  814. *pSentlen = pSomeoneChatCmd->sentlen;
  815. void* pSent = pSentlen + 1;
  816. memcpy(pSent, pSomeoneChatCmd + 1, pSomeoneChatCmd->sentlen);
  817. ////X
  819. PassToSpecMan(srcIP, SrcInfo.lnID, SrcInfo.nameid, pCfb, feedbacksize);
  820. }}
  823. // dTRACE("Chat Someone: sentence %u Bs from [%s] to [%s]", pSomeoneChatCmd->sentlen, srcrole.c_str(), pSomeoneChatCmd->someone);
  826. return TRUE;
  827. }
  830. BOOL CChannelMgr::ChannelChat(DWORD srcIP, const tagPlusSrcInfo& SrcInfo, const CHAT_CHANNELCHAT_CMD* pChannelChatCmd)
  831. {
  832. if (pChannelChatCmd->channelid == -1)
  833. return FALSE;
  834. if (pChannelChatCmd->sentlen <= 0 || pChannelChatCmd->sentlen > MAX_SENTLEN)
  835. return FALSE;
  838. std::_tstring srcacc;
  839. std::_tstring srcrole;
  840. if (!g_HostServer.FindPlayerByIpParam(NULL, srcIP, SrcInfo.lnID, NULL, &srcacc, &srcrole, NULL))
  841. return FALSE;
  844. BOOL sent = FALSE;
  847. DUMMY_AUTOLOCKREAD(m_lockChannel);
  850. CHANNID2INFOMAP::iterator itChannid = m_mapChannid2Info.find(pChannelChatCmd->channelid);
  851. if (itChannid == m_mapChannid2Info.end())
  852. return FALSE;
  854. CHANNINFO& rChannInfo = (*itChannid).second;
  856. if (pChannelChatCmd->cost != rChannInfo.cost)
  857. return FALSE;
  860. if (rChannInfo.god)
  861. {
  862. if (g_RootClient.IsReady())
  863. {
  864. size_t pckgsize = sizeof(CHAT_MSG_EX) + pChannelChatCmd->sentlen;
  865. CHAT_MSG_EX* pChatMsgEx = (CHAT_MSG_EX*)_alloca(pckgsize);
  866. pChatMsgEx->ProtocolFamily = pf_playercommunity;
  867. pChatMsgEx->ProtocolID = playercomm_channelchat;
  868. strcpy(pChatMsgEx->m_szSourceName, srcrole.c_str());
  869. strcpy(pChatMsgEx->m_szAccountName, srcacc.c_str());
  870. pChatMsgEx->SentenceLength = pChannelChatCmd->sentlen;
  871. memcpy(pChatMsgEx + 1, pChannelChatCmd + 1, pChannelChatCmd->sentlen);
  873. PassToGM(pChatMsgEx, pckgsize);
  875. sent = TRUE;
  876. }
  877. }
  878. else
  879. {
  880. if (IsNeedRelegate(rChannInfo.channname, pChannelChatCmd->filter))
  881. {//relegate to gamesvr
  882. assert(rChannInfo.channname[0] == m_chChannEsc);
  884. DWORD channIP = 0;
  885. DWORD theID = ParseChannelName(rChannInfo.channname, &channIP);
  886. if (theID == -1 && channIP == 0)
  887. return FALSE;
  890. assert(rChannInfo.channname.size() >= 2);
  893. size_t syncsize = sizeof(CHAT_CHANNELCHAT_SYNC) + pChannelChatCmd->sentlen;
  894. size_t pckgsize = sizeof(CHAT_RELEGATE) + syncsize;
  896. CHAT_RELEGATE* pCr = (CHAT_RELEGATE*)_alloca(pckgsize);
  897. pCr->ProtocolType = chat_relegate;
  898. pCr->wSize = pckgsize - 1;
  899. pCr->nFromIP = srcIP;
  900. pCr->nFromRelayID = SrcInfo.lnID;
  901. pCr->channelid = pChannelChatCmd->channelid;
  902. pCr->routeDateLength = syncsize;
  904. CHAT_CHANNELCHAT_SYNC* pCccSync = (CHAT_CHANNELCHAT_SYNC*)(pCr + 1);
  905. pCccSync->ProtocolType = chat_channelchat;
  906. pCccSync->wSize = syncsize - 1;
  907. pCccSync->packageID = pChannelChatCmd->packageID;
  908. strcpy(pCccSync->someone, srcrole.c_str());
  909. pCccSync->channelid = pChannelChatCmd->channelid;
  910. pCccSync->sentlen = pChannelChatCmd->sentlen;
  911. memcpy(pCccSync + 1, pChannelChatCmd + 1, pChannelChatCmd->sentlen);
  914. if (rChannInfo.channname[1] == m_chChannTEAM)
  915. {
  916. if (theID == -1 || channIP == 0)
  917. return FALSE;
  919. CHANNINFO& rChannInfo = (*itChannid).second;
  921. CNetConnectDup connDup = g_ChatServer.FindChatConnectByIP(channIP);
  922. if (connDup.IsValid())
  923. {
  924. pCr->TargetCls = tgtcls_team;
  925. pCr->TargetID = theID;
  927. connDup.SendPackage(pCr, pckgsize);
  929. sent = TRUE;
  930. }
  931. }
  932. else if (rChannInfo.channname[1] == m_chChannFAC)
  933. {
  934. if (theID == -1)
  935. return FALSE;
  937. pCr->TargetCls = tgtcls_fac;
  938. pCr->TargetID = theID;
  940. g_ChatServer.BroadPackage(pCr, pckgsize);
  942. sent = TRUE;
  943. }
  944. else if (rChannInfo.channname[1] == m_chChannTONG)
  945. {
  946. if (theID == -1)
  947. return FALSE;
  949. pCr->TargetCls = tgtcls_tong;
  950. pCr->TargetID = theID;
  952. g_ChatServer.BroadPackage(pCr, pckgsize);
  954. sent = TRUE;
  955. }
  956. else if (rChannInfo.channname[1] == m_chChannSCRN
  957. || rChannInfo.channname[1] == m_chChannBC)
  958. {
  959. if (channIP == 0)
  960. return FALSE;
  962. assert(channIP != 0 && theID == 0);
  964. CNetConnectDup connDup = g_ChatServer.FindChatConnectByIP(channIP);
  965. if (connDup.IsValid())
  966. {
  967. BOOL isScrn = rChannInfo.channname[1] == m_chChannSCRN;
  969. pCr->TargetCls = isScrn ? tgtcls_scrn : tgtcls_bc;
  970. pCr->TargetID = isScrn ? SrcInfo.lnID : 0;
  972. connDup.SendPackage(pCr, pckgsize);
  974. sent = TRUE;
  975. }
  976. }
  977. else
  978. {
  979. assert(FALSE);
  980. return FALSE;
  981. }
  982. }
  983. else
  984. {//broad on channel
  985. //== PassToPlayer
  986. //do like this for optimize
  988. size_t syncsize = sizeof(CHAT_CHANNELCHAT_SYNC) + pChannelChatCmd->sentlen;
  989. CHAT_CHANNELCHAT_SYNC* pCccSync = (CHAT_CHANNELCHAT_SYNC*)_alloca(syncsize);
  990. pCccSync->ProtocolType = chat_channelchat;
  991. pCccSync->wSize = syncsize - 1;
  992. pCccSync->packageID = pChannelChatCmd->packageID;
  993. strcpy(pCccSync->someone, srcrole.c_str());
  994. pCccSync->channelid = pChannelChatCmd->channelid;
  995. pCccSync->sentlen = pChannelChatCmd->sentlen;
  996. memcpy(pCccSync + 1, pChannelChatCmd + 1, pChannelChatCmd->sentlen);
  999. for (IP2PLAYERSMAP::iterator itIP = rChannInfo.mapIp2Players.begin(); itIP != rChannInfo.mapIp2Players.end(); itIP++)
  1000. {
  1001. DWORD IP = (*itIP).first;
  1002. PLAYERSMAP& rPlayers = (*itIP).second;
  1004. MANLIST mans;
  1006. for (PLAYERSMAP::iterator itPlayer = rPlayers.begin(); itPlayer != rPlayers.end(); itPlayer++)
  1007. {
  1008. DWORD param = (*itPlayer).first;
  1009. PLAYERINFO& rInfo = (*itPlayer).second;
  1011. if (rInfo.subed)
  1012. {
  1013. tagPlusSrcInfo friendInfo;
  1014. friendInfo.nameid = rInfo.nameid;
  1015. friendInfo.lnID = param;
  1017. mans.push_back(friendInfo);
  1018. }
  1019. }
  1021. if (!mans.empty())
  1022. {
  1023. PassToGroupMan(IP, FALSE, mans, pCccSync, syncsize);
  1024. }
  1026. }
  1028. sent = TRUE;
  1029. }
  1030. }
  1033. // {{
  1034. // size_t _exsize = sizeof(DWORD) + sizeof(BYTE) + pChannelChatCmd->sentlen; ////X
  1035. // size_t feedbacksize = sizeof(CHAT_FEEDBACK) + _exsize;
  1036. // CHAT_FEEDBACK* pCfb = (CHAT_FEEDBACK*)_alloca(feedbacksize);
  1037. // pCfb->ProtocolType = chat_feedback;
  1038. // pCfb->packageID = pChannelChatCmd->packageID;
  1039. // pCfb->code = sent ? codeSucc : codeFail;
  1040. //
  1041. // ////X
  1042. // DWORD* pChannelid = (DWORD*)(pCfb + 1);
  1043. // *pChannelid = pChannelChatCmd->channelid;
  1044. // BYTE* pSentlen = (BYTE*)(pChannelid + 1);
  1045. // *pSentlen = pChannelChatCmd->sentlen;
  1046. // void* pSent = pSentlen + 1;
  1047. // memcpy(pSent, pChannelChatCmd + 1, pChannelChatCmd->sentlen);
  1048. // ////X
  1049. //
  1050. // PassToSpecMan(srcIP, SrcInfo.lnID, SrcInfo.nameid, pCfb, feedbacksize);
  1051. // }}
  1054. // dTRACE("Chat Channel: sentence %u Bs from [%s] on <%08X>", pChannelChatCmd->sentlen, srcrole.c_str(), pChannelChatCmd->channelid);
  1057. return TRUE;
  1058. }
  1060. BOOL CChannelMgr::IsNeedRelegate(const std::_tstring& channname, BOOL filter)
  1061. {
  1062. if (channname[0] != m_chChannEsc)
  1063. return FALSE;
  1064. if (channname[1] == m_chChannSCRN)
  1065. return TRUE;
  1066. return !filter;
  1067. }
  1071. BOOL CChannelMgr::QueryChannelID(const std::_tstring& channel, DWORD ip, unsigned long param, DWORD nameid)
  1072. {
  1073. assert(FALSE);
  1074. return FALSE;
  1076. BLOCKCHANNELOP_QID* pOp = m_allcQID.allocate(1, NULL);
  1077. pOp->opr = _BLOCKCHANNELOP::op_querychannelid;
  1078. pOp->param = param;
  1079. pOp->channelname = channel;
  1080. pOp->nameid = nameid;
  1082. DUMMY_AUTOLOCKWRITE(m_lockBlockOp);
  1083. BLOCKOPLIST& rOps = m_mapIp2Ops[ip];
  1084. rOps.push_back(pOp);
  1086. return TRUE;
  1087. }
  1089. BOOL CChannelMgr::Subscribe(DWORD ip, unsigned long param, DWORD channelid)
  1090. {
  1091. assert(FALSE);
  1092. return FALSE;
  1094. BLOCKCHANNELOP_CMN* pOp = m_allcCMN.allocate(1, NULL);
  1095. pOp->opr = _BLOCKCHANNELOP::op_subscribe;
  1096. pOp->param = param;
  1097. pOp->channelid = channelid;
  1099. DUMMY_AUTOLOCKWRITE(m_lockBlockOp);
  1100. BLOCKOPLIST& rOps = m_mapIp2Ops[ip];
  1101. rOps.push_back(pOp);
  1103. return TRUE;
  1104. }
  1106. BOOL CChannelMgr::Unsubscribe(DWORD ip, unsigned long param, DWORD channelid)
  1107. {
  1108. assert(FALSE);
  1109. return FALSE;
  1111. BLOCKCHANNELOP_CMN* pOp = m_allcCMN.allocate(1, NULL);
  1112. pOp->opr = _BLOCKCHANNELOP::op_unsubscribe;
  1113. pOp->param = param;
  1114. pOp->channelid = channelid;
  1116. DUMMY_AUTOLOCKWRITE(m_lockBlockOp);
  1117. BLOCKOPLIST& rOps = m_mapIp2Ops[ip];
  1118. rOps.push_back(pOp);
  1120. return TRUE;
  1121. }
  1123. BOOL CChannelMgr::FreeChannID(DWORD channid, DWORD ip, unsigned long param)
  1124. {
  1125. assert(FALSE);
  1126. return FALSE;
  1128. BLOCKCHANNELOP_CMN* pOp = m_allcCMN.allocate(1, NULL);
  1129. pOp->opr = _BLOCKCHANNELOP::op_freechannelid;
  1130. pOp->param = param;
  1131. pOp->channelid = channid;
  1133. DUMMY_AUTOLOCKWRITE(m_lockBlockOp);
  1134. BLOCKOPLIST& rOps = m_mapIp2Ops[ip];
  1135. rOps.push_back(pOp);
  1137. return TRUE;
  1138. }
  1140. BOOL CChannelMgr::ClearPlayer(DWORD ip, unsigned long param)
  1141. {
  1142. assert(FALSE);
  1143. return FALSE;
  1145. BLOCKCHANNELOP_CLR* pOp = m_allcCLR.allocate(1, NULL);
  1146. pOp->opr = _BLOCKCHANNELOP::op_clearplayer;
  1147. pOp->param = param;
  1149. DUMMY_AUTOLOCKWRITE(m_lockBlockOp);
  1150. BLOCKOPLIST& rOps = m_mapIp2Ops[ip];
  1151. rOps.push_back(pOp);
  1153. return TRUE;
  1154. }
  1156. DWORD CChannelMgr::DoBlockOp(DWORD lmt)
  1157. {
  1158. assert(FALSE);
  1159. return FALSE;
  1161. DUMMY_AUTOLOCKWRITE(m_lockBlockOp);
  1163. for (IP2OPSMAP::iterator itIP = m_mapIp2Ops.begin(); itIP != m_mapIp2Ops.end(); itIP++)
  1164. {
  1165. DWORD ip = (*itIP).first;
  1166. BLOCKOPLIST& rOps = (*itIP).second;
  1168. for (BLOCKOPLIST::iterator itOp = rOps.begin(); itOp != rOps.end(); itOp++)
  1169. {
  1170. _BLOCKCHANNELOP* pOp = *itOp;
  1171. assert(pOp);
  1173. switch (pOp->opr)
  1174. {
  1175. case _BLOCKCHANNELOP::op_querychannelid:
  1176. {{
  1177. BLOCKCHANNELOP_QID* pTheOp = (BLOCKCHANNELOP_QID*)pOp;
  1179. Block_QueryChannelID(pTheOp->channelname, ip, pTheOp->param, pTheOp->nameid);
  1181. m_allcQID.deallocate(pTheOp, 1);
  1182. }}
  1183. break;
  1184. case _BLOCKCHANNELOP::op_subscribe:
  1185. {{
  1186. BLOCKCHANNELOP_CMN* pTheOp = (BLOCKCHANNELOP_CMN*)pOp;
  1188. Block_Subscribe(ip, pTheOp->param, pTheOp->channelid);
  1190. m_allcCMN.deallocate(pTheOp, 1);
  1191. }}
  1192. break;
  1193. case _BLOCKCHANNELOP::op_unsubscribe:
  1194. {{
  1195. BLOCKCHANNELOP_CMN* pTheOp = (BLOCKCHANNELOP_CMN*)pOp;
  1197. Block_Unsubscribe(ip, pTheOp->param, pTheOp->channelid);
  1199. m_allcCMN.deallocate(pTheOp, 1);
  1200. }}
  1201. break;
  1202. case _BLOCKCHANNELOP::op_freechannelid:
  1203. {{
  1204. BLOCKCHANNELOP_CMN* pTheOp = (BLOCKCHANNELOP_CMN*)pOp;
  1206. Block_FreeChannID(ip, pTheOp->param, pTheOp->channelid);
  1208. m_allcCMN.deallocate(pTheOp, 1);
  1209. }}
  1210. break;
  1211. case _BLOCKCHANNELOP::op_clearplayer:
  1212. {{
  1213. BLOCKCHANNELOP_CLR* pTheOp = (BLOCKCHANNELOP_CLR*)pOp;
  1215. Block_ClearPlayer(ip, pTheOp->param);
  1217. m_allcCLR.deallocate(pTheOp, 1);
  1218. }}
  1219. break;
  1220. default:
  1221. assert(FALSE);
  1222. }
  1223. }
  1224. }
  1226. m_mapIp2Ops.clear();
  1228. return 0;
  1229. }
  1232. BOOL CChannelMgr::Block_QueryChannelID(const std::_tstring& channel, DWORD ip, unsigned long param, DWORD nameid)
  1233. {
  1234. std::_tstring channname = MakeChannelName(channel, ip);
  1235. if (channname.empty())
  1236. return FALSE;
  1238. CNetConnectDup conndup;
  1239. std::_tstring rolename;
  1240. if (!g_HostServer.FindPlayerByIpParam(NULL, ip, param, &conndup, NULL, &rolename, NULL))
  1241. return FALSE;
  1245. DUMMY_AUTOLOCKWRITE(m_lockChannel);
  1248. DWORD channid = -1;
  1249. BYTE cost = 0;
  1250. IP2PLAYERSMAP* pMapI2P = NULL;
  1253. dTRACE("Query ChannelID: %s from (%08X, %08X)", channel.c_str(), ip, param);
  1256. CHANN2IDMAP::iterator it = m_mapChann2ID.find(channname);
  1257. if (it != m_mapChann2ID.end())
  1258. {//channel exist
  1259. channid = (*it).second;
  1261. CHANNINFO& rChannInfo = m_mapChannid2Info[channid];
  1263. cost = rChannInfo.cost;
  1264. if (channid != m_channidGM)
  1265. pMapI2P = &rChannInfo.mapIp2Players;
  1266. }
  1267. else
  1268. {
  1269. if (channname[0] != m_chChannEsc)
  1270. return FALSE;
  1272. //create the channel
  1273. channid = GenChannID();
  1274. if (channid != DWORD(-1))
  1275. {
  1276. m_mapChann2ID[channname] = channid;
  1278. CHANNINFO& rChannInfo = m_mapChannid2Info[channid];
  1279. rChannInfo.god = FALSE;
  1280. rChannInfo.stock = FALSE;
  1281. rChannInfo.channname = channname;
  1282. rChannInfo.gmuse = FALSE;
  1283. rChannInfo.gmsub = FALSE;
  1284. rChannInfo.cost = GainPreCost(channel);
  1286. rTRACE("Create Channel: <%08X> %s", channid, channname.c_str());
  1288. cost = rChannInfo.cost;
  1289. pMapI2P = &rChannInfo.mapIp2Players;
  1290. }
  1291. }
  1293. if (channid != DWORD(-1))
  1294. {
  1295. if (pMapI2P)
  1296. {
  1297. PLAYERSMAP& rPlayers = (*pMapI2P)[ip];
  1298. PLAYERINFO& rInfo = rPlayers[param];
  1299. rInfo.nameid = nameid;
  1300. rInfo.subed = FALSE;
  1301. }
  1302. }
  1305. {{
  1306. //notify channelid
  1307. size_t methodsize = _NAME_LEN + sizeof(DWORD) * 2;
  1308. size_t pckgsize = sizeof(RELAY_ASKWAY_DATA) + methodsize + sizeof(PLAYERCOMM_NOTIFYCHANNELID);
  1310. RELAY_ASKWAY_DATA* pAskWayData = (RELAY_ASKWAY_DATA*)_alloca(pckgsize);
  1311. pAskWayData->ProtocolFamily = pf_relay;
  1312. pAskWayData->ProtocolID = relay_c2c_askwaydata;
  1313. pAskWayData->nFromIP = 0;
  1314. pAskWayData->nFromRelayID = 0;
  1315. pAskWayData->seekRelayCount = 0;
  1316. pAskWayData->seekMethod = rm_role_id;
  1317. pAskWayData->wMethodDataLength = methodsize;
  1318. pAskWayData->routeDateLength = sizeof(PLAYERCOMM_NOTIFYCHANNELID);
  1320. char* pRoleName = (char*)(pAskWayData + 1);
  1321. strcpy(pRoleName, rolename.c_str());
  1323. DWORD* pRoleInfo = (DWORD*)(pRoleName + _NAME_LEN);
  1324. pRoleInfo[0] = nameid;
  1325. pRoleInfo[1] = param;
  1327. PLAYERCOMM_NOTIFYCHANNELID* pPlayerCommNID = (PLAYERCOMM_NOTIFYCHANNELID*)(pRoleInfo + 2);
  1328. pPlayerCommNID->ProtocolFamily = pf_playercommunity;
  1329. pPlayerCommNID->ProtocolID = playercomm_s2c_notifychannelid;
  1330. strcpy(pPlayerCommNID->channel, channel.c_str());
  1331. pPlayerCommNID->channelid = channid;
  1332. pPlayerCommNID->cost = cost;
  1334. conndup.SendPackage(pAskWayData, pckgsize);
  1335. }}
  1338. return TRUE;
  1339. }
  1341. BOOL CChannelMgr::Block_Subscribe(DWORD ip, unsigned long param, DWORD channelid)
  1342. {
  1343. if (channelid == -1)
  1344. return FALSE;
  1346. if (channelid == m_channidGM)
  1347. {
  1348. dTRACE("Subscribe Channel: GM <%08X> by (%08X,%08X)", channelid, ip, param);
  1349. return TRUE;
  1350. }
  1352. DUMMY_AUTOLOCKWRITE(m_lockChannel);
  1354. CHANNID2INFOMAP::iterator it = m_mapChannid2Info.find(channelid);
  1355. if (it == m_mapChannid2Info.end())
  1356. return FALSE;
  1358. CHANNINFO& rChannInfo = (*it).second;
  1359. PLAYERSMAP& rPlayers = rChannInfo.mapIp2Players[ip];
  1360. PLAYERSMAP::iterator itRole = rPlayers.find(param);
  1361. if (itRole == rPlayers.end())
  1362. return FALSE;
  1364. PLAYERINFO& rPlayerInfo = (*itRole).second;
  1365. rPlayerInfo.subed = TRUE;
  1367. dTRACE("Subscribe Channel: %08X by (%08X,%08X)", channelid, ip, param);
  1369. return TRUE;
  1370. }
  1372. BOOL CChannelMgr::Block_Unsubscribe(DWORD ip, unsigned long param, DWORD channelid)
  1373. {
  1374. if (channelid == m_channidGM)
  1375. return FALSE;
  1378. DUMMY_AUTOLOCKWRITE(m_lockChannel);
  1380. CHANNID2INFOMAP::iterator itChannid = m_mapChannid2Info.find(channelid);
  1381. if (itChannid == m_mapChannid2Info.end())
  1382. return FALSE;
  1384. CHANNINFO& rChannInfo = (*itChannid).second;
  1386. IP2PLAYERSMAP::iterator itPlayers = rChannInfo.mapIp2Players.find(ip);
  1387. if (itPlayers == rChannInfo.mapIp2Players.end())
  1388. return FALSE;
  1390. PLAYERSMAP& rPlayers = (*itPlayers).second;
  1391. PLAYERSMAP::iterator itRole = rPlayers.find(param);
  1392. if (itRole == rPlayers.end())
  1393. return FALSE;
  1395. PLAYERINFO& rInfo = (*itRole).second;
  1396. rInfo.subed = FALSE;
  1398. dTRACE("Unsubscribe Channel: %08X by (%08X,%08X)", channelid, ip, param);
  1400. return TRUE;
  1401. }
  1403. BOOL CChannelMgr::Block_FreeChannID(DWORD channid, DWORD ip, unsigned long param)
  1404. {
  1405. if (channid == -1)
  1406. return FALSE;
  1408. dTRACE("Free ChannelID: <%08X> from (%08X, %08X)", channid, ip, param);
  1411. DUMMY_AUTOLOCKWRITE(m_lockChannel);
  1413. if (channid == m_channidGM)
  1414. return TRUE;
  1417. CHANNID2INFOMAP::iterator it = m_mapChannid2Info.find(channid);
  1418. if (it == m_mapChannid2Info.end())
  1419. return FALSE;
  1421. CHANNINFO& rChannInfo = (*it).second;
  1423. if (rChannInfo.god)
  1424. return TRUE;
  1426. IP2PLAYERSMAP::iterator itPlayers = rChannInfo.mapIp2Players.find(ip);
  1427. if (itPlayers == rChannInfo.mapIp2Players.end())
  1428. return FALSE;
  1430. PLAYERSMAP& rPlayers = (*itPlayers).second;
  1431. rPlayers.erase(param);
  1432. if (rPlayers.empty())
  1433. {
  1434. rChannInfo.mapIp2Players.erase(itPlayers);
  1436. if (!rChannInfo.stock && !rChannInfo.gmuse
  1437. && rChannInfo.mapIp2Players.empty())
  1438. {
  1439. rTRACE("Destroy Channel: <%08X> %s", channid, rChannInfo.channname.c_str());
  1441. m_mapChann2ID.erase(rChannInfo.channname);
  1442. m_mapChannid2Info.erase(it);
  1443. }
  1444. }
  1447. return TRUE;
  1448. }
  1450. BOOL CChannelMgr::Block_ClearPlayer(DWORD ip, unsigned long param)
  1451. {
  1452. DUMMY_AUTOLOCKWRITE(m_lockChannel);
  1454. CHANNID2INFOMAP::iterator itChann = m_mapChannid2Info.begin();
  1455. while (itChann != m_mapChannid2Info.end())
  1456. {
  1457. CHANNID2INFOMAP::iterator itChannMe = itChann++;
  1458. DWORD channid = (*itChannMe).first;
  1459. CHANNINFO& rChannInfo = (*itChannMe).second;
  1461. if (channid == m_channidGM)
  1462. continue;
  1464. IP2PLAYERSMAP::iterator itIP = rChannInfo.mapIp2Players.find(ip);
  1465. if (itIP == rChannInfo.mapIp2Players.end()) //没找到此GS
  1466. continue;
  1468. IP2PLAYERSMAP::iterator itIPMe = itIP++;
  1469. PLAYERSMAP& rPlayers = (*itIPMe).second;
  1471. //删除此人
  1472. rPlayers.erase(param);
  1474. if (!rPlayers.empty()) //此GS上还有人
  1475. continue;
  1477. //GS上无人，删除此GS
  1478. rChannInfo.mapIp2Players.erase(itIPMe);
  1480. if (rChannInfo.stock || rChannInfo.gmuse) //频道不可删
  1481. continue;
  1483. if (!rChannInfo.mapIp2Players.empty()) //如果此频道还有GS
  1484. continue;
  1486. rTRACE("Destroy Channel: <%08X> %s", channid, rChannInfo.channname.c_str());
  1488. //删除频道
  1489. m_mapChann2ID.erase(rChannInfo.channname);
  1490. m_mapChannid2Info.erase(itChannMe);
  1491. }
  1493. return TRUE;
  1494. }
  1496. BOOL CChannelMgr::B_QueryChannelID(const std::_tstring& channel, DWORD ip, unsigned long param, DWORD nameid)
  1497. {
  1498. return Block_QueryChannelID(channel, ip, param, nameid);
  1499. }
  1501. BOOL CChannelMgr::B_Subscribe(DWORD ip, unsigned long param, DWORD channelid)
  1502. {
  1503. return Block_Subscribe(ip, param, channelid);
  1504. }
  1506. BOOL CChannelMgr::B_Unsubscribe(DWORD ip, unsigned long param, DWORD channelid)
  1507. {
  1508. return Block_Unsubscribe(ip, param, channelid);
  1509. }
  1511. BOOL CChannelMgr::B_FreeChannID(DWORD channid, DWORD ip, unsigned long param)
  1512. {
  1513. return Block_FreeChannID(channid, ip, param);
  1514. }
  1516. BOOL CChannelMgr::B_ClearPlayer(DWORD ip, unsigned long param)
  1517. {
  1518. return Block_ClearPlayer(ip, param);
  1519. }
  1522. size_t CChannelMgr::GetChannelCount()
  1523. {
  1524. DUMMY_AUTOLOCKWRITE(m_lockChannel);
  1526. return m_mapChannid2Info.size();
  1527. }
  1530. BOOL CChannelMgr::SayOnSomeone(DWORD ip, unsigned long param, DWORD nameid, const std::_tstring& name, const std::_tstring& sent)
  1531. {
  1532. CNetConnectDup hostconndup;
  1533. if (!g_HostServer.FindPlayerByIpParam(NULL, ip, param, &hostconndup, NULL, NULL, NULL))
  1534. return FALSE;
  1536. size_t syncsize = sizeof(CHAT_SOMEONECHAT_SYNC) + sent.size();
  1537. CHAT_SOMEONECHAT_SYNC* pCscSync = (CHAT_SOMEONECHAT_SYNC*)_alloca(syncsize);
  1538. pCscSync->ProtocolType = chat_someonechat;
  1539. pCscSync->wSize = syncsize - 1;
  1540. pCscSync->packageID = -1;
  1541. strcpy(pCscSync->someone, name.c_str());
  1542. pCscSync->sentlen = sent.size();
  1543. memcpy(pCscSync + 1, sent.data(), sent.size());
  1545. if (!PassToSpecMan(hostconndup.GetIP(), param, nameid, pCscSync, syncsize))
  1546. return FALSE;
  1548. return TRUE;
  1549. }
  1551. BOOL CChannelMgr::SayOnChannel(DWORD channid, BOOL filter, const std::_tstring& ids, const std::_tstring& name, const std::_tstring& sent)
  1552. {
  1553. DUMMY_AUTOLOCKREAD(m_lockChannel);
  1556. CHANNID2INFOMAP::iterator itChannid = m_mapChannid2Info.find(channid);
  1557. if (itChannid == m_mapChannid2Info.end())
  1558. return FALSE;
  1560. CHANNINFO& rChannInfo = (*itChannid).second;
  1562. if (rChannInfo.god)
  1563. {
  1564. if (!g_RootClient.IsReady())
  1565. return FALSE;
  1567. size_t pckgsize = sizeof(CHAT_MSG_EX) + sent.size();
  1568. CHAT_MSG_EX* pChatMsgEx = (CHAT_MSG_EX*)_alloca(pckgsize);
  1569. pChatMsgEx->ProtocolFamily = pf_playercommunity;
  1570. pChatMsgEx->ProtocolID = playercomm_channelchat;
  1571. strcpy(pChatMsgEx->m_szSourceName, name.c_str());
  1572. strcpy(pChatMsgEx->m_szAccountName, ids.c_str());
  1573. pChatMsgEx->SentenceLength = sent.size();
  1574. memcpy(pChatMsgEx + 1, sent.data(), sent.size());
  1576. PassToGM(pChatMsgEx, pckgsize);
  1577. }
  1578. else
  1579. {
  1580. if (IsNeedRelegate(rChannInfo.channname, filter))
  1581. {//relegate to gamesvr
  1582. assert(rChannInfo.channname[0] == m_chChannEsc);
  1584. DWORD channIP = 0;
  1585. DWORD theID = ParseChannelName(rChannInfo.channname, &channIP);
  1586. if (theID == -1 && channIP == 0)
  1587. return FALSE;
  1590. assert(rChannInfo.channname.size() >= 2);
  1593. size_t syncsize = sizeof(CHAT_CHANNELCHAT_SYNC) + sent.size();
  1594. size_t pckgsize = sizeof(CHAT_RELEGATE) + syncsize;
  1596. CHAT_RELEGATE* pCr = (CHAT_RELEGATE*)_alloca(pckgsize);
  1597. pCr->ProtocolType = chat_relegate;
  1598. pCr->wSize = pckgsize - 1;
  1599. pCr->nFromIP = 0;
  1600. pCr->nFromRelayID = -1;
  1601. pCr->channelid = channid;
  1602. pCr->routeDateLength = syncsize;
  1604. CHAT_CHANNELCHAT_SYNC* pCccSync = (CHAT_CHANNELCHAT_SYNC*)(pCr + 1);
  1605. pCccSync->ProtocolType = chat_channelchat;
  1606. pCccSync->wSize = syncsize - 1;
  1607. pCccSync->packageID = -1;
  1608. strcpy(pCccSync->someone, name.c_str());
  1609. pCccSync->channelid = channid;
  1610. pCccSync->sentlen = sent.size();
  1611. memcpy(pCccSync + 1, sent.data(), sent.size());
  1614. if (rChannInfo.channname[1] == m_chChannTEAM)
  1615. {
  1616. if (theID == -1 || channIP == 0)
  1617. return FALSE;
  1619. CHANNINFO& rChannInfo = (*itChannid).second;
  1621. CNetConnectDup connDup = g_ChatServer.FindChatConnectByIP(channIP);
  1622. if (!connDup.IsValid())
  1623. return FALSE;
  1625. pCr->TargetCls = tgtcls_team;
  1626. pCr->TargetID = theID;
  1628. connDup.SendPackage(pCr, pckgsize);
  1629. }
  1630. else if (rChannInfo.channname[1] == m_chChannFAC)
  1631. {
  1632. if (theID == -1)
  1633. return FALSE;
  1635. pCr->TargetCls = tgtcls_fac;
  1636. pCr->TargetID = theID;
  1638. g_ChatServer.BroadPackage(pCr, pckgsize);
  1639. }
  1640. else if (rChannInfo.channname[1] == m_chChannTONG)
  1641. {
  1642. if (theID == -1)
  1643. return FALSE;
  1645. pCr->TargetCls = tgtcls_tong;
  1646. pCr->TargetID = theID;
  1648. g_ChatServer.BroadPackage(pCr, pckgsize);
  1649. }
  1650. else if (rChannInfo.channname[1] == m_chChannSCRN)
  1651. {
  1652. //screen
  1653. assert(FALSE);
  1654. return FALSE;
  1655. }
  1656. else if (rChannInfo.channname[1] == m_chChannBC)
  1657. {
  1658. if (channIP == 0)
  1659. return FALSE;
  1661. assert(channIP != 0 && theID == 0);
  1663. CNetConnectDup connDup = g_ChatServer.FindChatConnectByIP(channIP);
  1664. if (!connDup.IsValid())
  1665. return FALSE;
  1667. pCr->TargetCls = tgtcls_bc;
  1668. pCr->TargetID = 0;
  1670. connDup.SendPackage(pCr, pckgsize);
  1671. }
  1672. else
  1673. {
  1674. assert(FALSE);
  1675. return FALSE;
  1676. }
  1677. }
  1678. else
  1679. {//broad on channel
  1680. //== PassToPlayer
  1681. //do like this for optimize
  1683. size_t syncsize = sizeof(CHAT_CHANNELCHAT_SYNC) + sent.size();
  1684. CHAT_CHANNELCHAT_SYNC* pCccSync = (CHAT_CHANNELCHAT_SYNC*)_alloca(syncsize);
  1685. pCccSync->ProtocolType = chat_channelchat;
  1686. pCccSync->wSize = syncsize - 1;
  1687. pCccSync->packageID = -1;
  1688. strcpy(pCccSync->someone, name.c_str());
  1689. pCccSync->channelid = channid;
  1690. pCccSync->sentlen = sent.size();
  1691. memcpy(pCccSync + 1, sent.data(), sent.size());
  1694. for (IP2PLAYERSMAP::iterator itIP = rChannInfo.mapIp2Players.begin(); itIP != rChannInfo.mapIp2Players.end(); itIP++)
  1695. {
  1696. DWORD IP = (*itIP).first;
  1697. PLAYERSMAP& rPlayers = (*itIP).second;
  1699. MANLIST mans;
  1701. for (PLAYERSMAP::iterator itPlayer = rPlayers.begin(); itPlayer != rPlayers.end(); itPlayer++)
  1702. {
  1703. DWORD param = (*itPlayer).first;
  1704. PLAYERINFO& rInfo = (*itPlayer).second;
  1706. if (rInfo.subed)
  1707. {
  1708. tagPlusSrcInfo friendInfo;
  1709. friendInfo.nameid = rInfo.nameid;
  1710. friendInfo.lnID = param;
  1712. mans.push_back(friendInfo);
  1713. }
  1714. }
  1716. if (!mans.empty())
  1717. {
  1718. PassToGroupMan(IP, FALSE, mans, pCccSync, syncsize);
  1719. }
  1720. }
  1721. }
  1722. }
  1725. return TRUE;
  1726. }