API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Oct 12th, 2018
144
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 25.58 KB | None | 0 0
raw download clone embed print report
  1. #include "StdAfx.h"
  2. #include "PythonChat.h"
  3.  
  4. #include "AbstractApplication.h"
  5. #include "PythonCharacterManager.h"
  6. #include "../eterbase/Timer.h"
  7.  
  8. int CPythonChat::TChatSet::ms_iChatModeSize = CHAT_TYPE_MAX_NUM;
  9.  
  10. const float c_fStartDisappearingTime = 5.0f;
  11. const int c_iMaxLineCount = 5;
  12.  
  13. ///////////////////////////////////////////////////////////////////////////////////////////////////
  14.  
  15. CDynamicPool<CPythonChat::SChatLine> CPythonChat::SChatLine::ms_kPool;
  16.  
  17. void CPythonChat::SetChatColor(UINT eType, UINT r, UINT g, UINT b)
  18. {
  19. if (eType>=CHAT_TYPE_MAX_NUM)
  20. return;
  21.  
  22. DWORD dwColor=(0xff000000)|(r<<16)|(g<<8)|(b);
  23. m_akD3DXClrChat[eType]=D3DXCOLOR(dwColor);
  24. }
  25.  
  26. ///////////////////////////////////////////////////////////////////////////////////////////////////
  27.  
  28. CPythonChat::SChatLine* CPythonChat::SChatLine::New()
  29. {
  30. return ms_kPool.Alloc();
  31. }
  32.  
  33. void CPythonChat::SChatLine::Delete(CPythonChat::SChatLine* pkChatLine)
  34. {
  35. pkChatLine->Instance.Destroy();
  36. #ifdef ENABLE_LANG_AND_EMPIRE_FLAG
  37. pkChatLine->InstanceLang.Destroy();
  38. pkChatLine->InstanceEmpire.Destroy();
  39. #endif
  40. ms_kPool.Free(pkChatLine);
  41. }
  42.  
  43. void CPythonChat::SChatLine::DestroySystem()
  44. {
  45. ms_kPool.Destroy();
  46. }
  47.  
  48. void CPythonChat::SChatLine::SetColor(DWORD dwID, DWORD dwColor)
  49. {
  50. assert(dwID < CHAT_LINE_COLOR_ARRAY_MAX_NUM);
  51.  
  52. if (dwID >= CHAT_LINE_COLOR_ARRAY_MAX_NUM)
  53. return;
  54.  
  55. aColor[dwID] = dwColor;
  56. }
  57.  
  58. void CPythonChat::SChatLine::SetColorAll(DWORD dwColor)
  59. {
  60. for (int i = 0; i < CHAT_LINE_COLOR_ARRAY_MAX_NUM; ++i)
  61. aColor[i] = dwColor;
  62. }
  63.  
  64. D3DXCOLOR & CPythonChat::SChatLine::GetColorRef(DWORD dwID)
  65. {
  66. assert(dwID < CHAT_LINE_COLOR_ARRAY_MAX_NUM);
  67.  
  68. if (dwID >= CHAT_LINE_COLOR_ARRAY_MAX_NUM)
  69. {
  70. static D3DXCOLOR color(1.0f, 0.0f, 0.0f, 1.0f);
  71. return color;
  72. }
  73.  
  74. return aColor[dwID];
  75. }
  76.  
  77. CPythonChat::SChatLine::SChatLine()
  78. {
  79. for (int i = 0; i < CHAT_LINE_COLOR_ARRAY_MAX_NUM; ++i)
  80. aColor[i] = 0xff0000ff;
  81. }
  82. CPythonChat::SChatLine::~SChatLine()
  83. {
  84. Instance.Destroy();
  85. #ifdef ENABLE_LANG_AND_EMPIRE_FLAG
  86. InstanceLang.Destroy();
  87. InstanceEmpire.Destroy();
  88. #endif
  89. }
  90.  
  91. ///////////////////////////////////////////////////////////////////////////////////////////////////
  92.  
  93. int CPythonChat::CreateChatSet(DWORD dwID)
  94. {
  95. m_ChatSetMap.insert(make_pair(dwID, TChatSet()));
  96. return dwID;
  97. }
  98.  
  99. void CPythonChat::UpdateViewMode(DWORD dwID)
  100. {
  101. IAbstractApplication& rApp=IAbstractApplication::GetSingleton();
  102.  
  103. float fcurTime = rApp.GetGlobalTime();
  104. //float felapsedTime = rApp.GetGlobalElapsedTime();
  105.  
  106. TChatSet * pChatSet = GetChatSetPtr(dwID);
  107. if (!pChatSet)
  108. return;
  109.  
  110. TChatLineList * pLineList = &(pChatSet->m_ShowingChatLineList);
  111. int iLineIndex = pLineList->size();
  112. int iHeight = -(int(pLineList->size()+1) * pChatSet->m_iStep);
  113.  
  114. TChatLineList::iterator itor;
  115. for (itor = pLineList->begin(); itor != pLineList->end();)
  116. {
  117. TChatLine * pChatLine = (*itor);
  118.  
  119. D3DXCOLOR & rColor = pChatLine->GetColorRef(dwID);
  120.  
  121. float fElapsedTime = (fcurTime - pChatLine->fAppendedTime);
  122. if (fElapsedTime >= c_fStartDisappearingTime || iLineIndex >= c_iMaxLineCount)
  123. {
  124. rColor.a -= rColor.a / 10.0f;
  125.  
  126. if (rColor.a <= 0.1f)
  127. {
  128. itor = pLineList->erase(itor);
  129. }
  130. else
  131. {
  132. ++itor;
  133. }
  134. }
  135. else
  136. {
  137. ++itor;
  138. }
  139.  
  140. /////
  141.  
  142. iHeight += pChatSet->m_iStep;
  143. --iLineIndex;
  144. #ifdef ENABLE_LANG_AND_EMPIRE_FLAG
  145. int iWidth = pChatSet->m_ix;
  146. bool isAttached = (pChatLine->InstanceLang.GetWidth() > 0 && pChatLine->InstanceEmpire.GetWidth() > 0);
  147.  
  148. if (isAttached)
  149. {
  150. pChatLine->InstanceLang.SetPosition(iWidth, pChatSet->m_iy + iHeight + 2);
  151. iWidth += pChatLine->InstanceLang.GetWidth() + 2;
  152.  
  153. pChatLine->InstanceEmpire.SetPosition(iWidth + 4, pChatSet->m_iy + iHeight + 2);
  154. iWidth += pChatLine->InstanceEmpire.GetWidth() + 8;
  155. }
  156. #endif
  157.  
  158. #ifdef ENABLE_LANG_AND_EMPIRE_FLAG
  159. pChatLine->Instance.SetPosition(iWidth, pChatSet->m_iy + iHeight);
  160. #else
  161. pChatLine->Instance.SetPosition(pChatSet->m_ix, pChatSet->m_iy + iHeight);
  162. #endif
  163. pChatLine->Instance.SetColor(rColor);
  164. pChatLine->Instance.Update();
  165. if(pChatLine->ImageInstance)
  166. pChatLine->ImageInstance->SetPosition(pChatSet->m_ix, pChatSet->m_iy + iHeight + 2);
  167. }
  168. }
  169.  
  170. void CPythonChat::UpdateEditMode(DWORD dwID)
  171. {
  172. TChatSet * pChatSet = GetChatSetPtr(dwID);
  173. if (!pChatSet)
  174. return;
  175.  
  176. const int c_iAlphaLine = max(0, GetVisibleLineCount(dwID) - GetEditableLineCount(dwID) + 2);
  177.  
  178. int iLineIndex = 0;
  179. float fAlpha = 0.0f;
  180. float fAlphaStep = 0.0f;
  181.  
  182. if (c_iAlphaLine > 0)
  183. fAlphaStep = 1.0f / float(c_iAlphaLine);
  184.  
  185. TChatLineList * pLineList = &(pChatSet->m_ShowingChatLineList);
  186. int iHeight = -(int(pLineList->size()+1) * pChatSet->m_iStep);
  187.  
  188. for (TChatLineList::iterator itor = pLineList->begin(); itor != pLineList->end(); ++itor)
  189. {
  190. TChatLine * pChatLine = (*itor);
  191.  
  192. D3DXCOLOR & rColor = pChatLine->GetColorRef(dwID);
  193.  
  194. if (iLineIndex < c_iAlphaLine)
  195. {
  196. rColor.a += (fAlpha - rColor.a) / 10.0f;
  197. fAlpha = fMIN(fAlpha+fAlphaStep, 1.0f);
  198. }
  199. else
  200. {
  201. rColor.a = fMIN(rColor.a+0.05f, 1.0f);
  202. }
  203.  
  204. iHeight += pChatSet->m_iStep;
  205. #ifdef ENABLE_LANG_AND_EMPIRE_FLAG
  206. int iWidth = pChatSet->m_ix;
  207. bool isAttached = (pChatLine->InstanceLang.GetWidth() > 0 && pChatLine->InstanceEmpire.GetWidth() > 0);
  208.  
  209. if (isAttached)
  210. {
  211. pChatLine->InstanceLang.SetPosition(iWidth, pChatSet->m_iy + iHeight + 2);
  212. iWidth += pChatLine->InstanceLang.GetWidth() + 2;
  213.  
  214. pChatLine->InstanceEmpire.SetPosition(iWidth + 4, pChatSet->m_iy + iHeight + 2);
  215. iWidth += pChatLine->InstanceEmpire.GetWidth() + 8;
  216. }
  217. #endif
  218. #ifdef ENABLE_LANG_AND_EMPIRE_FLAG
  219. pChatLine->Instance.SetPosition(iWidth, pChatSet->m_iy + iHeight);
  220. #else
  221. pChatLine->Instance.SetPosition(pChatSet->m_ix, pChatSet->m_iy + iHeight);
  222. #endif
  223. pChatLine->Instance.SetColor(rColor);
  224. pChatLine->Instance.Update();
  225. if(pChatLine->ImageInstance)
  226. pChatLine->ImageInstance->SetPosition(pChatSet->m_ix, pChatSet->m_iy + iHeight + 2);
  227. }
  228. }
  229.  
  230. void CPythonChat::UpdateLogMode(DWORD dwID)
  231. {
  232. TChatSet * pChatSet = GetChatSetPtr(dwID);
  233. if (!pChatSet)
  234. return;
  235.  
  236. TChatLineList * pLineList = &(pChatSet->m_ShowingChatLineList);
  237. int iHeight = 0;
  238.  
  239. for (TChatLineList::reverse_iterator itor = pLineList->rbegin(); itor != pLineList->rend(); ++itor)
  240. {
  241. TChatLine * pChatLine = (*itor);
  242.  
  243. iHeight -= pChatSet->m_iStep;
  244. #ifdef ENABLE_LANG_AND_EMPIRE_FLAG
  245. int iWidth = pChatSet->m_ix;
  246. bool isAttached = (pChatLine->InstanceLang.GetWidth() > 0 && pChatLine->InstanceEmpire.GetWidth() > 0);
  247.  
  248. if (isAttached)
  249. {
  250. pChatLine->InstanceLang.SetPosition(iWidth, pChatSet->m_iy + iHeight + 2);
  251. iWidth += pChatLine->InstanceLang.GetWidth() + 2;
  252.  
  253. pChatLine->InstanceEmpire.SetPosition(iWidth + 4, pChatSet->m_iy + iHeight + 2);
  254. iWidth += pChatLine->InstanceEmpire.GetWidth() + 8;
  255. }
  256. #endif
  257. #ifdef ENABLE_LANG_AND_EMPIRE_FLAG
  258. pChatLine->Instance.SetPosition(iWidth, pChatSet->m_iy + iHeight);
  259. #else
  260. pChatLine->Instance.SetPosition(pChatSet->m_ix, pChatSet->m_iy + iHeight);
  261. #endif
  262. pChatLine->Instance.SetColor(pChatLine->GetColorRef(dwID));
  263. pChatLine->Instance.Update();
  264. if(pChatLine->ImageInstance)
  265. pChatLine->ImageInstance->SetPosition(pChatSet->m_ix, pChatSet->m_iy + iHeight + 2);
  266. }
  267. }
  268.  
  269. void CPythonChat::Update(DWORD dwID)
  270. {
  271. TChatSet * pChatSet = GetChatSetPtr(dwID);
  272. if (!pChatSet)
  273. return;
  274.  
  275. switch (pChatSet->m_iBoardState)
  276. {
  277. case BOARD_STATE_VIEW:
  278. UpdateViewMode(dwID);
  279. break;
  280. case BOARD_STATE_EDIT:
  281. UpdateEditMode(dwID);
  282. break;
  283. case BOARD_STATE_LOG:
  284. UpdateLogMode(dwID);
  285. break;
  286. }
  287.  
  288. DWORD dwcurTime = CTimer::Instance().GetCurrentMillisecond();
  289. for (TWaitChatList::iterator itor = m_WaitChatList.begin(); itor != m_WaitChatList.end();)
  290. {
  291. TWaitChat & rWaitChat = *itor;
  292.  
  293. if (rWaitChat.dwAppendingTime < dwcurTime)
  294. {
  295. AppendChat(rWaitChat.iType, rWaitChat.strChat.c_str());
  296.  
  297. itor = m_WaitChatList.erase(itor);
  298. }
  299. else
  300. {
  301. ++itor;
  302. }
  303. }
  304. }
  305.  
  306. void CPythonChat::Render(DWORD dwID)
  307. {
  308. TChatLineList * pLineList = GetChatLineListPtr(dwID);
  309. if (!pLineList)
  310. return;
  311.  
  312. for (TChatLineList::iterator itor = pLineList->begin(); itor != pLineList->end(); ++itor)
  313. {
  314. CGraphicTextInstance & rInstance = (*itor)->Instance;
  315. rInstance.Render();
  316. CGraphicImageInstance *& imInstance = (*itor)->ImageInstance;
  317. if (imInstance)
  318. imInstance->Render();
  319. #ifdef ENABLE_LANG_AND_EMPIRE_FLAG
  320. CGraphicImageInstance & lInstance = (*itor)->InstanceLang;
  321. lInstance.Render();
  322.  
  323. CGraphicImageInstance & eInstance = (*itor)->InstanceEmpire;
  324. eInstance.Render();
  325. #endif
  326. }
  327. }
  328.  
  329.  
  330. void CPythonChat::SetBoardState(DWORD dwID, int iState)
  331. {
  332. TChatSet * pChatSet = GetChatSetPtr(dwID);
  333. if (!pChatSet)
  334. return;
  335.  
  336. pChatSet->m_iBoardState = iState;
  337. ArrangeShowingChat(dwID);
  338. }
  339. void CPythonChat::SetPosition(DWORD dwID, int ix, int iy)
  340. {
  341. TChatSet * pChatSet = GetChatSetPtr(dwID);
  342. if (!pChatSet)
  343. return;
  344.  
  345. pChatSet->m_ix = ix;
  346. pChatSet->m_iy = iy;
  347. }
  348. void CPythonChat::SetHeight(DWORD dwID, int iHeight)
  349. {
  350. TChatSet * pChatSet = GetChatSetPtr(dwID);
  351. if (!pChatSet)
  352. return;
  353.  
  354. pChatSet->m_iHeight = iHeight;
  355. }
  356. void CPythonChat::SetStep(DWORD dwID, int iStep)
  357. {
  358. TChatSet * pChatSet = GetChatSetPtr(dwID);
  359. if (!pChatSet)
  360. return;
  361.  
  362. pChatSet->m_iStep = iStep;
  363. }
  364. void CPythonChat::ToggleChatMode(DWORD dwID, int iMode)
  365. {
  366. TChatSet * pChatSet = GetChatSetPtr(dwID);
  367. if (!pChatSet)
  368. return;
  369.  
  370. pChatSet->m_iMode[iMode] = 1 - pChatSet->m_iMode[iMode];
  371. // Tracef("ToggleChatMode : %d\n", iMode);
  372. ArrangeShowingChat(dwID);
  373. }
  374. void CPythonChat::EnableChatMode(DWORD dwID, int iMode)
  375. {
  376. TChatSet * pChatSet = GetChatSetPtr(dwID);
  377. if (!pChatSet)
  378. return;
  379.  
  380. pChatSet->m_iMode[iMode] = TRUE;
  381. // Tracef("EnableChatMode : %d\n", iMode);
  382. ArrangeShowingChat(dwID);
  383. }
  384. void CPythonChat::DisableChatMode(DWORD dwID, int iMode)
  385. {
  386. TChatSet * pChatSet = GetChatSetPtr(dwID);
  387. if (!pChatSet)
  388. return;
  389.  
  390. pChatSet->m_iMode[iMode] = FALSE;
  391. // Tracef("DisableChatMode : %d\n", iMode);
  392. ArrangeShowingChat(dwID);
  393. }
  394. void CPythonChat::SetEndPos(DWORD dwID, float fPos)
  395. {
  396. TChatSet * pChatSet = GetChatSetPtr(dwID);
  397. if (!pChatSet)
  398. return;
  399.  
  400. fPos = max(0.0f, fPos);
  401. fPos = min(1.0f, fPos);
  402. if (pChatSet->m_fEndPos != fPos)
  403. {
  404. pChatSet->m_fEndPos = fPos;
  405. ArrangeShowingChat(dwID);
  406. }
  407. }
  408.  
  409.  
  410. int CPythonChat::GetVisibleLineCount(DWORD dwID)
  411. {
  412. TChatLineList * pLineList = GetChatLineListPtr(dwID);
  413. if (!pLineList)
  414. return 0;
  415.  
  416. return pLineList->size();
  417. }
  418.  
  419. int CPythonChat::GetEditableLineCount(DWORD dwID)
  420. {
  421. TChatSet * pChatSet = GetChatSetPtr(dwID);
  422. if (!pChatSet)
  423. return 0;
  424.  
  425. return pChatSet->m_iHeight / pChatSet->m_iStep + 1;
  426. }
  427.  
  428. int CPythonChat::GetLineCount(DWORD dwID)
  429. {
  430. TChatSet * pChatSet = GetChatSetPtr(dwID);
  431. if (!pChatSet)
  432. return 0;
  433.  
  434. int iCount = 0;
  435. for (DWORD i = 0; i < m_ChatLineDeque.size(); ++i)
  436. {
  437. if (!pChatSet->CheckMode(m_ChatLineDeque[i]->iType))
  438. continue;
  439.  
  440. ++iCount;
  441. }
  442.  
  443. return iCount;
  444. }
  445.  
  446. int CPythonChat::GetLineStep(DWORD dwID)
  447. {
  448. TChatSet * pChatSet = GetChatSetPtr(dwID);
  449. if (!pChatSet)
  450. return 0;
  451.  
  452. return pChatSet->m_iStep;
  453. }
  454.  
  455. CPythonChat::TChatLineList * CPythonChat::GetChatLineListPtr(DWORD dwID)
  456. {
  457. TChatSetMap::iterator itor = m_ChatSetMap.find(dwID);
  458. if (m_ChatSetMap.end() == itor)
  459. return NULL;
  460.  
  461. TChatSet & rChatSet = itor->second;
  462. return &(rChatSet.m_ShowingChatLineList);
  463. }
  464.  
  465. CPythonChat::TChatSet * CPythonChat::GetChatSetPtr(DWORD dwID)
  466. {
  467. TChatSetMap::iterator itor = m_ChatSetMap.find(dwID);
  468. if (m_ChatSetMap.end() == itor)
  469. return NULL;
  470.  
  471. TChatSet & rChatSet = itor->second;
  472. return &rChatSet;
  473. }
  474.  
  475. void CPythonChat::ArrangeShowingChat(DWORD dwID)
  476. {
  477. TChatSet * pChatSet = GetChatSetPtr(dwID);
  478. if (!pChatSet)
  479. return;
  480.  
  481. pChatSet->m_ShowingChatLineList.clear();
  482.  
  483. TChatLineDeque TempChatLineDeque;
  484. for (TChatLineDeque::iterator itor = m_ChatLineDeque.begin(); itor != m_ChatLineDeque.end(); ++itor)
  485. {
  486. TChatLine * pChatLine = *itor;
  487. if (pChatSet->CheckMode(pChatLine->iType))
  488. TempChatLineDeque.push_back(pChatLine);
  489. }
  490.  
  491. int icurLineCount = TempChatLineDeque.size();
  492. int iVisibleLineCount = min(icurLineCount, (pChatSet->m_iHeight + pChatSet->m_iStep) / pChatSet->m_iStep);
  493. int iEndLine = iVisibleLineCount + int(float(icurLineCount - iVisibleLineCount - 1) * pChatSet->m_fEndPos);
  494.  
  495. /////
  496.  
  497. int iHeight = 12;
  498. for (int i = min(icurLineCount-1, iEndLine); i >= 0; --i)
  499. {
  500. if (!pChatSet->CheckMode(TempChatLineDeque[i]->iType))
  501. continue;
  502.  
  503. if (pChatSet->m_iHeight + pChatSet->m_iStep <= iHeight)
  504. {
  505. break;
  506. }
  507.  
  508. pChatSet->m_ShowingChatLineList.push_front(TempChatLineDeque[i]);
  509.  
  510. iHeight += pChatSet->m_iStep;
  511. }
  512. }
  513.  
  514. void CPythonChat::AppendChat(int iType, const char * c_szChat)
  515. {
  516. std::string const s = c_szChat;
  517. std::size_t EP1 = 0;
  518. std::size_t EP2 = 0;
  519. std::size_t EP3 = 0;
  520.  
  521.  
  522. EP1 = s.find("[F7");
  523. EP2 = s.find("[F8");
  524. EP3 = s.find("[F9");
  525.  
  526. if (EP1 != std::string::npos) {
  527.  
  528. if (CResourceManager::Instance().IsFileExist("d:/ymir work/ui/game/flag/shinsoo.tga"))
  529. {
  530. CGraphicImage * pFlagImage = (CGraphicImage *)CResourceManager::Instance().GetResourcePointer("d:/ymir work/ui/game/flag/shinsoo.tga");
  531. if (pFlagImage)
  532. {
  533. prFlag = CGraphicImageInstance::New();
  534. prFlag->SetImagePointer(pFlagImage);
  535. }
  536. }
  537. }
  538.  
  539. else if (EP2 != std::string::npos) {
  540.  
  541. if (CResourceManager::Instance().IsFileExist("d:/ymir work/ui/game/flag/chunjo.tga"))
  542. {
  543. CGraphicImage * pFlagImage = (CGraphicImage *)CResourceManager::Instance().GetResourcePointer("d:/ymir work/ui/game/flag/chunjo.tga");
  544. if (pFlagImage)
  545. {
  546. prFlag = CGraphicImageInstance::New();
  547. prFlag->SetImagePointer(pFlagImage);
  548. }
  549. }
  550. }
  551.  
  552. else if (EP3 != std::string::npos) {
  553.  
  554. if (CResourceManager::Instance().IsFileExist("d:/ymir work/ui/game/flag/jinno.tga"))
  555. {
  556. CGraphicImage * pFlagImage = (CGraphicImage *)CResourceManager::Instance().GetResourcePointer("d:/ymir work/ui/game/flag/jinno.tga");
  557. if (pFlagImage)
  558. {
  559. prFlag = CGraphicImageInstance::New();
  560. prFlag->SetImagePointer(pFlagImage);
  561. }
  562. }
  563. }
  564.  
  565. else {
  566.  
  567. if (CResourceManager::Instance().IsFileExist("d:/ymir work/ui/game/flag/none.tga"))
  568. {
  569. CGraphicImage * pFlagImage = (CGraphicImage *)CResourceManager::Instance().GetResourcePointer("d:/ymir work/ui/game/flag/none.tga");
  570. if (pFlagImage)
  571. {
  572. prFlag = CGraphicImageInstance::New();
  573. prFlag->SetImagePointer(pFlagImage);
  574. }
  575. }
  576. }
  577. // DEFAULT_FONT
  578. //static CResource * s_pResource = CResourceManager::Instance().GetResourcePointer(g_strDefaultFontName.c_str());
  579.  
  580. CGraphicText* pkDefaultFont = static_cast<CGraphicText*>(DefaultFont_GetResource());
  581. if (!pkDefaultFont)
  582. {
  583. TraceError("CPythonChat::AppendChat - CANNOT_FIND_DEFAULT_FONT");
  584. return;
  585. }
  586. // END_OF_DEFAULT_FONT
  587.  
  588. IAbstractApplication& rApp=IAbstractApplication::GetSingleton();
  589. SChatLine * pChatLine = SChatLine::New();
  590. pChatLine->iType = iType;
  591. #ifdef ENABLE_LANG_AND_EMPIRE_FLAG
  592. std::string strContent = c_szChat;
  593.  
  594. if (iType == CHAT_TYPE_SHOUT)
  595. {
  596. pChatLine->InstanceLang.SetImagePointer((CGraphicImage*)CResourceManager::Instance().GetResourcePointer("d:/ymir work/ui/language_flag/ro.tga"));
  597. pChatLine->InstanceEmpire.SetImagePointer((CGraphicImage*)CResourceManager::Instance().GetResourcePointer("d:/ymir work/ui/empire/empire_a_256.dds"));
  598. }
  599.  
  600. if (iType == CHAT_TYPE_SHOUT)
  601. {
  602. std::string isEmpireFlag("/empire/");
  603. int position = strContent.find(isEmpireFlag);
  604.  
  605. if (position != std::string::npos)
  606. {
  607. strContent = strContent.substr(position + isEmpireFlag.length(), strContent.length());
  608. position = strContent.find("/");
  609. std::string c_szEmpire = strContent.substr(0, position);
  610.  
  611. if (strlen(c_szEmpire.c_str()) > 0)
  612. {
  613. char buf[128];
  614. sprintf(buf, "d:/ymir work/ui/empire/empire_%s_256.dds", c_szEmpire.c_str());
  615. pChatLine->InstanceEmpire.SetImagePointer((CGraphicImage*)CResourceManager::Instance().GetResourcePointer(buf));
  616. }
  617. strContent = strContent.substr(position + 1, strContent.length());
  618. }
  619. }
  620. #endif
  621. #ifdef ENABLE_LANG_AND_EMPIRE_FLAG
  622. pChatLine->Instance.SetValue(strContent.c_str());
  623. #else
  624. pChatLine->Instance.SetValue(c_szChat);
  625. #endif
  626.  
  627. // DEFAULT_FONT
  628. pChatLine->Instance.SetTextPointer(pkDefaultFont);
  629. // END_OF_DEFAULT_FONT
  630.  
  631. pChatLine->fAppendedTime = rApp.GetGlobalTime();
  632. pChatLine->SetColorAll(GetChatColor(iType));
  633.  
  634. m_ChatLineDeque.push_back(pChatLine);
  635. if (m_ChatLineDeque.size() > CHAT_LINE_MAX_NUM)
  636. {
  637. SChatLine * pChatLine = m_ChatLineDeque.front();
  638. SChatLine::Delete(pChatLine);
  639. m_ChatLineDeque.pop_front();
  640. }
  641.  
  642. for (TChatSetMap::iterator itor = m_ChatSetMap.begin(); itor != m_ChatSetMap.end(); ++itor)
  643. {
  644. TChatSet * pChatSet = &(itor->second);
  645. //pChatLine->SetColor(itor->first, GetChatColor(iType));
  646.  
  647. // Edit Mode 를 억지로 끼워 맞추기 위해 추가
  648. if (BOARD_STATE_EDIT == pChatSet->m_iBoardState)
  649. {
  650. ArrangeShowingChat(itor->first);
  651. }
  652. else// if (BOARD_STATE_VIEW == pChatSet->m_iBoardState)
  653. {
  654. pChatSet->m_ShowingChatLineList.push_back(pChatLine);
  655. if (pChatSet->m_ShowingChatLineList.size() > CHAT_LINE_MAX_NUM)
  656. {
  657. pChatSet->m_ShowingChatLineList.pop_front();
  658. }
  659. }
  660. }
  661. }
  662.  
  663. void CPythonChat::AppendChatWithDelay(int iType, const char * c_szChat, int iDelay)
  664. {
  665. TWaitChat WaitChat;
  666. WaitChat.iType = iType;
  667. WaitChat.strChat = c_szChat;
  668. WaitChat.dwAppendingTime = CTimer::Instance().GetCurrentMillisecond() + iDelay;
  669. m_WaitChatList.push_back(WaitChat);
  670. }
  671.  
  672. DWORD CPythonChat::GetChatColor(int iType)
  673. {
  674. if (iType<CHAT_TYPE_MAX_NUM)
  675. {
  676. return m_akD3DXClrChat[iType];
  677. }
  678.  
  679. return D3DXCOLOR(0.0f, 0.0f, 1.0f, 1.0f);
  680. }
  681.  
  682. void CPythonChat::IgnoreCharacter(const char * c_szName)
  683. {
  684. TIgnoreCharacterSet::iterator itor = m_IgnoreCharacterSet.find(c_szName);
  685. // NOTE : 이미 차단 중이라면..
  686. if (m_IgnoreCharacterSet.end() != itor)
  687. {
  688. m_IgnoreCharacterSet.erase(itor);
  689. }
  690. // NOTE : 차단이 되지 않은 캐릭터라면..
  691. else
  692. {
  693. m_IgnoreCharacterSet.insert(c_szName);
  694. }
  695. }
  696.  
  697. BOOL CPythonChat::IsIgnoreCharacter(const char * c_szName)
  698. {
  699. TIgnoreCharacterSet::iterator itor = m_IgnoreCharacterSet.find(c_szName);
  700.  
  701. if (m_IgnoreCharacterSet.end() == itor)
  702. return FALSE;
  703.  
  704. return TRUE;
  705. }
  706.  
  707. CWhisper * CPythonChat::CreateWhisper(const char * c_szName)
  708. {
  709. CWhisper * pWhisper = CWhisper::New();
  710. m_WhisperMap.insert(TWhisperMap::value_type(c_szName, pWhisper));
  711. return pWhisper;
  712. }
  713.  
  714. void CPythonChat::AppendWhisper(int iType, const char * c_szName, const char * c_szChat)
  715. {
  716. TWhisperMap::iterator itor = m_WhisperMap.find(c_szName);
  717.  
  718. CWhisper * pWhisper;
  719. if (itor == m_WhisperMap.end())
  720. {
  721. pWhisper = CreateWhisper(c_szName);
  722. }
  723. else
  724. {
  725. pWhisper = itor->second;
  726. }
  727.  
  728. pWhisper->AppendChat(iType, c_szChat);
  729. }
  730.  
  731. void CPythonChat::ClearWhisper(const char * c_szName)
  732. {
  733. TWhisperMap::iterator itor = m_WhisperMap.find(c_szName);
  734.  
  735. if (itor != m_WhisperMap.end())
  736. {
  737. CWhisper * pWhisper = itor->second;
  738. CWhisper::Delete(pWhisper);
  739.  
  740. m_WhisperMap.erase(itor);
  741. }
  742. }
  743.  
  744. BOOL CPythonChat::GetWhisper(const char * c_szName, CWhisper ** ppWhisper)
  745. {
  746. TWhisperMap::iterator itor = m_WhisperMap.find(c_szName);
  747.  
  748. if (itor == m_WhisperMap.end())
  749. return FALSE;
  750.  
  751. *ppWhisper = itor->second;
  752.  
  753. return TRUE;
  754. }
  755.  
  756. void CPythonChat::InitWhisper(PyObject * ppyObject)
  757. {
  758. TWhisperMap::iterator itor = m_WhisperMap.begin();
  759. for (; itor != m_WhisperMap.end(); ++itor)
  760. {
  761. std::string strName = itor->first;
  762. PyCallClassMemberFunc(ppyObject, "MakeWhisperButton", Py_BuildValue("(s)", strName.c_str()));
  763. }
  764. }
  765.  
  766. void CPythonChat::__DestroyWhisperMap()
  767. {
  768. TWhisperMap::iterator itor = m_WhisperMap.begin();
  769. for (; itor != m_WhisperMap.end(); ++itor)
  770. {
  771. CWhisper::Delete(itor->second);
  772. }
  773. m_WhisperMap.clear();
  774. }
  775.  
  776. void CPythonChat::Close()
  777. {
  778. TChatSetMap::iterator itor = m_ChatSetMap.begin();
  779. for (; itor != m_ChatSetMap.end(); ++itor)
  780. {
  781. TChatSet & rChatSet = itor->second;
  782. TChatLineList * pLineList = &(rChatSet.m_ShowingChatLineList);
  783. for (TChatLineList::iterator itor = pLineList->begin(); itor != pLineList->end(); ++itor)
  784. {
  785. TChatLine * pChatLine = (*itor);
  786. pChatLine->fAppendedTime = 0.0f;
  787. }
  788. }
  789. }
  790.  
  791. void CPythonChat::Destroy()
  792. {
  793. __DestroyWhisperMap();
  794.  
  795. m_ShowingChatLineList.clear();
  796. m_ChatSetMap.clear();
  797. m_ChatLineDeque.clear();
  798.  
  799. SChatLine::DestroySystem();
  800. CWhisper::DestroySystem();
  801.  
  802. __Initialize();
  803. }
  804.  
  805. void CPythonChat::__Initialize()
  806. {
  807. m_akD3DXClrChat[CHAT_TYPE_TALKING] = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
  808. m_akD3DXClrChat[CHAT_TYPE_INFO] = D3DXCOLOR(1.0f, 0.785f, 0.785f, 1.0f);
  809. m_akD3DXClrChat[CHAT_TYPE_NOTICE] = D3DXCOLOR(1.0f, 0.902f, 0.730f, 1.0f);
  810. m_akD3DXClrChat[CHAT_TYPE_PARTY] = D3DXCOLOR(0.542f, 1.0f, 0.949f, 1.0f);
  811. m_akD3DXClrChat[CHAT_TYPE_GUILD] = D3DXCOLOR(0.906f, 0.847f, 1.0f, 1.0f);
  812. m_akD3DXClrChat[CHAT_TYPE_COMMAND] = D3DXCOLOR(0.658f, 1.0f, 0.835f, 1.0f);
  813. m_akD3DXClrChat[CHAT_TYPE_SHOUT] = D3DXCOLOR(0.658f, 1.0f, 0.835f, 1.0f);
  814. m_akD3DXClrChat[CHAT_TYPE_WHISPER] = D3DXCOLOR(0xff4AE14A);
  815. m_akD3DXClrChat[CHAT_TYPE_BIG_NOTICE] = D3DXCOLOR(1.0f, 0.902f, 0.730f, 1.0f);
  816. }
  817.  
  818. CPythonChat::CPythonChat()
  819. {
  820. __Initialize();
  821. }
  822.  
  823. CPythonChat::~CPythonChat()
  824. {
  825. assert(m_ChatLineDeque.empty());
  826. assert(m_ShowingChatLineList.empty());
  827. assert(m_ChatSetMap.empty());
  828. assert(m_WhisperMap.empty());
  829. }
  830.  
  831. ///////////////////////////////////////////////////////////////////////////////////////////////////
  832. CDynamicPool<CWhisper> CWhisper::ms_kPool;
  833.  
  834. CWhisper* CWhisper::New()
  835. {
  836. return ms_kPool.Alloc();
  837. }
  838.  
  839. void CWhisper::Delete(CWhisper* pkWhisper)
  840. {
  841. pkWhisper->Destroy();
  842. ms_kPool.Free(pkWhisper);
  843. }
  844.  
  845. void CWhisper::DestroySystem()
  846. {
  847. ms_kPool.Destroy();
  848.  
  849. SChatLine::DestroySystem();
  850. }
  851.  
  852. void CWhisper::SetPosition(float fPosition)
  853. {
  854. m_fcurPosition = fPosition;
  855. __ArrangeChat();
  856. }
  857.  
  858. void CWhisper::SetBoxSize(float fWidth, float fHeight)
  859. {
  860. m_fWidth = fWidth;
  861. m_fHeight = fHeight;
  862.  
  863. for (TChatLineDeque::iterator itor = m_ChatLineDeque.begin(); itor != m_ChatLineDeque.end(); ++itor)
  864. {
  865. TChatLine * pChatLine = *itor;
  866. pChatLine->Instance.SetLimitWidth(fWidth);
  867. }
  868. }
  869.  
  870. void CWhisper::AppendChat(int iType, const char * c_szChat)
  871. {
  872. // DEFAULT_FONT
  873. //static CResource * s_pResource = CResourceManager::Instance().GetResourcePointer(g_strDefaultFontName.c_str());
  874.  
  875. #if defined(LOCALE_SERVICE_YMIR) || defined(LOCALE_SERVICE_JAPAN) || defined(LOCALE_SERVICE_HONGKONG) || defined(LOCALE_SERVICE_TAIWAN) || defined(LOCALE_SERVICE_NEWCIBN)
  876. CGraphicText* pkDefaultFont = static_cast<CGraphicText*>(DefaultFont_GetResource());
  877. #else
  878. CGraphicText* pkDefaultFont = (iType == CPythonChat::WHISPER_TYPE_GM) ? static_cast<CGraphicText*>(DefaultItalicFont_GetResource()) : static_cast<CGraphicText*>(DefaultFont_GetResource());
  879. #endif
  880.  
  881. if (!pkDefaultFont)
  882. {
  883. TraceError("CWhisper::AppendChat - CANNOT_FIND_DEFAULT_FONT");
  884. return;
  885. }
  886. // END_OF_DEFAULT_FONT
  887.  
  888. SChatLine * pChatLine = SChatLine::New();
  889. pChatLine->Instance.SetValue(c_szChat);
  890.  
  891. // DEFAULT_FONT
  892. pChatLine->Instance.SetTextPointer(pkDefaultFont);
  893. // END_OF_DEFAULT_FONT
  894.  
  895. pChatLine->Instance.SetLimitWidth(m_fWidth);
  896. pChatLine->Instance.SetMultiLine(TRUE);
  897.  
  898. switch(iType)
  899. {
  900. case CPythonChat::WHISPER_TYPE_SYSTEM:
  901. pChatLine->Instance.SetColor(D3DXCOLOR(1.0f, 0.785f, 0.785f, 1.0f));
  902. break;
  903. case CPythonChat::WHISPER_TYPE_GM:
  904. pChatLine->Instance.SetColor(D3DXCOLOR(1.0f, 0.632f, 0.0f, 1.0f));
  905. break;
  906. case CPythonChat::WHISPER_TYPE_CHAT:
  907. default:
  908. pChatLine->Instance.SetColor(0xffffffff);
  909. break;
  910. }
  911.  
  912. m_ChatLineDeque.push_back(pChatLine);
  913.  
  914. __ArrangeChat();
  915. }
  916.  
  917. void CWhisper::__ArrangeChat()
  918. {
  919. for (TChatLineDeque::iterator itor = m_ChatLineDeque.begin(); itor != m_ChatLineDeque.end(); ++itor)
  920. {
  921. TChatLine * pChatLine = *itor;
  922. pChatLine->Instance.Update();
  923. }
  924. }
  925.  
  926. void CWhisper::Render(float fx, float fy)
  927. {
  928. float fHeight = fy + m_fHeight;
  929.  
  930. int iViewCount = int(m_fHeight / m_fLineStep) - 1;
  931. int iLineCount = int(m_ChatLineDeque.size());
  932. int iStartLine = -1;
  933. if (iLineCount > iViewCount)
  934. {
  935. iStartLine = int(float(iLineCount-iViewCount) * m_fcurPosition) + iViewCount - 1;
  936. }
  937. else if (!m_ChatLineDeque.empty())
  938. {
  939. iStartLine = iLineCount - 1;
  940. }
  941.  
  942. RECT Rect = { fx, fy, fx+m_fWidth, fy+m_fHeight };
  943.  
  944. for (int i = iStartLine; i >= 0; --i)
  945. {
  946. assert(i >= 0 && i < int(m_ChatLineDeque.size()));
  947. TChatLine * pChatLine = m_ChatLineDeque[i];
  948.  
  949. WORD wLineCount = pChatLine->Instance.GetTextLineCount();
  950. fHeight -= wLineCount * m_fLineStep;
  951.  
  952. pChatLine->Instance.SetPosition(fx, fHeight);
  953. pChatLine->Instance.Render(&Rect);
  954.  
  955. if (fHeight < fy)
  956. break;
  957. }
  958. }
  959.  
  960. void CWhisper::__Initialize()
  961. {
  962. m_fLineStep = 15.0f;
  963. m_fWidth = 300.0f;
  964. m_fHeight = 120.0f;
  965. m_fcurPosition = 1.0f;
  966. }
  967.  
  968. void CWhisper::Destroy()
  969. {
  970. std::for_each(m_ChatLineDeque.begin(), m_ChatLineDeque.end(), SChatLine::Delete);
  971. m_ChatLineDeque.clear();
  972. m_ShowingChatLineList.clear();
  973. }
  974.  
  975. CWhisper::CWhisper()
  976. {
  977. __Initialize();
  978. }
  979.  
  980. CWhisper::~CWhisper()
  981. {
  982. Destroy();
  983. }
  984.  
  985. ///////////////////////////////////////////////////////////////////////////////////////////////////
  986.  
  987. CDynamicPool<CWhisper::SChatLine> CWhisper::SChatLine::ms_kPool;
  988.  
  989. CWhisper::SChatLine* CWhisper::SChatLine::New()
  990. {
  991. return ms_kPool.Alloc();
  992. }
  993.  
  994. void CWhisper::SChatLine::Delete(CWhisper::SChatLine* pkChatLine)
  995. {
  996. pkChatLine->Instance.Destroy();
  997. ms_kPool.Free(pkChatLine);
  998. }
  999.  
  1000. void CWhisper::SChatLine::DestroySystem()
  1001. {
  1002. ms_kPool.Destroy();
  1003. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!