API tools faq
paste
Guest User

Untitled

a guest
Mar 4th, 2017
160
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 26.71 KB | None | 0 0
raw download clone embed print report
  1. #include "stdafx.h"
  2. #include "InstanceBase.h"
  3. #include "resource.h"
  4. #include "PythonTextTail.h"
  5. #include "PythonCharacterManager.h"
  6. #include "PythonGuild.h"
  7. #include "Locale.h"
  8. #include "MarkManager.h"
  9.  
  10. const D3DXCOLOR c_TextTail_Player_Color = D3DXCOLOR (1.0f, 1.0f, 1.0f, 1.0f);
  11. const D3DXCOLOR c_TextTail_Monster_Color = D3DXCOLOR (1.0f, 0.0f, 0.0f, 1.0f);
  12. const D3DXCOLOR c_TextTail_Item_Color = D3DXCOLOR (1.0f, 1.0f, 1.0f, 1.0f);
  13. const D3DXCOLOR c_TextTail_Chat_Color = D3DXCOLOR (1.0f, 1.0f, 1.0f, 1.0f);
  14. const D3DXCOLOR c_TextTail_Info_Color = D3DXCOLOR (1.0f, 0.785f, 0.785f, 1.0f);
  15. const D3DXCOLOR c_TextTail_Guild_Name_Color = 0xFFEFD3FF;
  16. const float c_TextTail_Name_Position = -10.0f;
  17. const float c_fxMarkPosition = 1.5f;
  18. const float c_fyGuildNamePosition = 15.0f;
  19. const float c_fyMarkPosition = 15.0f + 11.0f;
  20. BOOL bPKTitleEnable = TRUE;
  21. long gs_TextTail_LivingTime = 5000;
  22.  
  23.  
  24.  
  25. long TextTail_GetLivingTime()
  26. {
  27.     assert (gs_TextTail_LivingTime > 1000);
  28.     return gs_TextTail_LivingTime;
  29. }
  30.  
  31. void TextTail_SetLivingTime (long livingTime)
  32. {
  33.     gs_TextTail_LivingTime = livingTime;
  34. }
  35.  
  36. CGraphicText* ms_pFont = NULL;
  37.  
  38. void CPythonTextTail::GetInfo (std::string* pstInfo)
  39. {
  40.     char szInfo[256];
  41.     sprintf (szInfo, "TextTail: ChatTail %d, ChrTail (Map %d, List %d), ItemTail (Map %d, List %d), Pool %d", m_ChatTailMap.size(), m_CharacterTextTailMap.size(), m_CharacterTextTailList.size(), m_ItemTextTailMap.size(), m_ItemTextTailList.size(), m_TextTailPool.GetCapacity());
  42.     pstInfo->append (szInfo);
  43. }
  44.  
  45. void CPythonTextTail::UpdateAllTextTail()
  46. {
  47.     CInstanceBase* pInstance = CPythonCharacterManager::Instance().GetMainInstancePtr();
  48.     if (pInstance)
  49.     {
  50.         TPixelPosition pixelPos;
  51.         pInstance->NEW_GetPixelPosition (&pixelPos);
  52.  
  53.         for (auto itorMap = m_CharacterTextTailMap.begin(); itorMap != m_CharacterTextTailMap.end(); ++itorMap)
  54.         {
  55.             UpdateDistance (pixelPos, itorMap->second);
  56.         }
  57.  
  58.         for (auto itorMap = m_ItemTextTailMap.begin(); itorMap != m_ItemTextTailMap.end(); ++itorMap)
  59.         {
  60.             UpdateDistance (pixelPos, itorMap->second);
  61.         }
  62.  
  63.         for (auto itorChat = m_ChatTailMap.begin(); itorChat != m_ChatTailMap.end(); ++itorChat)
  64.         {
  65.             UpdateDistance (pixelPos, itorChat->second);
  66.  
  67.             if (itorChat->second->bNameFlag)
  68.             {
  69.                 DWORD dwVID = itorChat->first;
  70.                 ShowCharacterTextTail (dwVID);
  71.             }
  72.         }
  73.     }
  74. }
  75.  
  76. void CPythonTextTail::UpdateShowingTextTail()
  77. {
  78.     for (auto itor = m_ItemTextTailList.begin(); itor != m_ItemTextTailList.end(); ++itor)
  79.     {
  80.         UpdateTextTail (*itor);
  81.     }
  82.  
  83.     for (auto itorChat = m_ChatTailMap.begin(); itorChat != m_ChatTailMap.end(); ++itorChat)
  84.     {
  85.         UpdateTextTail (itorChat->second);
  86.     }
  87.  
  88.     TTextTailList::iterator itor;
  89.     for (itor = m_CharacterTextTailList.begin(); itor != m_CharacterTextTailList.end(); ++itor)
  90.     {
  91.         TTextTail* pTextTail = *itor;
  92.         UpdateTextTail (pTextTail);
  93.  
  94.         TChatTailMap::iterator itor = m_ChatTailMap.find (pTextTail->dwVirtualID);
  95.         if (m_ChatTailMap.end() != itor)
  96.         {
  97.             TTextTail* pChatTail = itor->second;
  98.             if (pChatTail->bNameFlag)
  99.             {
  100.                 pTextTail->y = pChatTail->y - 17.0f;
  101.             }
  102.         }
  103.     }
  104. }
  105.  
  106. void CPythonTextTail::UpdateTextTail (TTextTail* pTextTail)
  107. {
  108.     if (!pTextTail->pOwner)
  109.     {
  110.         return;
  111.     }
  112.  
  113.     CPythonGraphic& rpyGraphic = CPythonGraphic::Instance();
  114.     rpyGraphic.Identity();
  115.  
  116.     const D3DXVECTOR3& c_rv3Position = pTextTail->pOwner->GetPosition();
  117.     rpyGraphic.ProjectPosition (c_rv3Position.x, c_rv3Position.y, c_rv3Position.z + pTextTail->fHeight, &pTextTail->x, &pTextTail->y, &pTextTail->z);
  118.  
  119.     pTextTail->x = floorf (pTextTail->x);
  120.     pTextTail->y = floorf (pTextTail->y);
  121.  
  122.     if (pTextTail->fDistanceFromPlayer < 1300.0f)
  123.     {
  124.         pTextTail->z = 0.0f;
  125.     }
  126.     else
  127.     {
  128.         pTextTail->z = pTextTail->z * CPythonGraphic::Instance().GetOrthoDepth() * -1.0f;
  129.         pTextTail->z += 10.0f;
  130.     }
  131. }
  132.  
  133. void CPythonTextTail::ArrangeTextTail()
  134. {
  135.     DWORD dwTime = CTimer::Instance().GetCurrentMillisecond();
  136.  
  137.     for (auto itor = m_ItemTextTailList.begin(); itor != m_ItemTextTailList.end(); ++itor)
  138.     {
  139.         TTextTail* pInsertTextTail = *itor;
  140.  
  141.         int yTemp = 5;
  142.         int LimitCount = 0;
  143.  
  144.         for (auto itorCompare = m_ItemTextTailList.begin(); itorCompare != m_ItemTextTailList.end();)
  145.         {
  146.             TTextTail* pCompareTextTail = *itorCompare;
  147.  
  148.             if (*itorCompare == *itor)
  149.             {
  150.                 ++itorCompare;
  151.                 continue;
  152.             }
  153.  
  154.             if (LimitCount >= 20)
  155.             {
  156.                 break;
  157.             }
  158.  
  159.             if (isIn (pInsertTextTail, pCompareTextTail))
  160.             {
  161.                 pInsertTextTail->y = (pCompareTextTail->y + pCompareTextTail->yEnd + yTemp);
  162.                 itorCompare = m_ItemTextTailList.begin();
  163.                 ++LimitCount;
  164.                 continue;
  165.             }
  166.             ++itorCompare;
  167.         }
  168.  
  169.  
  170.         if (pInsertTextTail->pOwnerTextInstance)
  171.         {
  172.             pInsertTextTail->pOwnerTextInstance->SetPosition (pInsertTextTail->x, pInsertTextTail->y, pInsertTextTail->z);
  173.             pInsertTextTail->pOwnerTextInstance->Update();
  174.  
  175.             pInsertTextTail->pTextInstance->SetColor (pInsertTextTail->Color.r, pInsertTextTail->Color.g, pInsertTextTail->Color.b);
  176.             pInsertTextTail->pTextInstance->SetPosition (pInsertTextTail->x, pInsertTextTail->y + 15.0f, pInsertTextTail->z);
  177.             pInsertTextTail->pTextInstance->Update();
  178.  
  179.         }
  180.         else
  181.         {
  182.             pInsertTextTail->pTextInstance->SetColor (pInsertTextTail->Color.r, pInsertTextTail->Color.g, pInsertTextTail->Color.b);
  183.             pInsertTextTail->pTextInstance->SetPosition (pInsertTextTail->x, pInsertTextTail->y, pInsertTextTail->z);
  184.             pInsertTextTail->pTextInstance->Update();
  185.  
  186.         }
  187.     }
  188.  
  189.     for (auto itor = m_CharacterTextTailList.begin(); itor != m_CharacterTextTailList.end(); ++itor)
  190.     {
  191.         TTextTail* pTextTail = *itor;
  192.         float fxAdd = 0.0f;
  193.  
  194.         CGraphicMarkInstance* pMarkInstance = pTextTail->pMarkInstance;
  195.         CGraphicTextInstance* pGuildNameInstance = pTextTail->pGuildNameTextInstance;
  196.         if (pMarkInstance && pGuildNameInstance)
  197.         {
  198.             int iWidth, iHeight;
  199.             int iImageHalfSize = pMarkInstance->GetWidth() / 2 + c_fxMarkPosition;
  200.             pGuildNameInstance->GetTextSize (&iWidth, &iHeight);
  201.  
  202.             pMarkInstance->SetPosition (pTextTail->x - iWidth / 2 - iImageHalfSize, pTextTail->y - c_fyMarkPosition);
  203.             pGuildNameInstance->SetPosition (pTextTail->x + iImageHalfSize, pTextTail->y - c_fyGuildNamePosition, pTextTail->z);
  204.             pGuildNameInstance->Update();
  205.         }
  206.  
  207.         int iNameWidth, iNameHeight;
  208.         pTextTail->pTextInstance->GetTextSize (&iNameWidth, &iNameHeight);
  209.  
  210.         CGraphicTextInstance* pTitle = pTextTail->pTitleTextInstance;
  211.         if (pTitle)
  212.         {
  213.             int iTitleWidth, iTitleHeight;
  214.             pTitle->GetTextSize (&iTitleWidth, &iTitleHeight);
  215.  
  216.             fxAdd = 8.0f;
  217.             pTitle->SetPosition (pTextTail->x - (iNameWidth / 2), pTextTail->y, pTextTail->z);
  218.  
  219.             pTitle->Update();
  220.  
  221.             CGraphicTextInstance* pLevel = pTextTail->pLevelTextInstance;
  222.             if (pLevel)
  223.             {
  224.                 int iLevelWidth, iLevelHeight;
  225.                 pLevel->GetTextSize (&iLevelWidth, &iLevelHeight);
  226.                 pLevel->SetPosition (pTextTail->x - (iNameWidth / 2) - iTitleWidth, pTextTail->y, pTextTail->z);
  227.                 pLevel->Update();
  228.             }
  229.         }
  230.         else
  231.         {
  232.             fxAdd = 4.0f;
  233.             CGraphicTextInstance* pLevel = pTextTail->pLevelTextInstance;
  234.             if (pLevel)
  235.             {
  236.                 int iLevelWidth, iLevelHeight;
  237.                 pLevel->GetTextSize (&iLevelWidth, &iLevelHeight);
  238.                 pLevel->SetPosition (pTextTail->x - (iNameWidth / 2), pTextTail->y, pTextTail->z);
  239.                 pLevel->Update();
  240.             }
  241.         }
  242.  
  243.         pTextTail->pTextInstance->SetColor (pTextTail->Color.r, pTextTail->Color.g, pTextTail->Color.b);
  244.         pTextTail->pTextInstance->SetPosition (pTextTail->x + fxAdd, pTextTail->y, pTextTail->z);
  245.         pTextTail->pTextInstance->Update();
  246.     }
  247.  
  248.     for (auto itorChat = m_ChatTailMap.begin(); itorChat != m_ChatTailMap.end();)
  249.     {
  250.         TTextTail* pTextTail = itorChat->second;
  251.  
  252.         if (pTextTail->LivingTime < dwTime)
  253.         {
  254.             DeleteTextTail (pTextTail);
  255.             itorChat = m_ChatTailMap.erase (itorChat);
  256.             continue;
  257.         }
  258.         else
  259.         {
  260.             ++itorChat;
  261.         }
  262.  
  263.         pTextTail->pTextInstance->SetColor (pTextTail->Color);
  264.         pTextTail->pTextInstance->SetPosition (pTextTail->x, pTextTail->y, pTextTail->z);
  265.         pTextTail->pTextInstance->Update();
  266.     }
  267. }
  268.  
  269. void CPythonTextTail::Render()
  270. {
  271.     for (auto itor = m_CharacterTextTailList.begin(); itor != m_CharacterTextTailList.end(); ++itor)
  272.     {
  273.         TTextTail* pTextTail = *itor;
  274.         pTextTail->pTextInstance->Render();
  275.         if (pTextTail->pMarkInstance && pTextTail->pGuildNameTextInstance)
  276.         {
  277.             pTextTail->pMarkInstance->Render();
  278.             pTextTail->pGuildNameTextInstance->Render();
  279.         }
  280.         if (pTextTail->pTitleTextInstance)
  281.         {
  282.             pTextTail->pTitleTextInstance->Render();
  283.         }
  284.         if (pTextTail->pLevelTextInstance)
  285.         {
  286.             pTextTail->pLevelTextInstance->Render();
  287.         }
  288.     }
  289.  
  290.     for (auto itor = m_ItemTextTailList.begin(); itor != m_ItemTextTailList.end(); ++itor)
  291.     {
  292.         TTextTail* pTextTail = *itor;
  293.  
  294.         RenderTextTailBox (pTextTail);
  295.         pTextTail->pTextInstance->Render();
  296.         if (pTextTail->pOwnerTextInstance)
  297.         {
  298.             pTextTail->pOwnerTextInstance->Render();
  299.         }
  300.     }
  301.  
  302.     for (auto itorChat = m_ChatTailMap.begin(); itorChat != m_ChatTailMap.end(); ++itorChat)
  303.     {
  304.         TTextTail* pTextTail = itorChat->second;
  305.         if (pTextTail->pOwner->isShow())
  306.         {
  307.             RenderTextTailName (pTextTail);
  308.         }
  309.     }
  310. }
  311.  
  312. void CPythonTextTail::RenderTextTailBox (TTextTail* pTextTail)
  313. {
  314.     CPythonGraphic::Instance().SetDiffuseColor (0.0f, 0.0f, 0.0f, 1.0f);
  315.     CPythonGraphic::Instance().RenderBox2d (pTextTail->x + pTextTail->xStart, pTextTail->y + pTextTail->yStart, pTextTail->x + pTextTail->xEnd, pTextTail->y + pTextTail->yEnd, pTextTail->z);
  316.  
  317.     CPythonGraphic::Instance().SetDiffuseColor (0.0f, 0.0f, 0.0f, 0.3f);
  318.     CPythonGraphic::Instance().RenderBar2d (pTextTail->x + pTextTail->xStart, pTextTail->y + pTextTail->yStart, pTextTail->x + pTextTail->xEnd, pTextTail->y + pTextTail->yEnd, pTextTail->z);
  319. }
  320.  
  321. void CPythonTextTail::RenderTextTailName (TTextTail* pTextTail)
  322. {
  323.     pTextTail->pTextInstance->Render();
  324. }
  325.  
  326. void CPythonTextTail::HideAllTextTail()
  327. {
  328.     m_CharacterTextTailList.clear();
  329.     m_ItemTextTailList.clear();
  330. }
  331.  
  332. void CPythonTextTail::UpdateDistance (const TPixelPosition& c_rCenterPosition, TTextTail* pTextTail)
  333. {
  334.     const D3DXVECTOR3& c_rv3Position = pTextTail->pOwner->GetPosition();
  335.     D3DXVECTOR2 v2Distance (c_rv3Position.x - c_rCenterPosition.x, -c_rv3Position.y - c_rCenterPosition.y);
  336.     pTextTail->fDistanceFromPlayer = D3DXVec2Length (&v2Distance);
  337. }
  338.  
  339. void CPythonTextTail::ShowAllTextTail()
  340. {
  341.     for (auto itor = m_CharacterTextTailMap.begin(); itor != m_CharacterTextTailMap.end(); ++itor)
  342.     {
  343.         TTextTail* pTextTail = itor->second;
  344.         if (pTextTail->fDistanceFromPlayer < 3500.0f)
  345.         {
  346.             ShowCharacterTextTail (itor->first);
  347.         }
  348.     }
  349.  
  350.     for (auto itor = m_ItemTextTailMap.begin(); itor != m_ItemTextTailMap.end(); ++itor)
  351.     {
  352.         TTextTail* pTextTail = itor->second;
  353.         if (pTextTail->fDistanceFromPlayer < 3500.0f)
  354.         {
  355.             ShowItemTextTail (itor->first);
  356.         }
  357.     }
  358. }
  359.  
  360. void CPythonTextTail::ShowCharacterTextTail (DWORD VirtualID)
  361. {
  362.     auto itor = m_CharacterTextTailMap.find (VirtualID);
  363.  
  364.     if (m_CharacterTextTailMap.end() == itor)
  365.     {
  366.         return;
  367.     }
  368.  
  369.     TTextTail* pTextTail = itor->second;
  370.  
  371.     if (m_CharacterTextTailList.end() != std::find (m_CharacterTextTailList.begin(), m_CharacterTextTailList.end(), pTextTail))
  372.     {
  373.         return;
  374.     }
  375.  
  376.     if (!pTextTail->pOwner->isShow())
  377.     {
  378.         return;
  379.     }
  380.  
  381.     CInstanceBase* pInstance = CPythonCharacterManager::Instance().GetInstancePtr (pTextTail->dwVirtualID);
  382.     if (!pInstance)
  383.     {
  384.         return;
  385.     }
  386.  
  387.     if (pInstance->IsGuildWall())
  388.     {
  389.         return;
  390.     }
  391.  
  392.     if (pInstance->CanPickInstance())
  393.     {
  394.         m_CharacterTextTailList.push_back (pTextTail);
  395.     }
  396. }
  397.  
  398. void CPythonTextTail::ShowItemTextTail (DWORD VirtualID)
  399. {
  400.     auto itor = m_ItemTextTailMap.find (VirtualID);
  401.     if (m_ItemTextTailMap.end() == itor)
  402.     {
  403.         return;
  404.     }
  405.  
  406.     TTextTail* pTextTail = itor->second;
  407.     if (m_ItemTextTailList.end() != std::find (m_ItemTextTailList.begin(), m_ItemTextTailList.end(), pTextTail))
  408.     {
  409.         return;
  410.     }
  411.  
  412.     m_ItemTextTailList.push_back (pTextTail);
  413. }
  414.  
  415. bool CPythonTextTail::isIn (CPythonTextTail::TTextTail* pSource, CPythonTextTail::TTextTail* pTarget)
  416. {
  417.     float x1Source = pSource->x + pSource->xStart;
  418.     float y1Source = pSource->y + pSource->yStart;
  419.     float x2Source = pSource->x + pSource->xEnd;
  420.     float y2Source = pSource->y + pSource->yEnd;
  421.     float x1Target = pTarget->x + pTarget->xStart;
  422.     float y1Target = pTarget->y + pTarget->yStart;
  423.     float x2Target = pTarget->x + pTarget->xEnd;
  424.     float y2Target = pTarget->y + pTarget->yEnd;
  425.  
  426.     if (x1Source <= x2Target && x2Source >= x1Target && y1Source <= y2Target && y2Source >= y1Target)
  427.     {
  428.         return true;
  429.     }
  430.  
  431.     return false;
  432. }
  433.  
  434. void CPythonTextTail::RegisterCharacterTextTail (DWORD dwGuildID, DWORD dwVirtualID, const D3DXCOLOR& c_rColor, float fAddHeight)
  435. {
  436.     CInstanceBase* pCharacterInstance = CPythonCharacterManager::Instance().GetInstancePtr (dwVirtualID);
  437.  
  438.     if (!pCharacterInstance)
  439.     {
  440.         return;
  441.     }
  442.  
  443.     TTextTail* pTextTail = RegisterTextTail (dwVirtualID, pCharacterInstance->GetNameString(), pCharacterInstance->GetGraphicThingInstancePtr(), pCharacterInstance->GetGraphicThingInstanceRef().GetHeight() + fAddHeight, c_rColor);
  444.     CGraphicTextInstance* pTextInstance = pTextTail->pTextInstance;
  445.     pTextInstance->SetOutline (true);
  446.     pTextInstance->SetVerticalAlign (CGraphicTextInstance::VERTICAL_ALIGN_BOTTOM);
  447.  
  448.     pTextTail->pMarkInstance = NULL;
  449.     pTextTail->pGuildNameTextInstance = NULL;
  450.     pTextTail->pTitleTextInstance = NULL;
  451.     pTextTail->pLevelTextInstance = NULL;
  452.  
  453.     if (0 != dwGuildID)
  454.     {
  455.         pTextTail->pMarkInstance = CGraphicMarkInstance::New();
  456.         DWORD dwMarkID = CGuildMarkManager::Instance().GetMarkID (dwGuildID);
  457.  
  458.         if (dwMarkID != CGuildMarkManager::INVALID_MARK_ID)
  459.         {
  460.             std::string markImagePath;
  461.             if (CGuildMarkManager::Instance().GetMarkImageFilename (dwMarkID / CGuildMarkImage::MARK_TOTAL_COUNT, markImagePath))
  462.             {
  463.                 pTextTail->pMarkInstance->SetImageFileName (markImagePath.c_str());
  464.                 pTextTail->pMarkInstance->Load();
  465.                 pTextTail->pMarkInstance->SetIndex (dwMarkID % CGuildMarkImage::MARK_TOTAL_COUNT);
  466.             }
  467.         }
  468.  
  469.         std::string strGuildName;
  470.         if (!CPythonGuild::Instance().GetGuildName (dwGuildID, &strGuildName))
  471.         {
  472.             strGuildName = "Noname";
  473.         }
  474.  
  475.         CGraphicTextInstance*& prGuildNameInstance = pTextTail->pGuildNameTextInstance;
  476.         prGuildNameInstance = CGraphicTextInstance::New();
  477.         prGuildNameInstance->SetTextPointer (ms_pFont);
  478.         prGuildNameInstance->SetOutline (true);
  479.         prGuildNameInstance->SetHorizonalAlign (CGraphicTextInstance::HORIZONTAL_ALIGN_CENTER);
  480.         prGuildNameInstance->SetVerticalAlign (CGraphicTextInstance::VERTICAL_ALIGN_BOTTOM);
  481.         prGuildNameInstance->SetValue (strGuildName.c_str());
  482.         prGuildNameInstance->SetColor (c_TextTail_Guild_Name_Color.r, c_TextTail_Guild_Name_Color.g, c_TextTail_Guild_Name_Color.b);
  483.         prGuildNameInstance->Update();
  484.     }
  485.  
  486.     m_CharacterTextTailMap.insert (TTextTailMap::value_type (dwVirtualID, pTextTail));
  487. }
  488.  
  489. void CPythonTextTail::RegisterItemTextTail (DWORD VirtualID, const char* c_szText, CGraphicObjectInstance* pOwner)
  490. {
  491.     TTextTail* pTextTail = RegisterTextTail (VirtualID, c_szText, pOwner, c_TextTail_Name_Position, c_TextTail_Item_Color);
  492.     m_ItemTextTailMap.insert (TTextTailMap::value_type (VirtualID, pTextTail));
  493. }
  494.  
  495. void CPythonTextTail::RegisterChatTail (DWORD VirtualID, const char* c_szChat)
  496. {
  497.     CInstanceBase* pCharacterInstance = CPythonCharacterManager::Instance().GetInstancePtr (VirtualID);
  498.  
  499.     if (!pCharacterInstance)
  500.     {
  501.         return;
  502.     }
  503.  
  504.     auto itor = m_ChatTailMap.find (VirtualID);
  505.  
  506.     if (m_ChatTailMap.end() != itor)
  507.     {
  508.         TTextTail* pTextTail = itor->second;
  509.  
  510.         pTextTail->pTextInstance->SetValue (c_szChat);
  511.         pTextTail->pTextInstance->Update();
  512.         pTextTail->Color = c_TextTail_Chat_Color;
  513.         pTextTail->pTextInstance->SetColor (c_TextTail_Chat_Color);
  514.         pTextTail->LivingTime = CTimer::Instance().GetCurrentMillisecond() + TextTail_GetLivingTime();
  515.         pTextTail->bNameFlag = TRUE;
  516.         return;
  517.     }
  518.  
  519.     TTextTail* pTextTail = RegisterTextTail (VirtualID, c_szChat, pCharacterInstance->GetGraphicThingInstancePtr(), pCharacterInstance->GetGraphicThingInstanceRef().GetHeight() + 10.0f, c_TextTail_Chat_Color);
  520.     pTextTail->LivingTime = CTimer::Instance().GetCurrentMillisecond() + TextTail_GetLivingTime();
  521.  
  522.     pTextTail->bNameFlag = TRUE;
  523.     pTextTail->pTextInstance->SetOutline (true);
  524.     pTextTail->pTextInstance->SetVerticalAlign (CGraphicTextInstance::VERTICAL_ALIGN_BOTTOM);
  525.     m_ChatTailMap.insert (TTextTailMap::value_type (VirtualID, pTextTail));
  526. }
  527.  
  528. void CPythonTextTail::RegisterInfoTail (DWORD VirtualID, const char* c_szChat)
  529. {
  530.     CInstanceBase* pCharacterInstance = CPythonCharacterManager::Instance().GetInstancePtr (VirtualID);
  531.  
  532.     if (!pCharacterInstance)
  533.     {
  534.         return;
  535.     }
  536.  
  537.     auto itor = m_ChatTailMap.find (VirtualID);
  538.  
  539.     if (m_ChatTailMap.end() != itor)
  540.     {
  541.         TTextTail* pTextTail = itor->second;
  542.  
  543.         pTextTail->pTextInstance->SetValue (c_szChat);
  544.         pTextTail->pTextInstance->Update();
  545.         pTextTail->Color = c_TextTail_Info_Color;
  546.         pTextTail->pTextInstance->SetColor (c_TextTail_Info_Color);
  547.  
  548.         pTextTail->LivingTime = CTimer::Instance().GetCurrentMillisecond() + TextTail_GetLivingTime();
  549.         pTextTail->bNameFlag = FALSE;
  550.  
  551.         return;
  552.     }
  553.  
  554.     TTextTail* pTextTail = RegisterTextTail (VirtualID, c_szChat, pCharacterInstance->GetGraphicThingInstancePtr(), pCharacterInstance->GetGraphicThingInstanceRef().GetHeight() + 10.0f, c_TextTail_Info_Color);
  555.     pTextTail->LivingTime = CTimer::Instance().GetCurrentMillisecond() + TextTail_GetLivingTime();
  556.     pTextTail->bNameFlag = FALSE;
  557.     pTextTail->pTextInstance->SetOutline (true);
  558.     pTextTail->pTextInstance->SetVerticalAlign (CGraphicTextInstance::VERTICAL_ALIGN_BOTTOM);
  559.     m_ChatTailMap.insert (TTextTailMap::value_type (VirtualID, pTextTail));
  560. }
  561.  
  562. bool CPythonTextTail::GetTextTailPosition (DWORD dwVID, float* px, float* py, float* pz)
  563. {
  564.     auto itorCharacter = m_CharacterTextTailMap.find (dwVID);
  565.  
  566.     if (m_CharacterTextTailMap.end() == itorCharacter)
  567.     {
  568.         return false;
  569.     }
  570.  
  571.     TTextTail* pTextTail = itorCharacter->second;
  572.     *px = pTextTail->x;
  573.     *py = pTextTail->y;
  574.     *pz = pTextTail->z;
  575.  
  576.     return true;
  577. }
  578.  
  579. bool CPythonTextTail::IsChatTextTail (DWORD dwVID)
  580. {
  581.     auto itorChat = m_ChatTailMap.find (dwVID);
  582.  
  583.     if (m_ChatTailMap.end() == itorChat)
  584.     {
  585.         return false;
  586.     }
  587.  
  588.     return true;
  589. }
  590.  
  591. void CPythonTextTail::SetCharacterTextTailColor (DWORD VirtualID, const D3DXCOLOR& c_rColor)
  592. {
  593.     auto itorCharacter = m_CharacterTextTailMap.find (VirtualID);
  594.  
  595.     if (m_CharacterTextTailMap.end() == itorCharacter)
  596.     {
  597.         return;
  598.     }
  599.  
  600.     TTextTail* pTextTail = itorCharacter->second;
  601.     pTextTail->pTextInstance->SetColor (c_rColor);
  602.     pTextTail->Color = c_rColor;
  603. }
  604.  
  605. void CPythonTextTail::SetItemTextTailOwner (DWORD dwVID, const char* c_szName)
  606. {
  607.     auto itor = m_ItemTextTailMap.find (dwVID);
  608.     if (m_ItemTextTailMap.end() == itor)
  609.     {
  610.         return;
  611.     }
  612.  
  613.     TTextTail* pTextTail = itor->second;
  614.  
  615.     if (strlen (c_szName) > 0)
  616.     {
  617.         if (!pTextTail->pOwnerTextInstance)
  618.         {
  619.             pTextTail->pOwnerTextInstance = CGraphicTextInstance::New();
  620.         }
  621.  
  622.         std::string strName = c_szName;
  623.         pTextTail->pOwnerTextInstance->SetTextPointer (ms_pFont);
  624.         pTextTail->pOwnerTextInstance->SetHorizonalAlign (CGraphicTextInstance::HORIZONTAL_ALIGN_CENTER);
  625.         pTextTail->pOwnerTextInstance->SetValue (strName.c_str());
  626.         pTextTail->pOwnerTextInstance->SetColor (1.0f, 1.0f, 0.0f);
  627.         pTextTail->pOwnerTextInstance->Update();
  628.  
  629.         int xOwnerSize, yOwnerSize;
  630.         pTextTail->pOwnerTextInstance->GetTextSize (&xOwnerSize, &yOwnerSize);
  631.         pTextTail->yStart = -2.0f;
  632.         pTextTail->yEnd += float (yOwnerSize + 4);
  633.         pTextTail->xStart = fMIN (pTextTail->xStart, float (-xOwnerSize / 2 - 1));
  634.         pTextTail->xEnd = fMAX (pTextTail->xEnd, float (xOwnerSize / 2 + 1));
  635.     }
  636.     else
  637.     {
  638.         if (pTextTail->pOwnerTextInstance)
  639.         {
  640.             CGraphicTextInstance::Delete (pTextTail->pOwnerTextInstance);
  641.             pTextTail->pOwnerTextInstance = NULL;
  642.         }
  643.  
  644.         int xSize, ySize;
  645.         pTextTail->pTextInstance->GetTextSize (&xSize, &ySize);
  646.         pTextTail->xStart = (float) (-xSize / 2 - 2);
  647.         pTextTail->yStart = -2.0f;
  648.         pTextTail->xEnd = (float) (xSize / 2 + 2);
  649.         pTextTail->yEnd = (float) ySize;
  650.     }
  651. }
  652.  
  653. void CPythonTextTail::DeleteCharacterTextTail (DWORD VirtualID)
  654. {
  655.     auto itorCharacter = m_CharacterTextTailMap.find (VirtualID);
  656.     auto itorChat = m_ChatTailMap.find (VirtualID);
  657.  
  658.     if (m_CharacterTextTailMap.end() != itorCharacter)
  659.     {
  660.         DeleteTextTail (itorCharacter->second);
  661.         m_CharacterTextTailMap.erase (itorCharacter);
  662.     }
  663.     else
  664.     {
  665.         Tracenf ("CPythonTextTail::DeleteCharacterTextTail - Find VID[%d] Error", VirtualID);
  666.     }
  667.  
  668.     if (m_ChatTailMap.end() != itorChat)
  669.     {
  670.         DeleteTextTail (itorChat->second);
  671.         m_ChatTailMap.erase (itorChat);
  672.     }
  673. }
  674.  
  675. void CPythonTextTail::DeleteItemTextTail (DWORD VirtualID)
  676. {
  677.     auto itor = m_ItemTextTailMap.find (VirtualID);
  678.  
  679.     if (m_ItemTextTailMap.end() == itor)
  680.     {
  681.         Tracef (" CPythonTextTail::DeleteItemTextTail - None Item Text Tail\n");
  682.         return;
  683.     }
  684.  
  685.     DeleteTextTail (itor->second);
  686.     m_ItemTextTailMap.erase (itor);
  687. }
  688.  
  689. CPythonTextTail::TTextTail* CPythonTextTail::RegisterTextTail (DWORD dwVirtualID, const char* c_szText, CGraphicObjectInstance* pOwner, float fHeight, const D3DXCOLOR& c_rColor)
  690. {
  691.     TTextTail* pTextTail = m_TextTailPool.Alloc();
  692.  
  693.     pTextTail->dwVirtualID = dwVirtualID;
  694.     pTextTail->pOwner = pOwner;
  695.     pTextTail->pTextInstance = CGraphicTextInstance::New();
  696.     pTextTail->pOwnerTextInstance = NULL;
  697.     pTextTail->fHeight = fHeight;
  698.  
  699.     pTextTail->pTextInstance->SetTextPointer (ms_pFont);
  700.     pTextTail->pTextInstance->SetHorizonalAlign (CGraphicTextInstance::HORIZONTAL_ALIGN_CENTER);
  701.     pTextTail->pTextInstance->SetValue (c_szText);
  702.     pTextTail->pTextInstance->SetColor (c_rColor.r, c_rColor.g, c_rColor.b);
  703.     pTextTail->pTextInstance->Update();
  704.  
  705.     int xSize, ySize;
  706.     pTextTail->pTextInstance->GetTextSize (&xSize, &ySize);
  707.     pTextTail->xStart = (float) (-xSize / 2 - 2);
  708.     pTextTail->yStart = -2.0f;
  709.     pTextTail->xEnd = (float) (xSize / 2 + 2);
  710.     pTextTail->yEnd = (float) ySize;
  711.     pTextTail->Color = c_rColor;
  712.     pTextTail->fDistanceFromPlayer = 0.0f;
  713.     pTextTail->x = -100.0f;
  714.     pTextTail->y = -100.0f;
  715.     pTextTail->z = 0.0f;
  716.     pTextTail->pMarkInstance = NULL;
  717.     pTextTail->pGuildNameTextInstance = NULL;
  718.     pTextTail->pTitleTextInstance = NULL;
  719.     pTextTail->pLevelTextInstance = NULL;
  720.     return pTextTail;
  721. }
  722.  
  723. void CPythonTextTail::DeleteTextTail (TTextTail* pTextTail)
  724. {
  725.     if (pTextTail->pTextInstance)
  726.     {
  727.         CGraphicTextInstance::Delete (pTextTail->pTextInstance);
  728.         pTextTail->pTextInstance = NULL;
  729.     }
  730.  
  731.     if (pTextTail->pOwnerTextInstance)
  732.     {
  733.         CGraphicTextInstance::Delete (pTextTail->pOwnerTextInstance);
  734.         pTextTail->pOwnerTextInstance = NULL;
  735.     }
  736.  
  737.     if (pTextTail->pMarkInstance)
  738.     {
  739.         CGraphicMarkInstance::Delete (pTextTail->pMarkInstance);
  740.         pTextTail->pMarkInstance = NULL;
  741.     }
  742.  
  743.     if (pTextTail->pGuildNameTextInstance)
  744.     {
  745.         CGraphicTextInstance::Delete (pTextTail->pGuildNameTextInstance);
  746.         pTextTail->pGuildNameTextInstance = NULL;
  747.     }
  748.  
  749.     if (pTextTail->pTitleTextInstance)
  750.     {
  751.         CGraphicTextInstance::Delete (pTextTail->pTitleTextInstance);
  752.         pTextTail->pTitleTextInstance = NULL;
  753.     }
  754.  
  755.     if (pTextTail->pLevelTextInstance)
  756.     {
  757.         CGraphicTextInstance::Delete (pTextTail->pLevelTextInstance);
  758.         pTextTail->pLevelTextInstance = NULL;
  759.     }
  760.  
  761.     m_TextTailPool.Free (pTextTail);
  762. }
  763.  
  764. int CPythonTextTail::Pick (int ixMouse, int iyMouse)
  765. {
  766.     for (auto itor = m_ItemTextTailMap.begin(); itor != m_ItemTextTailMap.end(); ++itor)
  767.     {
  768.         TTextTail* pTextTail = itor->second;
  769.         if (ixMouse >= pTextTail->x + pTextTail->xStart && ixMouse <= pTextTail->x + pTextTail->xEnd && iyMouse >= pTextTail->y + pTextTail->yStart && iyMouse <= pTextTail->y + pTextTail->yEnd)
  770.         {
  771.             SelectItemName (itor->first);
  772.             return (itor->first);
  773.         }
  774.     }
  775.  
  776.     return -1;
  777. }
  778.  
  779. void CPythonTextTail::SelectItemName (DWORD dwVirtualID)
  780. {
  781.     auto itor = m_ItemTextTailMap.find (dwVirtualID);
  782.  
  783.     if (m_ItemTextTailMap.end() == itor)
  784.     {
  785.         return;
  786.     }
  787.  
  788.     TTextTail* pTextTail = itor->second;
  789.     pTextTail->pTextInstance->SetColor (0.1f, 0.9f, 0.1f);
  790. }
  791.  
  792. void CPythonTextTail::AttachTitle (DWORD dwVID, const char* c_szName, const D3DXCOLOR& c_rColor)
  793. {
  794.     if (!bPKTitleEnable)
  795.     {
  796.         return;
  797.     }
  798.  
  799.     auto itor = m_CharacterTextTailMap.find (dwVID);
  800.     if (m_CharacterTextTailMap.end() == itor)
  801.     {
  802.         return;
  803.     }
  804.  
  805.     TTextTail* pTextTail = itor->second;
  806.  
  807.     CGraphicTextInstance*& prTitle = pTextTail->pTitleTextInstance;
  808.     if (!prTitle)
  809.     {
  810.         prTitle = CGraphicTextInstance::New();
  811.         prTitle->SetTextPointer (ms_pFont);
  812.         prTitle->SetOutline (true);
  813.  
  814.         prTitle->SetHorizonalAlign (CGraphicTextInstance::HORIZONTAL_ALIGN_RIGHT);
  815.         prTitle->SetVerticalAlign (CGraphicTextInstance::VERTICAL_ALIGN_BOTTOM);
  816.     }
  817.  
  818.     prTitle->SetValue (c_szName);
  819.     prTitle->SetColor (c_rColor.r, c_rColor.g, c_rColor.b);
  820.     prTitle->Update();
  821. }
  822.  
  823. void CPythonTextTail::DetachTitle (DWORD dwVID)
  824. {
  825.     if (!bPKTitleEnable)
  826.     {
  827.         return;
  828.     }
  829.  
  830.     auto itor = m_CharacterTextTailMap.find (dwVID);
  831.     if (m_CharacterTextTailMap.end() == itor)
  832.     {
  833.         return;
  834.     }
  835.  
  836.     TTextTail* pTextTail = itor->second;
  837.  
  838.     if (pTextTail->pTitleTextInstance)
  839.     {
  840.         CGraphicTextInstance::Delete (pTextTail->pTitleTextInstance);
  841.         pTextTail->pTitleTextInstance = NULL;
  842.     }
  843. }
  844.  
  845. void CPythonTextTail::EnablePKTitle (BOOL bFlag)
  846. {
  847.     bPKTitleEnable = bFlag;
  848. }
  849.  
  850. void CPythonTextTail::AttachLevel (DWORD dwVID, const char* c_szText, const D3DXCOLOR& c_rColor)
  851. {
  852.     if (!bPKTitleEnable)
  853.     {
  854.         return;
  855.     }
  856.  
  857.     auto itor = m_CharacterTextTailMap.find (dwVID);
  858.     if (m_CharacterTextTailMap.end() == itor)
  859.     {
  860.         return;
  861.     }
  862.  
  863.     TTextTail* pTextTail = itor->second;
  864.     CGraphicTextInstance*& prLevel = pTextTail->pLevelTextInstance;
  865.  
  866.     if (!prLevel)
  867.     {
  868.         prLevel = CGraphicTextInstance::New();
  869.         prLevel->SetTextPointer (ms_pFont);
  870.         prLevel->SetOutline (true);
  871.  
  872.         prLevel->SetHorizonalAlign (CGraphicTextInstance::HORIZONTAL_ALIGN_RIGHT);
  873.         prLevel->SetVerticalAlign (CGraphicTextInstance::VERTICAL_ALIGN_BOTTOM);
  874.     }
  875.  
  876.     prLevel->SetValue (c_szText);
  877.     prLevel->SetColor (c_rColor.r, c_rColor.g, c_rColor.b);
  878.     prLevel->Update();
  879. }
  880.  
  881. void CPythonTextTail::DetachLevel (DWORD dwVID)
  882. {
  883.     if (!bPKTitleEnable)
  884.     {
  885.         return;
  886.     }
  887.  
  888.     auto itor = m_CharacterTextTailMap.find (dwVID);
  889.     if (m_CharacterTextTailMap.end() == itor)
  890.     {
  891.         return;
  892.     }
  893.  
  894.     TTextTail* pTextTail = itor->second;
  895.  
  896.     if (pTextTail->pLevelTextInstance)
  897.     {
  898.         CGraphicTextInstance::Delete (pTextTail->pLevelTextInstance);
  899.         pTextTail->pLevelTextInstance = NULL;
  900.     }
  901. }
  902.  
  903. void CPythonTextTail::Initialize()
  904. {
  905.     CGraphicText* pkDefaultFont = static_cast<CGraphicText*> (DefaultFont_GetResource());
  906.     if (!pkDefaultFont)
  907.     {
  908.         TraceError ("CPythonTextTail::Initialize - CANNOT_FIND_DEFAULT_FONT");
  909.         return;
  910.     }
  911.  
  912.     ms_pFont = pkDefaultFont;
  913. }
  914.  
  915. void CPythonTextTail::Destroy()
  916. {
  917.     m_TextTailPool.Clear();
  918. }
  919.  
  920. void CPythonTextTail::Clear()
  921. {
  922.     m_CharacterTextTailMap.clear();
  923.     m_CharacterTextTailList.clear();
  924.     m_ItemTextTailMap.clear();
  925.     m_ItemTextTailList.clear();
  926.     m_ChatTailMap.clear();
  927.     m_TextTailPool.Clear();
  928. }
  929.  
  930. CPythonTextTail::CPythonTextTail()
  931. {
  932.     Clear();
  933. }
  934.  
  935. CPythonTextTail::~CPythonTextTail()
  936. {
  937.     Destroy();
  938. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
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!