API tools faq
paste
hfwhite

war_map.cpp

hfwhite
Jul 28th, 2025
275
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 27.96 KB | Gaming | 0 0
raw download clone embed print report
  1. #include "stdafx.h"
  2. #include "war_map.h"
  3. #include "sectree_manager.h"
  4. #include "char.h"
  5. #include "char_manager.h"
  6. #include "affect.h"
  7. #include "item.h"
  8. #include "config.h"
  9. #include "desc.h"
  10. #include "desc_manager.h"
  11. #include "guild_manager.h"
  12. #include "buffer_manager.h"
  13. #include "db.h"
  14. #include "packet.h"
  15. #include "locale_service.h"
  16. #include "questmanager.h"
  17.  
  18. EVENTINFO(war_map_info)
  19. {
  20.     int iStep;
  21.     CWarMap * pWarMap;
  22.  
  23.     war_map_info()
  24.     : iStep( 0 )
  25.     , pWarMap( 0 )
  26.     {
  27.     }
  28. };
  29.  
  30. EVENTFUNC(war_begin_event)
  31. {
  32.     war_map_info* info = dynamic_cast<war_map_info*>( event->info );
  33.  
  34.     if ( info == NULL )
  35.     {
  36.         sys_err( "war_begin_event> <Factor> Null pointer" );
  37.         return 0;
  38.     }
  39.  
  40.     CWarMap * pMap = info->pWarMap;
  41.     pMap->CheckWarEnd();
  42.     return PASSES_PER_SEC(10);
  43. }
  44.  
  45. EVENTFUNC(war_begin_protection_event)
  46. {
  47.     war_map_info* info = dynamic_cast<war_map_info*>(event->info);
  48.  
  49.     if (info == NULL)
  50.     {
  51.         sys_err( "war_begin_protection_event> <Factor> Null pointer" );
  52.         return 0;
  53.     }
  54.  
  55.     CWarMap* pMap = info->pWarMap;
  56.  
  57.     if (pMap->GetBeginProtectionStatus() == false)
  58.     {
  59.         DWORD dwElapsedTime = get_dword_time() - pMap->GetStartTime();
  60.         if (dwElapsedTime >= 180000) {
  61.             pMap->SetBeginProtectionStatus(true);
  62.             pMap->Notice("Savas basladi!");
  63.             SECTREE_MANAGER::instance().PurgeNPCsInMap(pMap->GetMapIndex());
  64.         }
  65.         else {
  66.             char szNoticeText[512];
  67.             snprintf(szNoticeText, sizeof(szNoticeText), "Savas %ld saniye icinde baslayacak.", 179 - (dwElapsedTime / 1000));
  68.             pMap->Notice(szNoticeText);
  69.         }
  70.     }
  71.  
  72.     return PASSES_PER_SEC(1);
  73. }
  74.  
  75. EVENTFUNC(war_end_event)
  76. {
  77.     war_map_info* info = dynamic_cast<war_map_info*>( event->info );
  78.  
  79.     if ( info == NULL )
  80.     {
  81.         sys_err( "war_end_event> <Factor> Null pointer" );
  82.         return 0;
  83.     }
  84.  
  85.     CWarMap * pMap = info->pWarMap;
  86.  
  87.     if (info->iStep == 0)
  88.     {
  89.         ++info->iStep;
  90.         pMap->ExitAll();
  91.         return PASSES_PER_SEC(5);
  92.     }
  93.     else
  94.     {
  95.         pMap->SetEndEvent(NULL);
  96.         CWarMapManager::instance().DestroyWarMap(pMap);
  97.         return 0;
  98.     }
  99. }
  100.  
  101. EVENTFUNC(war_timeout_event)
  102. {
  103.     war_map_info* info = dynamic_cast<war_map_info*>( event->info );
  104.  
  105.     if ( info == NULL )
  106.     {
  107.         sys_err( "war_timeout_event> <Factor> Null pointer" );
  108.         return 0;
  109.     }
  110.  
  111.     CWarMap * pMap = info->pWarMap;
  112.     pMap->Timeout();
  113.     return 0;
  114. }
  115.  
  116. void CWarMap::STeamData::Initialize()
  117. {
  118.     dwID = 0;
  119.     pkGuild = NULL;
  120.     iMemberCount = 0;
  121.     iUsePotionPrice = 0;
  122.     iScore = 0;
  123.     pkChrFlag = NULL;
  124.     pkChrFlagBase = NULL;
  125.  
  126.     set_pidJoiner.clear();
  127. }
  128.  
  129. CWarMap::CWarMap(long lMapIndex, const TGuildWarInfo & r_info, TWarMapInfo * pkWarMapInfo, DWORD dwGuildID1, DWORD dwGuildID2)
  130. {
  131.     m_kMapInfo = *pkWarMapInfo;
  132.     m_kMapInfo.lMapIndex = lMapIndex;
  133.  
  134.     memcpy(&m_WarInfo, &r_info, sizeof(TGuildWarInfo));
  135.  
  136.     m_TeamData[0].Initialize();
  137.     m_TeamData[0].dwID = dwGuildID1;
  138.     m_TeamData[0].pkGuild = CGuildManager::instance().TouchGuild(dwGuildID1);
  139.  
  140.     m_TeamData[1].Initialize();
  141.     m_TeamData[1].dwID = dwGuildID2;
  142.     m_TeamData[1].pkGuild = CGuildManager::instance().TouchGuild(dwGuildID2);
  143.     m_iObserverCount = 0;
  144.  
  145.     war_map_info* info = AllocEventInfo<war_map_info>();
  146.     info->pWarMap = this;
  147.  
  148.     SetBeginEvent(event_create(war_begin_event, info, PASSES_PER_SEC(60)));
  149.  
  150.     m_pkEndEvent = NULL;
  151.     m_pkTimeoutEvent = NULL;
  152.     m_pkResetFlagEvent = NULL;
  153.     m_bTimeout = false;
  154.     m_dwStartTime = get_dword_time();
  155.     m_bEnded = false;
  156.     m_bBeginProtectionCompleted = false;
  157.  
  158.     if (GetType() == WAR_MAP_TYPE_FLAG)
  159.     {
  160.         AddFlagBase(0);
  161.         AddFlagBase(1);
  162.         AddFlag(0);
  163.         AddFlag(1);
  164.     }
  165.  
  166.     CHARACTER_MANAGER::instance().SpawnMob(20387, GetMapIndex(), 127 * 100 + 32000, 102 * 100 + 0, 2, false, 225, true);
  167.     CHARACTER_MANAGER::instance().SpawnMob(20387, GetMapIndex(), 120 * 100 + 32000, 109 * 100 + 0, 2, false, 225, true);
  168.     CHARACTER_MANAGER::instance().SpawnMob(20387, GetMapIndex(), 115 * 100 + 32000, 114 * 100 + 0, 2, false, 225, true);
  169.     CHARACTER_MANAGER::instance().SpawnMob(20387, GetMapIndex(), 109 * 100 + 32000, 120 * 100 + 0, 2, false, 225, true);
  170.     CHARACTER_MANAGER::instance().SpawnMob(20387, GetMapIndex(), 103 * 100 + 32000, 126 * 100 + 0, 2, false, 225, true);
  171.     CHARACTER_MANAGER::instance().SpawnMob(20387, GetMapIndex(), 99 * 100 + 32000, 130 * 100 + 0, 2, false, 225, true);
  172.  
  173.     CHARACTER_MANAGER::instance().SpawnMob(20387, GetMapIndex(), 156 * 100 + 32000, 129 * 100 + 0, 2, false, 225, true);
  174.     CHARACTER_MANAGER::instance().SpawnMob(20387, GetMapIndex(), 151 * 100 + 32000, 134 * 100 + 0, 2, false, 225, true);
  175.     CHARACTER_MANAGER::instance().SpawnMob(20387, GetMapIndex(), 146 * 100 + 32000, 139 * 100 + 0, 2, false, 225, true);
  176.     CHARACTER_MANAGER::instance().SpawnMob(20387, GetMapIndex(), 141 * 100 + 32000, 144 * 100 + 0, 2, false, 225, true);
  177.     CHARACTER_MANAGER::instance().SpawnMob(20387, GetMapIndex(), 134 * 100 + 32000, 151 * 100 + 0, 2, false, 225, true);
  178.  
  179.     sys_log(0, "calisti 1");
  180. }
  181.  
  182. CWarMap::~CWarMap()
  183. {
  184.     event_cancel(&m_pkBeginEvent);
  185.     event_cancel(&m_pkBeginProtectionEvent);
  186.     event_cancel(&m_pkEndEvent);
  187.     event_cancel(&m_pkTimeoutEvent);
  188.     event_cancel(&m_pkResetFlagEvent);
  189.  
  190.     sys_log(0, "WarMap::~WarMap : map index %d", GetMapIndex());
  191.  
  192.     itertype(m_set_pkChr) it = m_set_pkChr.begin();
  193.  
  194.     while (it != m_set_pkChr.end())
  195.     {
  196.         LPCHARACTER ch = *(it++);
  197.  
  198.         if (ch->GetDesc())
  199.         {
  200.             sys_log(0, "WarMap::~WarMap : disconnecting %s", ch->GetName());
  201.             DESC_MANAGER::instance().DestroyDesc(ch->GetDesc());
  202.         }
  203.     }
  204.  
  205.     m_set_pkChr.clear();
  206. }
  207.  
  208. void CWarMap::SetBeginEvent(LPEVENT pkEv)
  209. {
  210.     if (m_pkBeginEvent != NULL) {
  211.         event_cancel(&m_pkBeginEvent);
  212.     }
  213.     if (pkEv != NULL) {
  214.         m_pkBeginEvent = pkEv;
  215.     }
  216. }
  217.  
  218. void CWarMap::SetBeginProtectionEvent(LPEVENT pkEv)
  219. {
  220.     if (m_pkBeginProtectionEvent != NULL) {
  221.         event_cancel(&m_pkBeginProtectionEvent);
  222.     }
  223.     if (pkEv != NULL) {
  224.         m_pkBeginProtectionEvent = pkEv;
  225.     }
  226. }
  227.  
  228. void CWarMap::SetEndEvent(LPEVENT pkEv)
  229. {
  230.     if (m_pkEndEvent != NULL) {
  231.         event_cancel(&m_pkEndEvent);
  232.     }
  233.     if (pkEv != NULL) {
  234.         m_pkEndEvent = pkEv;
  235.     }
  236. }
  237.  
  238. void CWarMap::SetTimeoutEvent(LPEVENT pkEv)
  239. {
  240.     if (m_pkTimeoutEvent != NULL) {
  241.         event_cancel(&m_pkTimeoutEvent);
  242.     }
  243.     if (pkEv != NULL) {
  244.         m_pkTimeoutEvent = pkEv;
  245.     }
  246. }
  247.  
  248. void CWarMap::SetResetFlagEvent(LPEVENT pkEv)
  249. {
  250.     if (m_pkResetFlagEvent != NULL) {
  251.         event_cancel(&m_pkResetFlagEvent);
  252.     }
  253.     if (pkEv != NULL) {
  254.         m_pkResetFlagEvent = pkEv;
  255.     }
  256. }
  257.  
  258. bool CWarMap::GetTeamIndex(DWORD dwGuildID, BYTE & bIdx)
  259. {
  260.     if (m_TeamData[0].dwID == dwGuildID)
  261.     {
  262.         bIdx = 0;
  263.         return true;
  264.     }
  265.     else if (m_TeamData[1].dwID == dwGuildID)
  266.     {
  267.         bIdx = 1;
  268.         return true;
  269.     }
  270.  
  271.     return false;
  272. }
  273.  
  274. DWORD CWarMap::GetGuildID(BYTE bIdx)
  275. {
  276.     assert(bIdx < 2);
  277.     return m_TeamData[bIdx].dwID;
  278. }
  279.  
  280. int CWarMap::GetCurrentPlayer(BYTE bIdx)
  281. {
  282.     assert(bIdx < 2);
  283.     return m_TeamData[bIdx].iMemberCount;
  284. }
  285.  
  286. CGuild * CWarMap::GetGuild(BYTE bIdx)
  287. {
  288.     return m_TeamData[bIdx].pkGuild;
  289. }
  290.  
  291. long CWarMap::GetMapIndex()
  292. {
  293.     return m_kMapInfo.lMapIndex;
  294. }
  295.  
  296. BYTE CWarMap::GetType()
  297. {
  298.     return m_kMapInfo.bType;
  299. }
  300.  
  301. DWORD CWarMap::GetGuildOpponent(LPCHARACTER ch)
  302. {
  303.     if (ch->GetGuild())
  304.     {
  305.         DWORD gid = ch->GetGuild()->GetID();
  306.         BYTE idx;
  307.  
  308.         if (GetTeamIndex(gid, idx))
  309.             return m_TeamData[!idx].dwID;
  310.     }
  311.     return 0;
  312. }
  313.  
  314. DWORD CWarMap::GetWinnerGuild()
  315. {
  316.     DWORD win_gid = 0;
  317.  
  318.     if (m_TeamData[1].iScore > m_TeamData[0].iScore)
  319.     {
  320.         win_gid = m_TeamData[1].dwID;
  321.     }
  322.     else if (m_TeamData[0].iScore > m_TeamData[1].iScore)
  323.     {
  324.         win_gid = m_TeamData[0].dwID;
  325.     }
  326.  
  327.     return (win_gid);
  328. }
  329.  
  330. void CWarMap::UsePotion(LPCHARACTER ch, LPITEM item)
  331. {
  332.     if (m_pkEndEvent)
  333.         return;
  334.  
  335.     if (ch->IsObserverMode())
  336.         return;
  337.  
  338.     if (!ch->GetGuild())
  339.         return;
  340.  
  341.     if (!item->GetProto())
  342.         return;
  343.  
  344.     int iPrice = item->GetProto()->dwGold;
  345.  
  346.     DWORD gid = ch->GetGuild()->GetID();
  347.  
  348.     if (gid == m_TeamData[0].dwID)
  349.         m_TeamData[0].iUsePotionPrice += iPrice;
  350.     else if (gid == m_TeamData[1].dwID)
  351.         m_TeamData[1].iUsePotionPrice += iPrice;
  352. }
  353.  
  354. int CWarMap::STeamData::GetAccumulatedJoinerCount()
  355. {
  356.     return set_pidJoiner.size();
  357. }
  358.  
  359. int CWarMap::STeamData::GetCurJointerCount()
  360. {
  361.     return iMemberCount;
  362. }
  363.  
  364. void CWarMap::STeamData::AppendMember(LPCHARACTER ch)
  365. {
  366.     set_pidJoiner.insert(ch->GetPlayerID());
  367.     ++iMemberCount;
  368. }
  369.  
  370. void CWarMap::STeamData::RemoveMember(LPCHARACTER ch)
  371. {
  372.     /* Lonca Sava?dan C©¥kanlar©¥ eksiltmeme sorunu Fixed // LONCASAVASDANCIKANOYUNCUCOUNT // 21.10.17 - 00:07 */
  373.     set_pidJoiner.erase(ch->GetPlayerID());
  374.     --iMemberCount;
  375. }
  376.  
  377.  
  378. struct FSendUserCount
  379. {
  380.     char buf1[30];
  381.     char buf2[128];
  382.  
  383.     FSendUserCount(DWORD g1, int g1_count, DWORD g2, int g2_count, int observer)
  384.     {
  385.         snprintf(buf1, sizeof(buf1), "ObserverCount %d", observer);
  386.         snprintf(buf2, sizeof(buf2), "WarUC %u %d %u %d %d", g1, g1_count, g2, g2_count, observer);
  387.     }
  388.  
  389.     void operator() (LPCHARACTER ch)
  390.     {
  391.         ch->ChatPacket(CHAT_TYPE_COMMAND, buf1);
  392.         ch->ChatPacket(CHAT_TYPE_COMMAND, buf2);
  393.     }
  394. };
  395.  
  396. void CWarMap::UpdateUserCount()
  397. {
  398.     FSendUserCount f(
  399.             m_TeamData[0].dwID,
  400.             m_TeamData[0].GetAccumulatedJoinerCount(),
  401.             m_TeamData[1].dwID,
  402.             m_TeamData[1].GetAccumulatedJoinerCount(),
  403.             m_iObserverCount);
  404.  
  405.     std::for_each(m_set_pkChr.begin(), m_set_pkChr.end(), f);
  406. }
  407.  
  408. struct FSendWarKillNotice
  409. {
  410.     char buf[512];
  411.  
  412.     FSendWarKillNotice(const char * c_szKillerName, const char * c_szVictimName, DWORD dwKillerRace, DWORD dwVictimRace) {
  413.         snprintf(buf, sizeof(buf), "GW_Kill_Update %s %u %s %u", c_szKillerName, dwKillerRace, c_szVictimName, dwVictimRace);
  414.     }
  415.  
  416.     void operator() (LPCHARACTER ch) {
  417.         ch->ChatPacket(CHAT_TYPE_COMMAND, buf);
  418.     }
  419. };
  420.  
  421. void CWarMap::SendKillNotice(const char * c_szKillerName, const char * c_szVictimName, DWORD dwKillerRace, DWORD dwVictimRace)
  422. {
  423.     FSendWarKillNotice f(c_szKillerName, c_szVictimName, dwKillerRace, dwVictimRace);
  424.     std::for_each(m_set_pkChr.begin(), m_set_pkChr.end(), f);
  425. }
  426.  
  427. void CWarMap::IncMember(LPCHARACTER ch)
  428. {
  429.     war_map_info* info = AllocEventInfo<war_map_info>();
  430.     info->pWarMap = this;
  431.  
  432.     if (!ch->IsPC())
  433.         return;
  434.  
  435.     sys_log(0, "WarMap::IncMember");
  436.     DWORD gid = 0;
  437.  
  438.     if (ch->GetGuild())
  439.         gid = ch->GetGuild()->GetID();
  440.  
  441.     bool isWarMember = ch->GetQuestFlag("war.is_war_member") > 0 ? true : false;
  442.  
  443.     if (isWarMember && gid != m_TeamData[0].dwID && gid != m_TeamData[1].dwID)
  444.     {
  445.         ch->SetQuestFlag("war.is_war_member", 0);
  446.         isWarMember = false;
  447.     }
  448.  
  449.     if (isWarMember)
  450.     {
  451.         if (m_set_pkChr.empty()) {
  452.             m_dwFirstLogonTime = get_dword_time();
  453.             SetBeginProtectionEvent(event_create(war_begin_protection_event, info, PASSES_PER_SEC(150)));
  454.         }
  455.  
  456.         if (gid == m_TeamData[0].dwID)
  457.         {
  458.             m_TeamData[0].AppendMember(ch);
  459.  
  460.         }
  461.         else if (gid == m_TeamData[1].dwID)
  462.         {
  463.             m_TeamData[1].AppendMember(ch);
  464.  
  465.         }
  466.  
  467.         event_cancel(&m_pkTimeoutEvent);
  468.  
  469.         sys_log(0, "WarMap +m %u(cur:%d, acc:%d) vs %u(cur:%d, acc:%d)",
  470.                 m_TeamData[0].dwID, m_TeamData[0].GetCurJointerCount(), m_TeamData[0].GetAccumulatedJoinerCount(),
  471.                 m_TeamData[1].dwID, m_TeamData[1].GetCurJointerCount(), m_TeamData[1].GetAccumulatedJoinerCount());
  472.     }
  473.     else
  474.     {
  475.         ++m_iObserverCount;
  476.         sys_log(0, "WarMap +o %d", m_iObserverCount);
  477.         ch->SetObserverMode(true);
  478.         ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("°üÀü ¸ğµå·Î ±æµåÀü¿¡ Âü°¡Çϼ̽À´Ï´Ù."));
  479.         ch->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("ÀÚ½ÅÀ» ¼±ÅÃÇÏ½Ã¸é ¹ÛÀ¸·Î ³ª°¥ ¼ö ÀÖ´Â <°ü¶÷ Á¾·á> ¹öÆ°ÀÌ ³ª¿É´Ï´Ù."));
  480.     }
  481.  
  482.     UpdateUserCount();
  483.  
  484.     m_set_pkChr.insert(ch);
  485.  
  486.     LPDESC d = ch->GetDesc();
  487.  
  488.     SendWarPacket(d);
  489.     SendScorePacket(0, d);
  490.     SendScorePacket(1, d);
  491. }
  492.  
  493. void CWarMap::DecMember(LPCHARACTER ch)
  494. {
  495.     if (!ch->IsPC())
  496.         return;
  497.  
  498.     sys_log(0, "WarMap::DecMember");
  499.     DWORD gid = 0;
  500.  
  501.     if (ch->GetGuild())
  502.         gid = ch->GetGuild()->GetID();
  503.  
  504.     if (!ch->IsObserverMode())
  505.     {
  506.         if (gid == m_TeamData[0].dwID)
  507.             m_TeamData[0].RemoveMember(ch);
  508.         else if (gid == m_TeamData[1].dwID)
  509.             m_TeamData[1].RemoveMember(ch);
  510.  
  511.         if (m_kMapInfo.bType == WAR_MAP_TYPE_FLAG)
  512.         {
  513.             CAffect * pkAff = ch->FindAffect(AFFECT_WAR_FLAG);
  514.  
  515.             if (pkAff)
  516.             {
  517.                 BYTE idx;
  518.  
  519.                 if (GetTeamIndex(pkAff->lApplyValue, idx))
  520.                     AddFlag(idx, ch->GetX(), ch->GetY());
  521.  
  522.                 ch->RemoveAffect(AFFECT_WAR_FLAG);
  523.             }
  524.         }
  525.  
  526.         sys_log(0, "WarMap -m %u(cur:%d, acc:%d) vs %u(cur:%d, acc:%d)",
  527.                 m_TeamData[0].dwID, m_TeamData[0].GetCurJointerCount(), m_TeamData[0].GetAccumulatedJoinerCount(),
  528.                 m_TeamData[1].dwID, m_TeamData[1].GetCurJointerCount(), m_TeamData[1].GetAccumulatedJoinerCount());
  529.  
  530.         CheckWarEnd();
  531.         ch->SetQuestFlag("war.is_war_member", 0);
  532.     }
  533.     else
  534.     {
  535.         --m_iObserverCount;
  536.  
  537.         sys_log(0, "WarMap -o %d", m_iObserverCount);
  538.         ch->SetObserverMode(false);
  539.         ch->SetQuestFlag("atakan_izleyici_engel", 0);
  540.     }
  541.  
  542.     UpdateUserCount();
  543.  
  544.     m_set_pkChr.erase(ch);
  545. }
  546.  
  547. DWORD CWarMap::GetStartTime()
  548. {
  549.     return m_dwFirstLogonTime;
  550. }
  551.  
  552. bool CWarMap::GetBeginProtectionStatus()
  553. {
  554.     return m_bBeginProtectionCompleted;
  555. }
  556.  
  557. void CWarMap::SetBeginProtectionStatus(bool bNewStat)
  558. {
  559.     m_bBeginProtectionCompleted = bNewStat;
  560. }
  561.  
  562. struct FExitGuildWar
  563. {
  564.     void operator() (LPCHARACTER ch)
  565.     {
  566.         if (ch->IsPC())
  567.         {
  568.             ch->ExitToSavedLocation();
  569.         }
  570.     }
  571. };
  572.  
  573. void CWarMap::ExitAll()
  574. {
  575.     FExitGuildWar f;
  576.     std::for_each(m_set_pkChr.begin(), m_set_pkChr.end(), f);
  577. }
  578.  
  579. void CWarMap::CheckWarEnd()
  580. {
  581.     if (m_bEnded)
  582.         return;
  583.  
  584.     if (m_TeamData[0].iMemberCount == 0 || m_TeamData[1].iMemberCount == 0)
  585.     {
  586.         if (m_bTimeout)
  587.             return;
  588.  
  589.         if (m_pkTimeoutEvent)
  590.             return;
  591.  
  592.         Notice(LC_TEXT("±æµåÀü¿¡ Âü°¡ÇÑ »ó´ë¹æ ±æµå¿øÀÌ ¾Æ¹«µµ ¾ø½À´Ï´Ù."));
  593.         Notice(LC_TEXT("1ºĞ À̳»¿¡ ¾Æ¹«µµ Á¢¼ÓÇÏÁö ¾ÊÀ¸¸é ±æµåÀüÀÌ ÀÚµ¿ Á¾·áµË´Ï´Ù."));
  594.  
  595.         sys_log(0, "CheckWarEnd: Timeout begin %u vs %u", m_TeamData[0].dwID, m_TeamData[1].dwID);
  596.  
  597.         war_map_info* info = AllocEventInfo<war_map_info>();
  598.         info->pWarMap = this;
  599.  
  600.         SetTimeoutEvent(event_create(war_timeout_event, info, PASSES_PER_SEC(60)));
  601.     }
  602.     else
  603.         CheckScore();
  604. }
  605.  
  606. int CWarMap::GetRewardGold(BYTE bWinnerIdx)
  607. {
  608.     int iRewardGold = m_WarInfo.iWarPrice;
  609.     iRewardGold += (m_TeamData[bWinnerIdx].iUsePotionPrice * m_WarInfo.iWinnerPotionRewardPctToWinner) / 100;
  610.     iRewardGold += (m_TeamData[bWinnerIdx ? 0 : 1].iUsePotionPrice * m_WarInfo.iLoserPotionRewardPctToWinner) / 100;
  611.     return iRewardGold;
  612. }
  613.  
  614. void CWarMap::Draw()
  615. {
  616.     CGuildManager::instance().RequestWarOver(m_TeamData[0].dwID, m_TeamData[1].dwID, 0, 0);
  617. }
  618.  
  619. void CWarMap::Timeout()
  620. {
  621.     SetTimeoutEvent(NULL);
  622.  
  623.     if (m_bTimeout)
  624.         return;
  625.  
  626.     if (m_bEnded)
  627.         return;
  628.  
  629.     DWORD dwWinner = 0;
  630.     DWORD dwLoser = 0;
  631.     int iRewardGold = 0;
  632.  
  633.     if (get_dword_time() - m_dwStartTime < 60000 * 5)
  634.     {
  635.         Notice(LC_TEXT("±æµåÀüÀÌ ÀÏÂï Á¾·áµÇ¾î ¹«½ÂºÎ·Î ÆÇÁ¤ µÇ¾ú½À´Ï´Ù. (5ºĞÀÌ Áö³ªÁö ¾ÊÀ½)"));
  636.         dwWinner = 0;
  637.         dwLoser = 0;
  638.     }
  639.     else
  640.     {
  641.         int iWinnerIdx = -1;
  642.  
  643.         if (m_TeamData[0].iMemberCount == 0)
  644.             iWinnerIdx = 1;
  645.         else if (m_TeamData[1].iMemberCount == 0)
  646.             iWinnerIdx = 0;
  647.  
  648.         if (iWinnerIdx == -1)
  649.         {
  650.             dwWinner = GetWinnerGuild();
  651.  
  652.             if (dwWinner == m_TeamData[0].dwID)
  653.             {
  654.                 iRewardGold = GetRewardGold(0);
  655.                 dwLoser = m_TeamData[1].dwID;
  656.             }
  657.             else if (dwWinner == m_TeamData[1].dwID)
  658.             {
  659.                 iRewardGold = GetRewardGold(1);
  660.                 dwLoser = m_TeamData[0].dwID;
  661.             }
  662.  
  663.             sys_err("WarMap: member count is not zero, guild1 %u %d guild2 %u %d, winner %u",
  664.                     m_TeamData[0].dwID, m_TeamData[0].iMemberCount,
  665.                     m_TeamData[1].dwID, m_TeamData[1].iMemberCount,
  666.                     dwWinner);
  667.         }
  668.         else
  669.         {
  670.             dwWinner = m_TeamData[iWinnerIdx].dwID;
  671.             dwLoser = m_TeamData[iWinnerIdx == 0 ? 1 : 0].dwID;
  672.  
  673.             iRewardGold = GetRewardGold(iWinnerIdx);
  674.         }
  675.     }
  676.  
  677.     sys_log(0, "WarMap: Timeout %u %u winner %u loser %u reward %d map %d",
  678.             m_TeamData[0].dwID, m_TeamData[1].dwID, dwWinner, dwLoser, iRewardGold, m_kMapInfo.lMapIndex);
  679.  
  680.     if (dwWinner)
  681.         CGuildManager::instance().RequestWarOver(dwWinner, dwLoser, dwWinner, iRewardGold);
  682.     else
  683.         CGuildManager::instance().RequestWarOver(m_TeamData[0].dwID, m_TeamData[1].dwID, dwWinner, iRewardGold);
  684.  
  685.     m_bTimeout = true;
  686. }
  687.  
  688. namespace
  689. {
  690.     struct FPacket
  691.     {
  692.         FPacket(const void * p, int size) : m_pvData(p), m_iSize(size)
  693.         {
  694.         }
  695.  
  696.         void operator () (LPCHARACTER ch)
  697.         {
  698.             ch->GetDesc()->Packet(m_pvData, m_iSize);
  699.         }
  700.  
  701.         const void * m_pvData;
  702.         int m_iSize;
  703.     };
  704.  
  705.     struct FNotice
  706.     {
  707.         FNotice(const char * psz) : m_psz(psz)
  708.         {
  709.         }
  710.  
  711.         void operator() (LPCHARACTER ch)
  712.         {
  713.             ch->ChatPacket(CHAT_TYPE_NOTICE, "%s", m_psz);
  714.         }
  715.  
  716.         const char * m_psz;
  717.     };
  718. };
  719.  
  720. void CWarMap::Notice(const char * psz)
  721. {
  722.     FNotice f(psz);
  723.     std::for_each(m_set_pkChr.begin(), m_set_pkChr.end(), f);
  724. }
  725.  
  726.  
  727. void CWarMap::Packet(const void * p, int size)
  728. {
  729.     FPacket f(p, size);
  730.     std::for_each(m_set_pkChr.begin(), m_set_pkChr.end(), f);
  731. }
  732.  
  733. void CWarMap::SendWarPacket(LPDESC d)
  734. {
  735.     TPacketGCGuild pack;
  736.     TPacketGCGuildWar pack2;
  737.  
  738.     pack.header     = HEADER_GC_GUILD;
  739.     pack.subheader  = GUILD_SUBHEADER_GC_WAR;
  740.     pack.size       = sizeof(pack) + sizeof(pack2);
  741.  
  742.     pack2.dwGuildSelf   = m_TeamData[0].dwID;
  743.     pack2.dwGuildOpp    = m_TeamData[1].dwID;
  744.     pack2.bType     = CGuildManager::instance().TouchGuild(m_TeamData[0].dwID)->GetGuildWarType(m_TeamData[1].dwID);
  745.     pack2.bWarState = CGuildManager::instance().TouchGuild(m_TeamData[0].dwID)->GetGuildWarState(m_TeamData[1].dwID);
  746.  
  747.     d->BufferedPacket(&pack, sizeof(pack));
  748.     d->Packet(&pack2, sizeof(pack2));
  749. }
  750.  
  751. void CWarMap::SendScorePacket(BYTE bIdx, LPDESC d)
  752. {
  753.     TPacketGCGuild p;
  754.  
  755.     p.header = HEADER_GC_GUILD;
  756.     p.subheader = GUILD_SUBHEADER_GC_WAR_SCORE;
  757.     p.size = sizeof(p) + sizeof(DWORD) + sizeof(DWORD) + sizeof(long);
  758.  
  759.     TEMP_BUFFER buf;
  760.     buf.write(&p, sizeof(p));
  761.     buf.write(&m_TeamData[bIdx].dwID, sizeof(DWORD));
  762.     buf.write(&m_TeamData[bIdx ? 0 : 1].dwID, sizeof(DWORD));
  763.     buf.write(&m_TeamData[bIdx].iScore, sizeof(long));
  764.  
  765.     if (d)
  766.         d->Packet(buf.read_peek(), buf.size());
  767.     else
  768.         Packet(buf.read_peek(), buf.size());
  769. }
  770.  
  771. void CWarMap::UpdateScore(DWORD g1, int score1, DWORD g2, int score2)
  772. {
  773.     BYTE idx;
  774.  
  775.     if (GetTeamIndex(g1, idx))
  776.     {
  777.         if (m_TeamData[idx].iScore != score1)
  778.         {
  779.             m_TeamData[idx].iScore = score1;
  780.             SendScorePacket(idx);
  781.         }
  782.     }
  783.  
  784.     if (GetTeamIndex(g2, idx))
  785.     {
  786.         if (m_TeamData[idx].iScore != score2)
  787.         {
  788.             m_TeamData[idx].iScore = score2;
  789.             SendScorePacket(idx);
  790.         }
  791.     }
  792.  
  793.     CheckScore();
  794. }
  795.  
  796. bool CWarMap::CheckScore()
  797. {
  798.     if (m_bEnded)
  799.         return true;
  800.  
  801.     // 30ÃÊ ÀÌÈÄ ºÎÅÍ È®ÀÎÇÑ´Ù.
  802.     if (get_dword_time() - m_dwStartTime < 30000)
  803.         return false;
  804.  
  805.     // Á¡¼ö°¡ °°À¸¸é üũÇÏÁö ¾Ê´Â´Ù.
  806.     if (m_TeamData[0].iScore == m_TeamData[1].iScore)
  807.         return false;
  808.  
  809.     CGuild * opp_g = CGuildManager::instance().FindGuild(m_TeamData[0].dwID);
  810.     int iEndScore = quest::CQuestManager::instance().GetEventFlagBR("skor", opp_g->GetName());
  811.  
  812.     if (test_server) iEndScore /= 10;
  813.  
  814.     DWORD dwWinner;
  815.     DWORD dwLoser;
  816.  
  817.     if (m_TeamData[0].iScore >= iEndScore)
  818.     {
  819.         dwWinner = m_TeamData[0].dwID;
  820.         dwLoser = m_TeamData[1].dwID;
  821.     }
  822.     else if (m_TeamData[1].iScore >= iEndScore)
  823.     {
  824.         dwWinner = m_TeamData[1].dwID;
  825.         dwLoser = m_TeamData[0].dwID;
  826.     }
  827.     else
  828.         return false;
  829.  
  830.     int iRewardGold = 0;
  831.  
  832.     if (dwWinner == m_TeamData[0].dwID)
  833.         iRewardGold = GetRewardGold(0);
  834.     else if (dwWinner == m_TeamData[1].dwID)
  835.         iRewardGold = GetRewardGold(1);
  836.  
  837.     sys_log(0, "WarMap::CheckScore end score %d guild1 %u score guild2 %d %u score %d winner %u reward %d",
  838.             iEndScore,
  839.             m_TeamData[0].dwID,
  840.             m_TeamData[0].iScore,
  841.             m_TeamData[1].dwID,
  842.             m_TeamData[1].iScore,
  843.             dwWinner,
  844.             iRewardGold);
  845.  
  846.     CGuildManager::instance().RequestWarOver(dwWinner, dwLoser, dwWinner, iRewardGold);
  847.     return true;
  848. }
  849.  
  850. bool CWarMap::SetEnded()
  851. {
  852.     sys_log(0, "WarMap::SetEnded %d", m_kMapInfo.lMapIndex);
  853.  
  854.     if (m_pkEndEvent)
  855.         return false;
  856.  
  857.     if (m_TeamData[0].pkChrFlag)
  858.     {
  859.         M2_DESTROY_CHARACTER(m_TeamData[0].pkChrFlag);
  860.         m_TeamData[0].pkChrFlag = NULL;
  861.     }
  862.  
  863.     if (m_TeamData[0].pkChrFlagBase)
  864.     {
  865.         M2_DESTROY_CHARACTER(m_TeamData[0].pkChrFlagBase);
  866.         m_TeamData[0].pkChrFlagBase = NULL;
  867.     }
  868.  
  869.     if (m_TeamData[1].pkChrFlag)
  870.     {
  871.         M2_DESTROY_CHARACTER(m_TeamData[1].pkChrFlag);
  872.         m_TeamData[1].pkChrFlag = NULL;
  873.     }
  874.  
  875.     if (m_TeamData[1].pkChrFlagBase)
  876.     {
  877.         M2_DESTROY_CHARACTER(m_TeamData[1].pkChrFlagBase);
  878.         m_TeamData[1].pkChrFlagBase = NULL;
  879.     }
  880.  
  881.     event_cancel(&m_pkResetFlagEvent);
  882.     m_bEnded = true;
  883.  
  884.     war_map_info* info = AllocEventInfo<war_map_info>();
  885.  
  886.     info->pWarMap = this;
  887.     info->iStep = 0;
  888.     SetEndEvent(event_create(war_end_event, info, PASSES_PER_SEC(10)));
  889.     return true;
  890. }
  891.  
  892. void CWarMap::OnKill(LPCHARACTER killer, LPCHARACTER ch)
  893. {
  894.     if (m_bEnded)
  895.         return;
  896.  
  897.     DWORD dwKillerGuild = 0;
  898.     DWORD dwDeadGuild = 0;
  899.  
  900.     if (killer->GetGuild())
  901.         dwKillerGuild = killer->GetGuild()->GetID();
  902.  
  903.     if (ch->GetGuild())
  904.         dwDeadGuild = ch->GetGuild()->GetID();
  905.  
  906.     BYTE idx;
  907.  
  908.     sys_log(0, "WarMap::OnKill %u %u", dwKillerGuild, dwDeadGuild);
  909.  
  910.     if (!GetTeamIndex(dwKillerGuild, idx))
  911.         return;
  912.  
  913.     if (!GetTeamIndex(dwDeadGuild, idx))
  914.         return;
  915.  
  916.     if (ch->GetGuild() && killer->GetGuild())
  917.     {
  918.         int iRatio = ch->GetWarDeadCount() - ch->GetWarKillCount();
  919.         if (iRatio && iRatio % 10 == 0)
  920.         {
  921.             LPCHARACTER chGuildLeader = ch->GetGuild()->GetMasterCharacter();
  922.             if (chGuildLeader)
  923.             {
  924.                 chGuildLeader->ChatPacket(CHAT_TYPE_COMMAND, "WarPlayerCheckReq %s %d %d", ch->GetName(), ch->GetWarKillCount(), ch->GetWarDeadCount());
  925.                 //ch->ResetWarDeadCount();
  926.             }
  927.         }
  928.         killer->IncWarKillCount();
  929.         ch->IncWarDeadCount();
  930.     }
  931.  
  932.     switch (m_kMapInfo.bType)
  933.     {
  934.         case WAR_MAP_TYPE_NORMAL:
  935.             SendGuildWarScore(dwKillerGuild, dwDeadGuild, 1, ch->GetLevel());
  936.             break;
  937.  
  938.         case WAR_MAP_TYPE_FLAG:
  939.             {
  940.                 CAffect * pkAff = ch->FindAffect(AFFECT_WAR_FLAG);
  941.  
  942.                 if (pkAff)
  943.                 {
  944.                     if (GetTeamIndex(pkAff->lApplyValue, idx))
  945.                         AddFlag(idx, ch->GetX(), ch->GetY());
  946.  
  947.                     ch->RemoveAffect(AFFECT_WAR_FLAG);
  948.                 }
  949.             }
  950.             break;
  951.  
  952.         default:
  953.             sys_err("unknown war map type %u index %d", m_kMapInfo.bType, m_kMapInfo.lMapIndex);
  954.             break;
  955.     }
  956. }
  957.  
  958. void CWarMap::AddFlagBase(BYTE bIdx, DWORD x, DWORD y)
  959. {
  960.     if (m_bEnded)
  961.         return;
  962.  
  963.     assert(bIdx < 2);
  964.  
  965.     TeamData & r = m_TeamData[bIdx];
  966.  
  967.     if (r.pkChrFlagBase)
  968.         return;
  969.  
  970.     if (x == 0)
  971.     {
  972.         x = m_kMapInfo.posStart[bIdx].x;
  973.         y = m_kMapInfo.posStart[bIdx].y;
  974.     }
  975.  
  976.     r.pkChrFlagBase = CHARACTER_MANAGER::instance().SpawnMob(warmap::WAR_FLAG_BASE_VNUM, m_kMapInfo.lMapIndex, x, y, 0);
  977.     sys_log(0, "WarMap::AddFlagBase %u %p id %u", bIdx, get_pointer(r.pkChrFlagBase), r.dwID);
  978.  
  979.     r.pkChrFlagBase->SetPoint(POINT_STAT, r.dwID);
  980.     r.pkChrFlagBase->SetWarMap(this);
  981. }
  982.  
  983. void CWarMap::AddFlag(BYTE bIdx, DWORD x, DWORD y)
  984. {
  985.     if (m_bEnded)
  986.         return;
  987.  
  988.     assert(bIdx < 2);
  989.  
  990.     TeamData & r = m_TeamData[bIdx];
  991.  
  992.     if (r.pkChrFlag)
  993.         return;
  994.  
  995.     if (x == 0)
  996.     {
  997.         x = m_kMapInfo.posStart[bIdx].x;
  998.         y = m_kMapInfo.posStart[bIdx].y;
  999.     }
  1000.  
  1001.     r.pkChrFlag = CHARACTER_MANAGER::instance().SpawnMob(bIdx == 0 ? warmap::WAR_FLAG_VNUM0 : warmap::WAR_FLAG_VNUM1, m_kMapInfo.lMapIndex, x, y, 0);
  1002.     sys_log(0, "WarMap::AddFlag %u %p id %u", bIdx, get_pointer(r.pkChrFlag), r.dwID);
  1003.  
  1004.     r.pkChrFlag->SetPoint(POINT_STAT, r.dwID);
  1005.     r.pkChrFlag->SetWarMap(this);
  1006. }
  1007.  
  1008. void CWarMap::RemoveFlag(BYTE bIdx)
  1009. {
  1010.     assert(bIdx < 2);
  1011.  
  1012.     TeamData & r = m_TeamData[bIdx];
  1013.  
  1014.     if (!r.pkChrFlag)
  1015.         return;
  1016.  
  1017.     sys_log(0, "WarMap::RemoveFlag %u %p", bIdx, get_pointer(r.pkChrFlag));
  1018.  
  1019.     r.pkChrFlag->Dead(NULL, true);
  1020.     r.pkChrFlag = NULL;
  1021. }
  1022.  
  1023. bool CWarMap::IsFlagOnBase(BYTE bIdx)
  1024. {
  1025.     assert(bIdx < 2);
  1026.  
  1027.     TeamData & r = m_TeamData[bIdx];
  1028.  
  1029.     if (!r.pkChrFlag)
  1030.         return false;
  1031.  
  1032.     const PIXEL_POSITION & pos = r.pkChrFlag->GetXYZ();
  1033.  
  1034.     if (pos.x == m_kMapInfo.posStart[bIdx].x && pos.y == m_kMapInfo.posStart[bIdx].y)
  1035.         return true;
  1036.  
  1037.     return false;
  1038. }
  1039.  
  1040. EVENTFUNC(war_reset_flag_event)
  1041. {
  1042.     war_map_info* info = dynamic_cast<war_map_info*>( event->info );
  1043.  
  1044.     if ( info == NULL )
  1045.     {
  1046.         sys_err( "war_reset_flag_event> <Factor> Null pointer" );
  1047.         return 0;
  1048.     }
  1049.  
  1050.     CWarMap * pMap = info->pWarMap;
  1051.  
  1052.     pMap->AddFlag(0);
  1053.     pMap->AddFlag(1);
  1054.  
  1055.     pMap->SetResetFlagEvent(NULL);
  1056.     return 0;
  1057. }
  1058.  
  1059. struct FRemoveFlagAffect
  1060. {
  1061.     void operator() (LPCHARACTER ch)
  1062.     {
  1063.         if (ch->FindAffect(AFFECT_WAR_FLAG))
  1064.             ch->RemoveAffect(AFFECT_WAR_FLAG);
  1065.     }
  1066. };
  1067.  
  1068. void CWarMap::ResetFlag()
  1069. {
  1070.     if (m_kMapInfo.bType != WAR_MAP_TYPE_FLAG)
  1071.         return;
  1072.  
  1073.     if (m_pkResetFlagEvent)
  1074.         return;
  1075.  
  1076.     if (m_bEnded)
  1077.         return;
  1078.  
  1079.     FRemoveFlagAffect f;
  1080.     std::for_each(m_set_pkChr.begin(), m_set_pkChr.end(), f);
  1081.  
  1082.     RemoveFlag(0);
  1083.     RemoveFlag(1);
  1084.  
  1085.     war_map_info* info = AllocEventInfo<war_map_info>();
  1086.  
  1087.     info->pWarMap = this;
  1088.     info->iStep = 0;
  1089.     SetResetFlagEvent(event_create(war_reset_flag_event, info, PASSES_PER_SEC(10)));
  1090. }
  1091.  
  1092. /////////////////////////////////////////////////////////////////////////////////
  1093. // WarMapManager
  1094. /////////////////////////////////////////////////////////////////////////////////
  1095. CWarMapManager::CWarMapManager()
  1096. {
  1097. }
  1098.  
  1099. CWarMapManager::~CWarMapManager()
  1100. {
  1101.     for( std::map<long, TWarMapInfo *>::const_iterator iter = m_map_kWarMapInfo.begin() ; iter != m_map_kWarMapInfo.end() ; ++iter )
  1102.     {
  1103.         M2_DELETE(iter->second);
  1104.     }
  1105.  
  1106.     m_map_kWarMapInfo.clear();
  1107. }
  1108.  
  1109. bool CWarMapManager::LoadWarMapInfo(const char * c_pszFileName)
  1110. {
  1111.     TWarMapInfo * k;
  1112.  
  1113.     k = M2_NEW TWarMapInfo;
  1114.     k->bType = WAR_MAP_TYPE_NORMAL;
  1115.  
  1116.     k->lMapIndex = 110;
  1117.     k->posStart[0].x = 48 * 100 + 32000;
  1118.     k->posStart[0].y = 52 * 100 + 0;
  1119.     k->posStart[1].x = 183 * 100 + 32000;
  1120.     k->posStart[1].y = 206 * 100 + 0;
  1121.     k->posStart[2].x = 141 * 100 + 32000;
  1122.     k->posStart[2].y = 117 * 100 + 0;
  1123.  
  1124.     m_map_kWarMapInfo.insert(std::make_pair(k->lMapIndex, k));
  1125.  
  1126.     k = M2_NEW TWarMapInfo;
  1127.     k->bType = WAR_MAP_TYPE_FLAG;
  1128.  
  1129.     k->lMapIndex = 111;
  1130.     k->posStart[0].x = 68 * 100 + 57600;
  1131.     k->posStart[0].y = 69 * 100 + 0;
  1132.     k->posStart[1].x = 171 * 100 + 57600;
  1133.     k->posStart[1].y = 182 * 100 + 0;
  1134.     k->posStart[2].x = 122 * 100 + 57600;
  1135.     k->posStart[2].y = 131 * 100 + 0;
  1136.  
  1137.     m_map_kWarMapInfo.insert(std::make_pair(k->lMapIndex, k));
  1138.     return true;
  1139. }
  1140.  
  1141. bool CWarMapManager::IsWarMap(long lMapIndex)
  1142. {
  1143.     return GetWarMapInfo(lMapIndex) ? true : false;
  1144. }
  1145.  
  1146. bool CWarMapManager::GetStartPosition(long lMapIndex, BYTE bIdx, PIXEL_POSITION & pos)
  1147. {
  1148.     assert(bIdx < 3);
  1149.  
  1150.     TWarMapInfo * pi = GetWarMapInfo(lMapIndex);
  1151.  
  1152.     if (!pi)
  1153.     {
  1154.         sys_log(0, "GetStartPosition FAILED [%d] WarMapInfoSize(%d)", lMapIndex, m_map_kWarMapInfo.size());
  1155.  
  1156.         itertype(m_map_kWarMapInfo) it;
  1157.         for (it = m_map_kWarMapInfo.begin(); it != m_map_kWarMapInfo.end(); ++it)
  1158.         {
  1159.             PIXEL_POSITION& cur=it->second->posStart[bIdx];
  1160.             sys_log(0, "WarMap[%d]=Pos(%d, %d)", it->first, cur.x, cur.y);
  1161.         }
  1162.         return false;
  1163.     }
  1164.  
  1165.     pos = pi->posStart[bIdx];
  1166.     return true;
  1167. }
  1168.  
  1169. long CWarMapManager::CreateWarMap(const TGuildWarInfo& guildWarInfo, DWORD dwGuildID1, DWORD dwGuildID2)
  1170. {
  1171.     TWarMapInfo * pkInfo = GetWarMapInfo(guildWarInfo.lMapIndex);
  1172.     if (!pkInfo)
  1173.     {
  1174.         sys_err("GuildWar.CreateWarMap.NOT_FOUND_MAPINFO[%d]", guildWarInfo.lMapIndex);
  1175.         return 0;
  1176.     }
  1177.  
  1178.     DWORD lMapIndex = SECTREE_MANAGER::instance().CreatePrivateMap(guildWarInfo.lMapIndex);
  1179.  
  1180.     if (lMapIndex)
  1181.     {
  1182.         m_mapWarMap.insert(std::make_pair(lMapIndex, M2_NEW CWarMap(lMapIndex, guildWarInfo, pkInfo, dwGuildID1, dwGuildID2)));
  1183.     }
  1184.  
  1185.     return lMapIndex;
  1186. }
  1187.  
  1188. TWarMapInfo * CWarMapManager::GetWarMapInfo(long lMapIndex)
  1189. {
  1190.     if (lMapIndex >= 10000)
  1191.         lMapIndex /= 10000;
  1192.  
  1193.     itertype(m_map_kWarMapInfo) it = m_map_kWarMapInfo.find(lMapIndex);
  1194.  
  1195.     if (m_map_kWarMapInfo.end() == it)
  1196.         return NULL;
  1197.  
  1198.     return it->second;
  1199. }
  1200.  
  1201. void CWarMapManager::DestroyWarMap(CWarMap* pMap)
  1202. {
  1203.     long mapIdx = pMap->GetMapIndex();
  1204.  
  1205.     sys_log(0, "WarMap::DestroyWarMap : %d", mapIdx);
  1206.  
  1207.     m_mapWarMap.erase(pMap->GetMapIndex());
  1208.     M2_DELETE(pMap);
  1209.  
  1210.     SECTREE_MANAGER::instance().DestroyPrivateMap(mapIdx);
  1211. }
  1212.  
  1213. CWarMap * CWarMapManager::Find(long lMapIndex)
  1214. {
  1215.     itertype(m_mapWarMap) it = m_mapWarMap.find(lMapIndex);
  1216.  
  1217.     if (it == m_mapWarMap.end())
  1218.         return NULL;
  1219.  
  1220.     return it->second;
  1221. }
  1222.  
  1223. void CWarMapManager::OnShutdown()
  1224. {
  1225.     itertype(m_mapWarMap) it = m_mapWarMap.begin();
  1226.  
  1227.     while (it != m_mapWarMap.end())
  1228.         (it++)->second->Draw();
  1229. }
Tags: metin2
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!