API tools faq
paste
Guest User

battlepass_manager.cpp

a guest
May 4th, 2023
261
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 57.57 KB | None | 0 0
raw download clone embed print report
  1. #include "stdafx.h"
  2.  
  3. #ifdef ENABLE_EXTENDED_BATTLE_PASS
  4. #include "battlepass_manager.h"
  5.  
  6. #include "p2p.h"
  7. #include "locale_service.h"
  8. #include "char.h"
  9. #include "desc_client.h"
  10. #include "desc_manager.h"
  11. #include "buffer_manager.h"
  12. #include "packet.h"
  13. #include "questmanager.h"
  14. #include "questlua.h"
  15. #include "start_position.h"
  16. #include "char_manager.h"
  17. #include "item_manager.h"
  18. #include "sectree_manager.h"
  19. #include "regen.h"
  20. #include "log.h"
  21. #include "db.h"
  22. #include "target.h"
  23. #include "party.h"
  24.  
  25. #include <string>
  26. #include <algorithm>
  27.  
  28. const std::string g_astBattlePassType[BATTLEPASS_TYPE_MAX] = {
  29.     "BATTLEPASS_NORMAL",
  30.     "BATTLEPASS_PREMIUM",
  31.     "BATTLEPASS_EVENT",
  32. };
  33.  
  34. const std::string g_astMissionType[MISSION_TYPE_MAX] = {
  35.     "",
  36.     "KILL_MONSTER",
  37.     "KILL_PLAYER",
  38.     "DAMAGE_MONSTER",
  39.     "DAMAGE_PLAYER",
  40.     "BP_ITEM_USE",
  41.     "BP_ITEM_SELL",
  42.     "BP_ITEM_CRAFT",
  43.     "BP_ITEM_REFINE",
  44.     "BP_ITEM_DESTROY",
  45.     "BP_ITEM_COLLECT",
  46.     "FISH_FISHING",
  47.     "FISH_GRILL",
  48.     "FISH_CATCH",
  49.     "EXP_COLLECT",
  50.     "YANG_COLLECT",
  51.     "GUILD_PLAY_GUILDWAR",
  52.     "GUILD_SPENT_EXP",
  53.     "GAYA_CRAFT_GAYA",
  54.     "GAYA_BUY_ITEM_GAYA_COST",
  55.     "PET_ENCHANT",
  56.     "COMPLETE_DUNGEON",
  57.     "COMPLETE_MINIGAME",
  58. };
  59.  
  60. CBattlePassManager::CBattlePassManager()
  61. {
  62.     m_pNormalLoader = NULL;
  63.     m_pPremiumLoader = NULL;
  64.     m_pEventLoader = NULL;
  65.    
  66.     m_dwActiveNormalBattlePassID = 0;
  67.     m_dwActivePremiumBattlePassID = 0;
  68.     m_dwActiveEventBattlePassID = 0;
  69.    
  70.     m_dwNormalBattlePassStartTime = 0;
  71.     m_dwNormalBattlePassEndTime = 0;
  72.     m_dwPremiumBattlePassStartTime = 0;
  73.     m_dwPremiumBattlePassEndTime = 0;
  74.     m_dwEventBattlePassStartTime = 0;
  75.     m_dwEventBattlePassEndTime = 0;
  76. }
  77.  
  78. CBattlePassManager::~CBattlePassManager()
  79. {
  80.     if (m_pNormalLoader)
  81.         delete m_pNormalLoader;
  82.     if (m_pPremiumLoader)
  83.         delete m_pPremiumLoader;
  84.     if (m_pEventLoader)
  85.         delete m_pEventLoader;
  86.    
  87.     m_dwActiveNormalBattlePassID = 0;
  88.     m_dwActivePremiumBattlePassID = 0;
  89.     m_dwActiveEventBattlePassID = 0;
  90.    
  91.     m_dwNormalBattlePassStartTime = 0;
  92.     m_dwNormalBattlePassEndTime = 0;
  93.     m_dwPremiumBattlePassStartTime = 0;
  94.     m_dwPremiumBattlePassEndTime = 0;
  95.     m_dwEventBattlePassStartTime = 0;
  96.     m_dwEventBattlePassEndTime = 0;
  97. }
  98.  
  99. bool CBattlePassManager::InitializeBattlePass()
  100. {
  101.     // ----------------------- Normal --------------------------//
  102.     char szNormalBattlePassFileName[256];
  103.     snprintf(szNormalBattlePassFileName, sizeof(szNormalBattlePassFileName), "%s/battlepass/normal.txt", LocaleService_GetBasePath().c_str());
  104.     m_pNormalLoader = new CGroupTextParseTreeLoader;
  105.     CGroupTextParseTreeLoader& normal_loader = *m_pNormalLoader;
  106.    
  107.     if (false == normal_loader.Load(szNormalBattlePassFileName))
  108.     {
  109.         sys_err("battlepass/normal.txt initialize failure (path incorrect?)");
  110.         return false;
  111.     }
  112.  
  113.     if (!ReadNormalBattlePassGroup())
  114.         return false;
  115.  
  116.     if (!ReadNormalBattlePassMissions())
  117.         return false;
  118.    
  119.     // ---------------------- Premium -------------------------//
  120.     char szPremiumBattlePassFileName[256];
  121.     snprintf(szPremiumBattlePassFileName, sizeof(szPremiumBattlePassFileName), "%s/battlepass/premium.txt", LocaleService_GetBasePath().c_str());
  122.     m_pPremiumLoader = new CGroupTextParseTreeLoader;
  123.     CGroupTextParseTreeLoader& premium_loader = *m_pPremiumLoader;
  124.    
  125.     if (false == premium_loader.Load(szPremiumBattlePassFileName))
  126.     {
  127.         sys_err("battlepass/premium.txt initialize failure (path incorrect?)");
  128.         return false;
  129.     }
  130.  
  131.     if (!ReadPremiumBattlePassGroup())
  132.         return false;
  133.  
  134.     if (!ReadPremiumBattlePassMissions())
  135.         return false;
  136.    
  137.     // ------------------------ Event ---------------------------//
  138.     char szEventBattlePassFileName[256];
  139.     snprintf(szEventBattlePassFileName, sizeof(szEventBattlePassFileName), "%s/battlepass/event.txt", LocaleService_GetBasePath().c_str());
  140.     m_pEventLoader = new CGroupTextParseTreeLoader;
  141.     CGroupTextParseTreeLoader& event_loader = *m_pEventLoader;
  142.    
  143.     if (false == event_loader.Load(szEventBattlePassFileName))
  144.     {
  145.         sys_err("battlepass/event.txt initialize failure (path incorrect?)");
  146.         return false;
  147.     }
  148.  
  149.     if (!ReadEventBattlePassGroup())
  150.         return false;
  151.  
  152.     if (!ReadEventBattlePassMissions())
  153.         return false;
  154.    
  155.     // --------------- Check Battlepass Times ------------------//
  156.    
  157.     CheckBattlePassTimes();
  158.    
  159.     return true;
  160. }
  161.  
  162. bool CBattlePassManager::ReadNormalBattlePassGroup()
  163. {
  164.     std::string stName;
  165.  
  166.     CGroupNode* pGroupNode = m_pNormalLoader->GetGroup("battlepass");
  167.  
  168.     if (NULL == pGroupNode)
  169.     {
  170.         sys_err("battle_pass.txt a besoin d'un groupe de battle pass.");
  171.         return false;
  172.     }
  173.  
  174.     int n = pGroupNode->GetRowCount();
  175.     if (0 == n)
  176.     {
  177.         sys_err("Le group battle pass est vide.");
  178.         return false;
  179.     }
  180.  
  181.     std::set<BYTE> setIDs;
  182.  
  183.     for (int i = 0; i < n; i++)
  184.     {
  185.         const CGroupNode::CGroupNodeRow* pRow;
  186.         pGroupNode->GetRow(i, &pRow);
  187.  
  188.         std::string stBattlePassName;
  189.         BYTE battlePassId;
  190.        
  191.         //DWORD dwStartTime;
  192.         //DWORD dwEndTime;
  193.        
  194.         std::vector<TExtBattlePassTimeTable> timeVector;
  195.         TExtBattlePassTimeTable activeTimes;
  196.        
  197.         if (!pRow->GetValue("battlepassname", stBattlePassName))
  198.         {
  199.             sys_err("In Group BattlePass, No BattlePassName column.");
  200.             return false;
  201.         }
  202.  
  203.         if (!pRow->GetValue("battlepassid", battlePassId))
  204.         {
  205.             sys_err("In Group BattlePass, %s's ID is invalid", stBattlePassName.c_str());
  206.             return false;
  207.         }
  208.  
  209.         if (!pRow->GetValue("starttime", activeTimes.dwStartTime))
  210.         {
  211.             sys_err("In Group BattlePass, %s's StartTime is invalid", stBattlePassName.c_str());
  212.             return false;
  213.         }
  214.        
  215.         if (!pRow->GetValue("endtime", activeTimes.dwEndTime))
  216.         {
  217.             sys_err("In Group BattlePass, %s's EndTime is invalid", stBattlePassName.c_str());
  218.             return false;
  219.         }
  220.        
  221.         if (setIDs.end() != setIDs.find(battlePassId))
  222.         {
  223.             sys_err("In Group BattlePass, duplicated id exist.");
  224.             return false;
  225.         }
  226.         //sys_err("BattlePassNormal: StartTime = %d |-| EndTime = %d", m_dwNormalBattlePassStartTime, m_dwNormalBattlePassEndTime);
  227.        
  228.         /* if(m_dwNormalBattlePassStartTime < get_global_time() && m_dwNormalBattlePassEndTime > get_global_time())
  229.         {
  230.             m_dwActiveNormalBattlePassID = battlePassId;
  231.         } */
  232.        
  233.            
  234.         setIDs.insert(battlePassId);
  235.        
  236.         m_map_normal_battle_pass_name.insert(TMapNormalBattlePassName::value_type(battlePassId, stBattlePassName));
  237.        
  238.         activeTimes.bBattlePassId = battlePassId;
  239.        
  240.         timeVector.push_back(activeTimes);
  241.         m_map_normal_battle_pass_times.insert(TMapNormalBattlePassTimeTable::value_type(battlePassId, timeVector));
  242.     }
  243.  
  244.     return true;
  245. }
  246.  
  247. bool CBattlePassManager::ReadPremiumBattlePassGroup()
  248. {
  249.     std::string stName;
  250.  
  251.     CGroupNode* pGroupNode = m_pPremiumLoader->GetGroup("battlepass");
  252.  
  253.     if (NULL == pGroupNode)
  254.     {
  255.         sys_err("battle_pass.txt a besoin d'un groupe de battle pass.");
  256.         return false;
  257.     }
  258.  
  259.     int n = pGroupNode->GetRowCount();
  260.     if (0 == n)
  261.     {
  262.         sys_err("Le group battle pass est vide.");
  263.         return false;
  264.     }
  265.  
  266.     std::set<BYTE> setIDs;
  267.  
  268.     for (int i = 0; i < n; i++)
  269.     {
  270.         const CGroupNode::CGroupNodeRow* pRow;
  271.         pGroupNode->GetRow(i, &pRow);
  272.  
  273.         std::string stBattlePassName;
  274.         BYTE battlePassId;
  275.        
  276.         std::vector<TExtBattlePassTimeTable> timeVector;
  277.         TExtBattlePassTimeTable activeTimes;
  278.        
  279.         if (!pRow->GetValue("battlepassname", stBattlePassName))
  280.         {
  281.             sys_err("In Group BattlePass, No BattlePassName column.");
  282.             return false;
  283.         }
  284.  
  285.         if (!pRow->GetValue("battlepassid", battlePassId))
  286.         {
  287.             sys_err("In Group BattlePass, %s's ID is invalid", stBattlePassName.c_str());
  288.             return false;
  289.         }
  290.  
  291.         if (!pRow->GetValue("starttime", activeTimes.dwStartTime))
  292.         {
  293.             sys_err("In Group BattlePass, %s's StartTime is invalid", stBattlePassName.c_str());
  294.             return false;
  295.         }
  296.        
  297.         if (!pRow->GetValue("endtime", activeTimes.dwEndTime))
  298.         {
  299.             sys_err("In Group BattlePass, %s's EndTime is invalid", stBattlePassName.c_str());
  300.             return false;
  301.         }
  302.        
  303.         if (setIDs.end() != setIDs.find(battlePassId))
  304.         {
  305.             sys_err("In Group BattlePass, duplicated id exist.");
  306.             return false;
  307.         }
  308.         //sys_err("BattlePassNormal: StartTime = %d |-| EndTime = %d", m_dwNormalBattlePassStartTime, m_dwNormalBattlePassEndTime);
  309.        
  310.         /* if(m_dwNormalBattlePassStartTime < get_global_time() && m_dwNormalBattlePassEndTime > get_global_time())
  311.         {
  312.             m_dwActiveNormalBattlePassID = battlePassId;
  313.         } */
  314.        
  315.            
  316.         setIDs.insert(battlePassId);
  317.        
  318.         m_map_premium_battle_pass_name.insert(TMapPremiumBattlePassName::value_type(battlePassId, stBattlePassName));
  319.        
  320.         activeTimes.bBattlePassId = battlePassId;
  321.        
  322.         timeVector.push_back(activeTimes);
  323.         m_map_premium_battle_pass_times.insert(TMapPremiumBattlePassTimeTable::value_type(battlePassId, timeVector));
  324.     }
  325.  
  326.     return true;
  327. }
  328.  
  329. bool CBattlePassManager::ReadEventBattlePassGroup()
  330. {
  331.     std::string stName;
  332.  
  333.     CGroupNode* pGroupNode = m_pEventLoader->GetGroup("battlepass");
  334.  
  335.     if (NULL == pGroupNode)
  336.     {
  337.         sys_err("battle_pass.txt a besoin d'un groupe de battle pass.");
  338.         return false;
  339.     }
  340.  
  341.     int n = pGroupNode->GetRowCount();
  342.     if (0 == n)
  343.     {
  344.         sys_err("Le group battle pass est vide.");
  345.         return false;
  346.     }
  347.  
  348.     std::set<BYTE> setIDs;
  349.  
  350.     for (int i = 0; i < n; i++)
  351.     {
  352.         const CGroupNode::CGroupNodeRow* pRow;
  353.         pGroupNode->GetRow(i, &pRow);
  354.  
  355.         std::string stBattlePassName;
  356.         BYTE battlePassId;
  357.  
  358.         std::vector<TExtBattlePassTimeTable> timeVector;
  359.         TExtBattlePassTimeTable activeTimes;
  360.        
  361.         if (!pRow->GetValue("battlepassname", stBattlePassName))
  362.         {
  363.             sys_err("In Group BattlePass, No BattlePassName column.");
  364.             return false;
  365.         }
  366.  
  367.         if (!pRow->GetValue("battlepassid", battlePassId))
  368.         {
  369.             sys_err("In Group BattlePass, %s's ID is invalid", stBattlePassName.c_str());
  370.             return false;
  371.         }
  372.  
  373.         if (!pRow->GetValue("starttime", activeTimes.dwStartTime))
  374.         {
  375.             sys_err("In Group BattlePass, %s's StartTime is invalid", stBattlePassName.c_str());
  376.             return false;
  377.         }
  378.        
  379.         if (!pRow->GetValue("endtime", activeTimes.dwEndTime))
  380.         {
  381.             sys_err("In Group BattlePass, %s's EndTime is invalid", stBattlePassName.c_str());
  382.             return false;
  383.         }
  384.        
  385.         if (setIDs.end() != setIDs.find(battlePassId))
  386.         {
  387.             sys_err("In Group BattlePass, duplicated id exist.");
  388.             return false;
  389.         }
  390.         //sys_err("BattlePassNormal: StartTime = %d |-| EndTime = %d", m_dwNormalBattlePassStartTime, m_dwNormalBattlePassEndTime);
  391.        
  392.         /* if(m_dwNormalBattlePassStartTime < get_global_time() && m_dwNormalBattlePassEndTime > get_global_time())
  393.         {
  394.             m_dwActiveNormalBattlePassID = battlePassId;
  395.         } */
  396.        
  397.            
  398.         setIDs.insert(battlePassId);
  399.        
  400.         m_map_event_battle_pass_name.insert(TMapEventBattlePassName::value_type(battlePassId, stBattlePassName));
  401.        
  402.         activeTimes.bBattlePassId = battlePassId;
  403.        
  404.         timeVector.push_back(activeTimes);
  405.         m_map_event_battle_pass_times.insert(TMapEventBattlePassTimeTable::value_type(battlePassId, timeVector));
  406.     }
  407.  
  408.     return true;
  409. }
  410.  
  411. bool CBattlePassManager::ReadNormalBattlePassMissions()
  412. {
  413.     TMapNormalBattlePassName::iterator it = m_map_normal_battle_pass_name.begin();
  414.     while (it != m_map_normal_battle_pass_name.end())
  415.     {
  416.         std::string battlePassName = (it++)->second;
  417.  
  418.         CGroupNode* pGroupNode = m_pNormalLoader->GetGroup(battlePassName.c_str());
  419.  
  420.         sys_err("battle_pass.txt : %s ", battlePassName.c_str()); // SYS_ERR AT THIS LINE
  421.         if (NULL == pGroupNode) {
  422.             sys_err("battle_pass.txt need group %s.", battlePassName.c_str());
  423.             return false;
  424.         }
  425.  
  426.         int n = pGroupNode->GetChildNodeCount();
  427.         if (n < 2) {
  428.             sys_err("Group %s need to have at least one grup for Reward and one Mission. Row: %d", battlePassName.c_str(), n);
  429.             return false;
  430.         }
  431.        
  432.         {
  433.             CGroupNode* pChild;
  434.             if (NULL == (pChild = pGroupNode->GetChildNode("reward"))) {
  435.                 sys_err("In Group %s, Reward group is not defined.", battlePassName.c_str());
  436.                 return false;
  437.             }
  438.  
  439.             int m = pChild->GetRowCount();
  440.             std::vector<TExtBattlePassRewardItem> rewardVector;
  441.  
  442.             for (int j = 1; j <= m; j++) {
  443.                 std::stringstream ss;
  444.                 ss << j;
  445.                 const CGroupNode::CGroupNodeRow* pRow = NULL;
  446.  
  447.                 pChild->GetRow(ss.str(), &pRow);
  448.                 if (NULL == pRow) {
  449.                     sys_err("In Group %s, subgroup Reward, No %d row.", battlePassName.c_str(), j);
  450.                     return false;
  451.                 }
  452.  
  453.                 TExtBattlePassRewardItem itemReward;
  454.  
  455.                 if (!pRow->GetValue("itemvnum", itemReward.dwVnum)) {
  456.                     sys_err("In Group %s, subgroup Reward, ItemVnum is empty.", battlePassName.c_str());
  457.                     return false;
  458.                 }
  459.  
  460.                 if (!pRow->GetValue("itemcount", itemReward.bCount)) {
  461.                     sys_err("In Group %s, subgroup Reward, ItemCount is empty.", battlePassName.c_str());
  462.                     return false;
  463.                 }
  464.  
  465.                 rewardVector.push_back(itemReward);
  466.             }
  467.  
  468.             m_map_normal_battle_pass_reward.insert(TNormalMapBattlePassReward::value_type(battlePassName.c_str(), rewardVector));
  469.         }
  470.  
  471.         std::vector<TExtBattlePassMissionInfo> missionInfoVector;
  472.  
  473.         for (int i = 1; i < n; i++) {
  474.             std::stringstream ss;
  475.             ss << "mission_" << i;
  476.  
  477.             CGroupNode* pChild;
  478.             if (NULL == (pChild = pGroupNode->GetChildNode(ss.str()))) {
  479.                 sys_err("In Group %s, %s subgroup is not defined.", battlePassName.c_str(), ss.str().c_str());
  480.                 return false;
  481.             }
  482.  
  483.             int m = pChild->GetRowCount();
  484.  
  485.             std::string stMissionSearch[] = { "", "" };
  486.             bool bAlreadySearched = false;
  487.             BYTE bRewardContor = 0;
  488.             TExtBattlePassMissionInfo missionInfo;
  489.             memset(&missionInfo, 0, sizeof(TExtBattlePassMissionInfo));
  490.  
  491.             missionInfo.bMissionIndex = i;
  492.            
  493.             for (int j = 0; j < m; j++) {
  494.                 const CGroupNode::CGroupNodeRow* pRow = NULL;
  495.  
  496.                 pChild->GetRow(j, &pRow);
  497.                 if (NULL == pRow) {
  498.                     sys_err("In Group %s and subgroup %s null row.", battlePassName.c_str(), ss.str().c_str());
  499.                     return false;
  500.                 }
  501.  
  502.                 // InfoDesc = ItemVnum from reward
  503.                 // InfoName = ItemCount from reward
  504.  
  505.                 std::string stInfoDesc;
  506.                 if (!pRow->GetValue("infodesc", stInfoDesc)) {
  507.                     sys_err("In Group %s and subgroup %s InfoDesc does not exist.", battlePassName.c_str(), ss.str().c_str());
  508.                     return false;
  509.                 }
  510.  
  511.                 if (stInfoDesc == "type") {
  512.                     std::string stInfoName;
  513.                     if (!pRow->GetValue("infoname", stInfoName)) {
  514.                         sys_err("In Group %s and subgroup %s InfoName does not exist.", battlePassName.c_str(), ss.str().c_str());
  515.                         return false;
  516.                     }
  517.  
  518.                     missionInfo.bMissionType = GetMissionTypeByName(stInfoName);
  519.                 }
  520.  
  521.                 if (missionInfo.bMissionType <= MISSION_TYPE_NONE || missionInfo.bMissionType >= MISSION_TYPE_MAX) {
  522.                     sys_err("In Group %s and subgroup %s Wrong mission type: %d.", battlePassName.c_str(), ss.str().c_str(), missionInfo.bMissionType);
  523.                     return false;
  524.                 }
  525.  
  526.                 if (!bAlreadySearched) {
  527.                     GetMissionSearchName(missionInfo.bMissionType, &stMissionSearch[0], &stMissionSearch[1]);
  528.                     bAlreadySearched = true;
  529.                 }
  530.  
  531.                 for (int k = 0; k < 2; k++) {
  532.                     if (stMissionSearch[k] != "") {
  533.                         if (stInfoDesc == stMissionSearch[k]) {
  534.                             if (!pRow->GetValue("infoname", missionInfo.dwMissionInfo[k])) {
  535.                                 sys_err("In Group %s and subgroup %s InfoDesc %s InfoName does not exist.", battlePassName.c_str(), ss.str().c_str(), stMissionSearch[k].c_str());
  536.                                 return false;
  537.                             }
  538.  
  539.                             sys_log(0, "BattlePassInfo: Group %s // Subgroup %s // InfoName %s // InfoValue %d",
  540.                                 battlePassName.c_str(), ss.str().c_str(), stMissionSearch[k].c_str(), missionInfo.dwMissionInfo[k]);
  541.  
  542.                             stMissionSearch[k] = "";
  543.                         }
  544.                     }
  545.                 }
  546.  
  547.                 if (bRewardContor >= 3) {
  548.                     sys_err("In Group %s and subgroup %s More than 3 rewards.", battlePassName.c_str(), ss.str().c_str());
  549.                     return false;
  550.                 }
  551.  
  552.                 if (isdigit(*stInfoDesc.c_str())) {
  553.                     DWORD dwVnum = atoi(stInfoDesc.c_str());
  554.                     BYTE bCount = 1;
  555.  
  556.                     if (!pRow->GetValue("infoname", bCount)) {
  557.                         sys_err("In Group %s and subgroup %s Wrong ItemCount.", battlePassName.c_str(), ss.str().c_str());
  558.                         return false;
  559.                     }
  560.  
  561.                     missionInfo.aRewardList[bRewardContor].dwVnum = dwVnum;
  562.                     missionInfo.aRewardList[bRewardContor].bCount = bCount;
  563.                     bRewardContor++;
  564.                 }
  565.             }
  566.  
  567.             missionInfoVector.push_back(missionInfo);
  568.         }
  569.  
  570.         m_map_normal_battle_pass_mission_info.insert(TNormalMapBattleMissionInfo::value_type(battlePassName.c_str(), missionInfoVector));
  571.     }
  572.     return true;
  573. }
  574.  
  575. bool CBattlePassManager::ReadPremiumBattlePassMissions()
  576. {
  577.     TMapPremiumBattlePassName::iterator it = m_map_premium_battle_pass_name.begin();
  578.     while (it != m_map_premium_battle_pass_name.end())
  579.     {
  580.         std::string battlePassName = (it++)->second;
  581.  
  582.         CGroupNode* pGroupNode = m_pPremiumLoader->GetGroup(battlePassName.c_str());
  583.  
  584.         sys_err("battle_pass.txt : %s ", battlePassName.c_str());
  585.         if (NULL == pGroupNode) {
  586.             sys_err("battle_pass.txt need group %s.", battlePassName.c_str());
  587.             return false;
  588.         }
  589.  
  590.         int n = pGroupNode->GetChildNodeCount();
  591.         if (n < 2) {
  592.             sys_err("Group %s need to have at least one grup for Reward and one Mission. Row: %d", battlePassName.c_str(), n);
  593.             return false;
  594.         }
  595.  
  596.         {
  597.             CGroupNode* pChild;
  598.             if (NULL == (pChild = pGroupNode->GetChildNode("reward"))) {
  599.                 sys_err("In Group %s, Reward group is not defined.", battlePassName.c_str());
  600.                 return false;
  601.             }
  602.  
  603.             int m = pChild->GetRowCount();
  604.             std::vector<TExtBattlePassRewardItem> rewardVector;
  605.  
  606.             for (int j = 1; j <= m; j++) {
  607.                 std::stringstream ss;
  608.                 ss << j;
  609.                 const CGroupNode::CGroupNodeRow* pRow = NULL;
  610.  
  611.                 pChild->GetRow(ss.str(), &pRow);
  612.                 if (NULL == pRow) {
  613.                     sys_err("In Group %s, subgroup Reward, No %d row.", battlePassName.c_str(), j);
  614.                     return false;
  615.                 }
  616.  
  617.                 TExtBattlePassRewardItem itemReward;
  618.  
  619.                 if (!pRow->GetValue("itemvnum", itemReward.dwVnum)) {
  620.                     sys_err("In Group %s, subgroup Reward, ItemVnum is empty.", battlePassName.c_str());
  621.                     return false;
  622.                 }
  623.  
  624.                 if (!pRow->GetValue("itemcount", itemReward.bCount)) {
  625.                     sys_err("In Group %s, subgroup Reward, ItemCount is empty.", battlePassName.c_str());
  626.                     return false;
  627.                 }
  628.  
  629.                 rewardVector.push_back(itemReward);
  630.             }
  631.  
  632.             m_map_premium_battle_pass_reward.insert(TPremiumMapBattlePassReward::value_type(battlePassName.c_str(), rewardVector));
  633.         }
  634.  
  635.         std::vector<TExtBattlePassMissionInfo> missionInfoVector;
  636.  
  637.         for (int i = 1; i < n; i++) {
  638.             std::stringstream ss;
  639.             ss << "mission_" << i;
  640.  
  641.             CGroupNode* pChild;
  642.             if (NULL == (pChild = pGroupNode->GetChildNode(ss.str()))) {
  643.                 sys_err("In Group %s, %s subgroup is not defined.", battlePassName.c_str(), ss.str().c_str());
  644.                 return false;
  645.             }
  646.  
  647.            
  648.             int m = pChild->GetRowCount();
  649.  
  650.             std::string stMissionSearch[] = { "", "" };
  651.             bool bAlreadySearched = false;
  652.             BYTE bRewardContor = 0;
  653.             TExtBattlePassMissionInfo missionInfo;
  654.             memset(&missionInfo, 0, sizeof(TExtBattlePassMissionInfo));
  655.  
  656.             missionInfo.bMissionIndex = i;
  657.    
  658.             for (int j = 0; j < m; j++) {
  659.                 const CGroupNode::CGroupNodeRow* pRow = NULL;
  660.  
  661.                 pChild->GetRow(j, &pRow);
  662.                 if (NULL == pRow) {
  663.                     sys_err("In Group %s and subgroup %s null row.", battlePassName.c_str(), ss.str().c_str());
  664.                     return false;
  665.                 }
  666.  
  667.                 // InfoDesc = ItemVnum from reward
  668.                 // InfoName = ItemCount from reward
  669.  
  670.                 std::string stInfoDesc;
  671.                 if (!pRow->GetValue("infodesc", stInfoDesc)) {
  672.                     sys_err("In Group %s and subgroup %s InfoDesc does not exist.", battlePassName.c_str(), ss.str().c_str());
  673.                     return false;
  674.                 }
  675.  
  676.                 if (stInfoDesc == "type") {
  677.                     std::string stInfoName;
  678.                     if (!pRow->GetValue("infoname", stInfoName)) {
  679.                         sys_err("In Group %s and subgroup %s InfoName does not exist.", battlePassName.c_str(), ss.str().c_str());
  680.                         return false;
  681.                     }
  682.  
  683.                     missionInfo.bMissionType = GetMissionTypeByName(stInfoName);
  684.                 }
  685.  
  686.                 if (missionInfo.bMissionType <= MISSION_TYPE_NONE || missionInfo.bMissionType >= MISSION_TYPE_MAX) {
  687.                     sys_err("In Group %s and subgroup %s Wrong mission type: %d.", battlePassName.c_str(), ss.str().c_str(), missionInfo.bMissionType);
  688.                     return false;
  689.                 }
  690.  
  691.                 if (!bAlreadySearched) {
  692.                     GetMissionSearchName(missionInfo.bMissionType, &stMissionSearch[0], &stMissionSearch[1]);
  693.                     bAlreadySearched = true;
  694.                 }
  695.  
  696.                 for (int k = 0; k < 2; k++) {
  697.                     if (stMissionSearch[k] != "") {
  698.                         if (stInfoDesc == stMissionSearch[k]) {
  699.                             if (!pRow->GetValue("infoname", missionInfo.dwMissionInfo[k])) {
  700.                                 sys_err("In Group %s and subgroup %s InfoDesc %s InfoName does not exist.", battlePassName.c_str(), ss.str().c_str(), stMissionSearch[k].c_str());
  701.                                 return false;
  702.                             }
  703.  
  704.                             sys_log(0, "BattlePassInfo: Group %s // Subgroup %s // InfoName %s // InfoValue %d",
  705.                                 battlePassName.c_str(), ss.str().c_str(), stMissionSearch[k].c_str(), missionInfo.dwMissionInfo[k]);
  706.  
  707.                             stMissionSearch[k] = "";
  708.                         }
  709.                     }
  710.                 }
  711.  
  712.                 if (bRewardContor >= 3) {
  713.                     sys_err("In Group %s and subgroup %s More than 3 rewards.", battlePassName.c_str(), ss.str().c_str());
  714.                     return false;
  715.                 }
  716.  
  717.                 if (isdigit(*stInfoDesc.c_str())) {
  718.                     DWORD dwVnum = atoi(stInfoDesc.c_str());
  719.                     BYTE bCount = 1;
  720.  
  721.                     if (!pRow->GetValue("infoname", bCount)) {
  722.                         sys_err("In Group %s and subgroup %s Wrong ItemCount.", battlePassName.c_str(), ss.str().c_str());
  723.                         return false;
  724.                     }
  725.  
  726.                     missionInfo.aRewardList[bRewardContor].dwVnum = dwVnum;
  727.                     missionInfo.aRewardList[bRewardContor].bCount = bCount;
  728.                     bRewardContor++;
  729.                 }
  730.             }
  731.  
  732.             missionInfoVector.push_back(missionInfo);
  733.         }
  734.  
  735.         m_map_premium_battle_pass_mission_info.insert(TPremiumMapBattleMissionInfo::value_type(battlePassName.c_str(), missionInfoVector));
  736.     }
  737.     return true;
  738. }
  739.  
  740. bool CBattlePassManager::ReadEventBattlePassMissions()
  741. {
  742.     TMapEventBattlePassName::iterator it = m_map_event_battle_pass_name.begin();
  743.     while (it != m_map_event_battle_pass_name.end())
  744.     {
  745.         std::string battlePassName = (it++)->second;
  746.  
  747.         CGroupNode* pGroupNode = m_pEventLoader->GetGroup(battlePassName.c_str());
  748.  
  749.         sys_err("battle_pass.txt : %s ", battlePassName.c_str());
  750.         if (NULL == pGroupNode) {
  751.             sys_err("battle_pass.txt need group %s.", battlePassName.c_str());
  752.             return false;
  753.         }
  754.  
  755.         int n = pGroupNode->GetChildNodeCount();
  756.         if (n < 2) {
  757.             sys_err("Group %s need to have at least one grup for Reward and one Mission. Row: %d", battlePassName.c_str(), n);
  758.             return false;
  759.         }
  760.  
  761.         {
  762.             CGroupNode* pChild;
  763.             if (NULL == (pChild = pGroupNode->GetChildNode("reward"))) {
  764.                 sys_err("In Group %s, Reward group is not defined.", battlePassName.c_str());
  765.                 return false;
  766.             }
  767.  
  768.             int m = pChild->GetRowCount();
  769.             std::vector<TExtBattlePassRewardItem> rewardVector;
  770.  
  771.             for (int j = 1; j <= m; j++) {
  772.                 std::stringstream ss;
  773.                 ss << j;
  774.                 const CGroupNode::CGroupNodeRow* pRow = NULL;
  775.  
  776.                 pChild->GetRow(ss.str(), &pRow);
  777.                 if (NULL == pRow) {
  778.                     sys_err("In Group %s, subgroup Reward, No %d row.", battlePassName.c_str(), j);
  779.                     return false;
  780.                 }
  781.  
  782.                 TExtBattlePassRewardItem itemReward;
  783.  
  784.                 if (!pRow->GetValue("itemvnum", itemReward.dwVnum)) {
  785.                     sys_err("In Group %s, subgroup Reward, ItemVnum is empty.", battlePassName.c_str());
  786.                     return false;
  787.                 }
  788.  
  789.                 if (!pRow->GetValue("itemcount", itemReward.bCount)) {
  790.                     sys_err("In Group %s, subgroup Reward, ItemCount is empty.", battlePassName.c_str());
  791.                     return false;
  792.                 }
  793.  
  794.                 rewardVector.push_back(itemReward);
  795.             }
  796.  
  797.             m_map_event_battle_pass_reward.insert(TEventMapBattlePassReward::value_type(battlePassName.c_str(), rewardVector));
  798.         }
  799.  
  800.         std::vector<TExtBattlePassMissionInfo> missionInfoVector;
  801.  
  802.         for (int i = 1; i < n; i++) {
  803.             std::stringstream ss;
  804.             ss << "mission_" << i;
  805.  
  806.             CGroupNode* pChild;
  807.             if (NULL == (pChild = pGroupNode->GetChildNode(ss.str()))) {
  808.                 sys_err("In Group %s, %s subgroup is not defined.", battlePassName.c_str(), ss.str().c_str());
  809.                 return false;
  810.             }
  811.  
  812.             int m = pChild->GetRowCount();
  813.  
  814.             std::string stMissionSearch[] = { "", "" };
  815.             bool bAlreadySearched = false;
  816.             BYTE bRewardContor = 0;
  817.             TExtBattlePassMissionInfo missionInfo;
  818.             memset(&missionInfo, 0, sizeof(TExtBattlePassMissionInfo));
  819.  
  820.             missionInfo.bMissionIndex = i;
  821.  
  822.             for (int j = 0; j < m; j++) {
  823.                 const CGroupNode::CGroupNodeRow* pRow = NULL;
  824.  
  825.                 pChild->GetRow(j, &pRow);
  826.                 if (NULL == pRow) {
  827.                     sys_err("In Group %s and subgroup %s null row.", battlePassName.c_str(), ss.str().c_str());
  828.                     return false;
  829.                 }
  830.  
  831.                 // InfoDesc = ItemVnum from reward
  832.                 // InfoName = ItemCount from reward
  833.  
  834.                 std::string stInfoDesc;
  835.                 if (!pRow->GetValue("infodesc", stInfoDesc)) {
  836.                     sys_err("In Group %s and subgroup %s InfoDesc does not exist.", battlePassName.c_str(), ss.str().c_str());
  837.                     return false;
  838.                 }
  839.  
  840.                 if (stInfoDesc == "type") {
  841.                     std::string stInfoName;
  842.                     if (!pRow->GetValue("infoname", stInfoName)) {
  843.                         sys_err("In Group %s and subgroup %s InfoName does not exist.", battlePassName.c_str(), ss.str().c_str());
  844.                         return false;
  845.                     }
  846.  
  847.                     missionInfo.bMissionType = GetMissionTypeByName(stInfoName);
  848.                 }
  849.  
  850.                 if (missionInfo.bMissionType <= MISSION_TYPE_NONE || missionInfo.bMissionType >= MISSION_TYPE_MAX) {
  851.                     sys_err("In Group %s and subgroup %s Wrong mission type: %d.", battlePassName.c_str(), ss.str().c_str(), missionInfo.bMissionType);
  852.                     return false;
  853.                 }
  854.  
  855.                 if (!bAlreadySearched) {
  856.                     GetMissionSearchName(missionInfo.bMissionType, &stMissionSearch[0], &stMissionSearch[1]);
  857.                     bAlreadySearched = true;
  858.                 }
  859.  
  860.                 for (int k = 0; k < 2; k++) {
  861.                     if (stMissionSearch[k] != "") {
  862.                         if (stInfoDesc == stMissionSearch[k]) {
  863.                             if (!pRow->GetValue("infoname", missionInfo.dwMissionInfo[k])) {
  864.                                 sys_err("In Group %s and subgroup %s InfoDesc %s InfoName does not exist.", battlePassName.c_str(), ss.str().c_str(), stMissionSearch[k].c_str());
  865.                                 return false;
  866.                             }
  867.  
  868.                             sys_log(0, "BattlePassInfo: Group %s // Subgroup %s // InfoName %s // InfoValue %d",
  869.                                 battlePassName.c_str(), ss.str().c_str(), stMissionSearch[k].c_str(), missionInfo.dwMissionInfo[k]);
  870.  
  871.                             stMissionSearch[k] = "";
  872.                         }
  873.                     }
  874.                 }
  875.  
  876.                 if (bRewardContor >= 3) {
  877.                     sys_err("In Group %s and subgroup %s More than 3 rewards.", battlePassName.c_str(), ss.str().c_str());
  878.                     return false;
  879.                 }
  880.  
  881.                 if (isdigit(*stInfoDesc.c_str())) {
  882.                     DWORD dwVnum = atoi(stInfoDesc.c_str());
  883.                     BYTE bCount = 1;
  884.  
  885.                     if (!pRow->GetValue("infoname", bCount)) {
  886.                         sys_err("In Group %s and subgroup %s Wrong ItemCount.", battlePassName.c_str(), ss.str().c_str());
  887.                         return false;
  888.                     }
  889.  
  890.                     missionInfo.aRewardList[bRewardContor].dwVnum = dwVnum;
  891.                     missionInfo.aRewardList[bRewardContor].bCount = bCount;
  892.                     bRewardContor++;
  893.                 }
  894.             }
  895.  
  896.             missionInfoVector.push_back(missionInfo);
  897.         }
  898.  
  899.         m_map_event_battle_pass_mission_info.insert(TEventMapBattleMissionInfo::value_type(battlePassName.c_str(), missionInfoVector));
  900.     }
  901.     return true;
  902. }
  903.  
  904. void CBattlePassManager::CheckBattlePassTimes()
  905. {
  906.     {
  907.         bool findActiveBattlePass = false;
  908.         int cachedBattlePassID, cachedStartTime, cachedEndTime;
  909.         for(TMapNormalBattlePassTimeTable::iterator it = m_map_normal_battle_pass_times.begin(); it != m_map_normal_battle_pass_times.end(); ++it)
  910.         {
  911.             std::vector<TExtBattlePassTimeTable> timeInfo = it->second;
  912.             if (time(0) > timeInfo[0].dwStartTime and time(0) <timeInfo[0].dwEndTime) {
  913.                 findActiveBattlePass = true;
  914.                 cachedBattlePassID = timeInfo[0].bBattlePassId;
  915.                 cachedStartTime = timeInfo[0].dwStartTime;
  916.                 cachedEndTime = timeInfo[0].dwEndTime;
  917.             }
  918.         }
  919.         if (findActiveBattlePass)
  920.         {
  921.             m_dwActiveNormalBattlePassID = cachedBattlePassID;
  922.             m_dwNormalBattlePassStartTime = cachedStartTime;
  923.             m_dwNormalBattlePassEndTime = cachedEndTime;
  924.         }
  925.         else
  926.         {
  927.             m_dwActiveNormalBattlePassID = 0;
  928.             m_dwNormalBattlePassStartTime = 0;
  929.             m_dwNormalBattlePassEndTime = 0;
  930.         }
  931.     }
  932.    
  933.     {
  934.         bool findActiveBattlePass = false;
  935.         int cachedBattlePassID, cachedStartTime, cachedEndTime;
  936.         for(TMapPremiumBattlePassTimeTable::iterator it = m_map_premium_battle_pass_times.begin(); it != m_map_premium_battle_pass_times.end(); ++it)
  937.         {
  938.             std::vector<TExtBattlePassTimeTable> timeInfo = it->second;
  939.             if (time(0) > timeInfo[0].dwStartTime and time(0) <timeInfo[0].dwEndTime) {
  940.                 findActiveBattlePass = true;
  941.                 cachedBattlePassID = timeInfo[0].bBattlePassId;
  942.                 cachedStartTime = timeInfo[0].dwStartTime;
  943.                 cachedEndTime = timeInfo[0].dwEndTime;
  944.             }
  945.         }
  946.         if (findActiveBattlePass)
  947.         {
  948.             m_dwActivePremiumBattlePassID = cachedBattlePassID;
  949.             m_dwPremiumBattlePassStartTime = cachedStartTime;
  950.             m_dwPremiumBattlePassEndTime = cachedEndTime;
  951.         }
  952.         else
  953.         {
  954.             m_dwActivePremiumBattlePassID = 0;
  955.             m_dwPremiumBattlePassStartTime = 0;
  956.             m_dwPremiumBattlePassEndTime = 0;
  957.         }
  958.     }
  959.    
  960.     {
  961.         bool findActiveBattlePass = false;
  962.         int cachedBattlePassID, cachedStartTime, cachedEndTime;
  963.         for(TMapEventBattlePassTimeTable::iterator it = m_map_event_battle_pass_times.begin(); it != m_map_event_battle_pass_times.end(); ++it)
  964.         {
  965.             std::vector<TExtBattlePassTimeTable> timeInfo = it->second;
  966.             if (time(0) > timeInfo[0].dwStartTime and time(0) <timeInfo[0].dwEndTime) {
  967.                 findActiveBattlePass = true;
  968.                 cachedBattlePassID = timeInfo[0].bBattlePassId;
  969.                 cachedStartTime = timeInfo[0].dwStartTime;
  970.                 cachedEndTime = timeInfo[0].dwEndTime;
  971.             }
  972.         }
  973.         if (findActiveBattlePass)
  974.         {
  975.             m_dwActiveEventBattlePassID = cachedBattlePassID;
  976.             m_dwEventBattlePassStartTime = cachedStartTime;
  977.             m_dwEventBattlePassEndTime = cachedEndTime;
  978.         }
  979.         else
  980.         {
  981.             m_dwActiveEventBattlePassID = 0;
  982.             m_dwEventBattlePassStartTime = 0;
  983.             m_dwEventBattlePassEndTime = 0;
  984.         }
  985.     }
  986. }
  987.  
  988. BYTE CBattlePassManager::GetMissionIndex(BYTE bBattlePassType, BYTE bMissionType, DWORD dwCondition)
  989. {
  990.     bool isMinMissionType = false;
  991.     if (bMissionType == 2 or bMissionType == 4 or bMissionType == 20)
  992.         isMinMissionType = true;
  993.  
  994.     if (bBattlePassType == 1)
  995.     {
  996.         TMapNormalBattlePassName::iterator it_normal = m_map_normal_battle_pass_name.find(m_dwActiveNormalBattlePassID);
  997.  
  998.         if (it_normal != m_map_normal_battle_pass_name.end())
  999.         {
  1000.             std::string normalBattlePassName = it_normal->second;
  1001.            
  1002.             TNormalMapBattleMissionInfo::iterator itNormalInfo = m_map_normal_battle_pass_mission_info.find(normalBattlePassName);
  1003.             std::vector<TExtBattlePassMissionInfo> normalMissionInfo = itNormalInfo->second;
  1004.  
  1005.             for (int i = 0; i < normalMissionInfo.size(); i++) {
  1006.                 //sys_err("NORMAL: TableSize = %d |-|-| Type : %d |-| Condition %d = %d |-| MissionIndex = %d", normalMissionInfo.size(), normalMissionInfo[i].bMissionType, normalMissionInfo[i].dwMissionInfo[0], dwCondition, normalMissionInfo[i].bMissionIndex);
  1007.                 if (normalMissionInfo[i].dwMissionInfo[0] != 0 and isMinMissionType == false) {
  1008.                     if (normalMissionInfo[i].bMissionType == bMissionType and normalMissionInfo[i].dwMissionInfo[0] == dwCondition)
  1009.                         return normalMissionInfo[i].bMissionIndex;
  1010.                 }
  1011.                 else {
  1012.                     if (normalMissionInfo[i].bMissionType == bMissionType)
  1013.                         return normalMissionInfo[i].bMissionIndex;
  1014.                 }
  1015.             }
  1016.             return 0;
  1017.         }
  1018.     }
  1019.     else if (bBattlePassType == 2)
  1020.     {
  1021.         TMapPremiumBattlePassName::iterator it_premium = m_map_premium_battle_pass_name.find(m_dwActivePremiumBattlePassID);
  1022.  
  1023.         if (it_premium != m_map_premium_battle_pass_name.end())
  1024.         {
  1025.             std::string premiumBattlePassName = it_premium->second;
  1026.            
  1027.             TPremiumMapBattleMissionInfo::iterator itPremiumInfo = m_map_premium_battle_pass_mission_info.find(premiumBattlePassName);
  1028.             std::vector<TExtBattlePassMissionInfo> premiumMissionInfo = itPremiumInfo->second;
  1029.             for (int i = 0; i < premiumMissionInfo.size(); i++) {
  1030.                 //sys_err("PREMIUM: TableSize = %d |-|-| Type : %d |-| Condition %d = %d |-| MissionIndex = %d", premiumMissionInfo.size(), premiumMissionInfo[i].bMissionType, premiumMissionInfo[i].dwMissionInfo[0], dwCondition, premiumMissionInfo[i].bMissionIndex);
  1031.                 if (premiumMissionInfo[i].dwMissionInfo[0] != 0 and isMinMissionType == false) {
  1032.                     if (premiumMissionInfo[i].bMissionType == bMissionType and premiumMissionInfo[i].dwMissionInfo[0] == dwCondition)
  1033.                         return premiumMissionInfo[i].bMissionIndex;
  1034.                 }
  1035.                 else {
  1036.                     if (premiumMissionInfo[i].bMissionType == bMissionType)
  1037.                         return premiumMissionInfo[i].bMissionIndex;
  1038.                 }
  1039.             }
  1040.             return 0;
  1041.         }
  1042.     }
  1043.     else if (bBattlePassType == 3)
  1044.     {
  1045.         TMapEventBattlePassName::iterator it_event = m_map_event_battle_pass_name.find(m_dwActiveEventBattlePassID);
  1046.  
  1047.         if (it_event != m_map_event_battle_pass_name.end())
  1048.         {
  1049.             std::string eventBattlePassName = it_event->second;
  1050.            
  1051.             TEventMapBattleMissionInfo::iterator itEventInfo = m_map_event_battle_pass_mission_info.find(eventBattlePassName);
  1052.             std::vector<TExtBattlePassMissionInfo> eventMissionInfo = itEventInfo->second;
  1053.  
  1054.             for (int i = 0; i < eventMissionInfo.size(); i++) {
  1055.                 sys_err("EVENT: TableSize = %d |-|-| Type : %d |-| Condition %d = %d |-| MissionIndex = %d", eventMissionInfo.size(), eventMissionInfo[i].bMissionType, eventMissionInfo[i].dwMissionInfo[0], dwCondition, eventMissionInfo[i].bMissionIndex);
  1056.                 if (eventMissionInfo[i].dwMissionInfo[0] != 0 and isMinMissionType == false) {
  1057.                     if (eventMissionInfo[i].bMissionType == bMissionType and eventMissionInfo[i].dwMissionInfo[0] == dwCondition)
  1058.                         return eventMissionInfo[i].bMissionIndex;
  1059.                 }
  1060.                 else {
  1061.                     if (eventMissionInfo[i].bMissionType == bMissionType)
  1062.                         return eventMissionInfo[i].bMissionIndex;
  1063.                 }
  1064.             }
  1065.             return 0;
  1066.         }
  1067.     }
  1068.     else
  1069.         sys_err("GetMissionIndex: False BattlePassType (%d)", bBattlePassType);
  1070.     return 0;
  1071. }
  1072.  
  1073. BYTE CBattlePassManager::GetMissionTypeByName(std::string stMissionName)
  1074. {
  1075.     for (int i = 0; i < MISSION_TYPE_MAX; i++)
  1076.     {
  1077.         if (g_astMissionType[i] == stMissionName)
  1078.             return i;
  1079.     }
  1080.  
  1081.     return 0;
  1082. }
  1083.  
  1084. BYTE CBattlePassManager::GetMissionTypeByIndex(BYTE bBattlePassType, DWORD dwIndex)
  1085. {
  1086.     if (bBattlePassType == 1)
  1087.     {
  1088.         TMapNormalBattlePassName::iterator it_normal = m_map_normal_battle_pass_name.find(m_dwActiveNormalBattlePassID);
  1089.  
  1090.         if (it_normal != m_map_normal_battle_pass_name.end()) {
  1091.             std::string normalBattlePassName = it_normal->second;
  1092.            
  1093.             TNormalMapBattleMissionInfo::iterator itNormalInfo = m_map_normal_battle_pass_mission_info.find(normalBattlePassName);
  1094.             std::vector<TExtBattlePassMissionInfo> normalMissionInfo = itNormalInfo->second;
  1095.  
  1096.             for (int i = 0; i < normalMissionInfo.size(); i++) {
  1097.                 if (normalMissionInfo[i].dwMissionInfo[0] != 0 and normalMissionInfo[i].bMissionIndex == dwIndex) {
  1098.                     return normalMissionInfo[i].bMissionType;
  1099.                 }
  1100.             }
  1101.             return 0;
  1102.         }
  1103.     }
  1104.     else if (bBattlePassType == 2)
  1105.     {
  1106.         TMapPremiumBattlePassName::iterator it_premium = m_map_premium_battle_pass_name.find(m_dwActivePremiumBattlePassID);
  1107.  
  1108.         if (it_premium != m_map_premium_battle_pass_name.end()) {
  1109.             std::string premiumBattlePassName = it_premium->second;
  1110.            
  1111.             TPremiumMapBattleMissionInfo::iterator itPremiumInfo = m_map_premium_battle_pass_mission_info.find(premiumBattlePassName);
  1112.             std::vector<TExtBattlePassMissionInfo> premiumMissionInfo = itPremiumInfo->second;
  1113.            
  1114.             for (int i = 0; i < premiumMissionInfo.size(); i++) {
  1115.                 if (premiumMissionInfo[i].dwMissionInfo[0] != 0 and premiumMissionInfo[i].bMissionIndex == dwIndex) {
  1116.                     return premiumMissionInfo[i].bMissionType;
  1117.                 }
  1118.             }
  1119.             return 0;
  1120.         }
  1121.     }
  1122.     else if (bBattlePassType == 3)
  1123.     {
  1124.         TMapEventBattlePassName::iterator it_event = m_map_event_battle_pass_name.find(m_dwActiveEventBattlePassID);
  1125.  
  1126.         if (it_event != m_map_event_battle_pass_name.end()) {
  1127.             std::string eventBattlePassName = it_event->second;
  1128.            
  1129.             TEventMapBattleMissionInfo::iterator itEventInfo = m_map_event_battle_pass_mission_info.find(eventBattlePassName);
  1130.             std::vector<TExtBattlePassMissionInfo> eventMissionInfo = itEventInfo->second;
  1131.            
  1132.             for (int i = 0; i < eventMissionInfo.size(); i++) {
  1133.                 if (eventMissionInfo[i].dwMissionInfo[0] != 0 and eventMissionInfo[i].bMissionIndex == dwIndex) {
  1134.                     return eventMissionInfo[i].bMissionType;
  1135.                 }
  1136.             }
  1137.             return 0;
  1138.         }
  1139.     }
  1140.     else
  1141.         sys_err("GetMissionIndex: False BattlePassType (%d)", bBattlePassType);
  1142.     return 0;
  1143. }
  1144.  
  1145. std::string CBattlePassManager::GetMissionNameByType(BYTE bType)
  1146. {
  1147.     for (int i = 0; i < MISSION_TYPE_MAX; i++)
  1148.     {
  1149.         if (i == bType)
  1150.             return g_astMissionType[i];
  1151.     }
  1152.  
  1153.     return "";
  1154. }
  1155.  
  1156. std::string CBattlePassManager::GetNormalBattlePassNameByID(BYTE bID)
  1157. {
  1158.     TMapNormalBattlePassName::iterator it = m_map_normal_battle_pass_name.find(bID);
  1159.  
  1160.     if (it == m_map_normal_battle_pass_name.end())
  1161.     {
  1162.         return "";
  1163.     }
  1164.  
  1165.     return it->second;
  1166. }
  1167.  
  1168. std::string CBattlePassManager::GetPremiumBattlePassNameByID(BYTE bID)
  1169. {
  1170.     TMapPremiumBattlePassName::iterator it = m_map_premium_battle_pass_name.find(bID);
  1171.  
  1172.     if (it == m_map_premium_battle_pass_name.end())
  1173.     {
  1174.         return "";
  1175.     }
  1176.  
  1177.     return it->second;
  1178. }
  1179.  
  1180. std::string CBattlePassManager::GetEventBattlePassNameByID(BYTE bID)
  1181. {
  1182.     TMapEventBattlePassName::iterator it = m_map_event_battle_pass_name.find(bID);
  1183.  
  1184.     if (it == m_map_event_battle_pass_name.end())
  1185.     {
  1186.         return "";
  1187.     }
  1188.  
  1189.     return it->second;
  1190. }
  1191.  
  1192. void CBattlePassManager::GetMissionSearchName(BYTE bMissionType, std::string* st_name_1, std::string* st_name_2)
  1193. {
  1194.     switch (bMissionType)
  1195.     {
  1196.         case KILL_MONSTER:
  1197.         case DAMAGE_MONSTER:
  1198.             *st_name_1 = "mob_vnum";
  1199.             *st_name_2 = "value";
  1200.             break;
  1201.        
  1202.         case KILL_PLAYER:
  1203.         case DAMAGE_PLAYER:
  1204.             *st_name_1 = "min_level";
  1205.             *st_name_2 = "value";
  1206.             break;
  1207.        
  1208.         case BP_ITEM_USE:
  1209.         case BP_ITEM_SELL:
  1210.         case BP_ITEM_CRAFT:
  1211.         case BP_ITEM_REFINE:
  1212.         case BP_ITEM_DESTROY:
  1213.         case BP_ITEM_COLLECT:
  1214.         case FISH_FISHING:
  1215.         case FISH_GRILL:
  1216.         case FISH_CATCH:
  1217.             *st_name_1 = "item_vnum";
  1218.             *st_name_2 = "count";
  1219.             break;
  1220.    
  1221.         case EXP_COLLECT:
  1222.             *st_name_1 = "mob_vnum";
  1223.             *st_name_2 = "value";
  1224.             break;
  1225.  
  1226.         case YANG_COLLECT:
  1227.             *st_name_1 = "map_idx";
  1228.             *st_name_2 = "value";
  1229.             break;
  1230.  
  1231.         case GUILD_PLAY_GUILDWAR:
  1232.             *st_name_1 = "war_type";
  1233.             *st_name_2 = "count";
  1234.             break;
  1235.        
  1236.         case GUILD_SPENT_EXP:
  1237.         case GAYA_CRAFT_GAYA:
  1238.         case GAYA_BUY_ITEM_GAYA_COST:
  1239.             *st_name_1 = "";
  1240.             *st_name_2 = "value";
  1241.             break;
  1242.  
  1243.         case PET_ENCHANT:
  1244.             *st_name_1 = "min_type";
  1245.             *st_name_2 = "value";
  1246.             break;
  1247.  
  1248.         case COMPLETE_DUNGEON:
  1249.             *st_name_1 = "dungeon_id";
  1250.             *st_name_2 = "count";
  1251.             break;
  1252.  
  1253.         case COMPLETE_MINIGAME:
  1254.             *st_name_1 = "minigame_id";
  1255.             *st_name_2 = "count";
  1256.             break;
  1257.  
  1258.         default:
  1259.             *st_name_1 = "";
  1260.             *st_name_2 = "";
  1261.             break;
  1262.     }
  1263. }
  1264.  
  1265. void CBattlePassManager::BattlePassRequestOpen(LPCHARACTER pkChar, bool bAfterOpen)
  1266. {
  1267.     if (!pkChar) {
  1268.         sys_err("pkChar null");
  1269.         return;
  1270.     }
  1271.  
  1272.     if (!pkChar->GetDesc()) {
  1273.         sys_err("pkChar GetDesc null");
  1274.         return;
  1275.     }
  1276.    
  1277.     if(get_dword_time() < pkChar->GetLastReciveExtBattlePassInfoTime())
  1278.         return;
  1279.    
  1280.     pkChar->SetLastReciveExtBattlePassInfoTime(get_dword_time() + 1000);
  1281.    
  1282.     {
  1283.         // --- NORMAL
  1284.         const char* season_name;
  1285.         TMapNormalBattlePassName::iterator it = m_map_normal_battle_pass_name.find(m_dwActiveNormalBattlePassID);
  1286.         if (it != m_map_normal_battle_pass_name.end()) {
  1287.             std::string BattlePassName = it->second;
  1288.             season_name =  BattlePassName.c_str();
  1289.         }
  1290.         else
  1291.             season_name = "NoName";
  1292.  
  1293.         // --- GENERAL INFOS
  1294.         for(TMapNormalBattlePassTimeTable::iterator it = m_map_normal_battle_pass_times.begin(); it != m_map_normal_battle_pass_times.end(); ++it)
  1295.         {
  1296.             std::vector<TExtBattlePassTimeTable> timeInfo = it->second;
  1297.             if (!timeInfo.empty()) {
  1298.                 TPacketGCExtBattlePassGeneralInfo packet;
  1299.                 packet.bHeader = HEADER_GC_EXT_BATTLE_PASS_GENERAL_INFO;
  1300.                 packet.bBattlePassType = 1;
  1301.                 strcpy(packet.szSeasonName, season_name);
  1302.                 packet.dwBattlePassID = timeInfo[0].bBattlePassId;
  1303.                 packet.dwBattlePassStartTime = timeInfo[0].dwStartTime;
  1304.                 packet.dwBattlePassEndTime = timeInfo[0].dwEndTime;
  1305.  
  1306.                 pkChar->GetDesc()->Packet(&packet, sizeof(TPacketGCExtBattlePassGeneralInfo));
  1307.             }
  1308.         }
  1309.     }
  1310.    
  1311.     {
  1312.         const char* season_name;
  1313.         TMapPremiumBattlePassName::iterator it = m_map_premium_battle_pass_name.find(m_dwActivePremiumBattlePassID);
  1314.         if (it != m_map_premium_battle_pass_name.end()) {
  1315.             std::string BattlePassName = it->second;
  1316.             season_name = BattlePassName.c_str();
  1317.         }
  1318.         else
  1319.             season_name = "NoName";
  1320.        
  1321.         for(TMapPremiumBattlePassTimeTable::iterator it = m_map_premium_battle_pass_times.begin(); it != m_map_premium_battle_pass_times.end(); ++it)
  1322.         {
  1323.             std::vector<TExtBattlePassTimeTable> timeInfo = it->second;
  1324.             if (!timeInfo.empty()) {
  1325.                 TPacketGCExtBattlePassGeneralInfo packet;
  1326.                 packet.bHeader = HEADER_GC_EXT_BATTLE_PASS_GENERAL_INFO;
  1327.                 packet.bBattlePassType = 2;
  1328.                 strcpy(packet.szSeasonName, season_name);
  1329.                 packet.dwBattlePassID = timeInfo[0].bBattlePassId;
  1330.                 packet.dwBattlePassStartTime = timeInfo[0].dwStartTime;
  1331.                 packet.dwBattlePassEndTime = timeInfo[0].dwEndTime;
  1332.  
  1333.                 pkChar->GetDesc()->Packet(&packet, sizeof(TPacketGCExtBattlePassGeneralInfo));
  1334.             }
  1335.         }
  1336.     }
  1337.    
  1338.     {
  1339.         const char* season_name;
  1340.         TMapEventBattlePassName::iterator it = m_map_event_battle_pass_name.find(m_dwActiveEventBattlePassID);
  1341.         if (it != m_map_event_battle_pass_name.end()) {
  1342.             std::string BattlePassName = it->second;
  1343.             season_name =  BattlePassName.c_str();
  1344.         }
  1345.         else
  1346.             season_name = "NoName";
  1347.            
  1348.         for(TMapEventBattlePassTimeTable::iterator it = m_map_event_battle_pass_times.begin(); it != m_map_event_battle_pass_times.end(); ++it)
  1349.         {
  1350.             std::vector<TExtBattlePassTimeTable> timeInfo = it->second;
  1351.             if (!timeInfo.empty()) {
  1352.                 TPacketGCExtBattlePassGeneralInfo packet;
  1353.                 packet.bHeader = HEADER_GC_EXT_BATTLE_PASS_GENERAL_INFO;
  1354.                 packet.bBattlePassType = 3;
  1355.                 strcpy(packet.szSeasonName, season_name);
  1356.                 packet.dwBattlePassID = timeInfo[0].bBattlePassId;
  1357.                 packet.dwBattlePassStartTime = timeInfo[0].dwStartTime;
  1358.                 packet.dwBattlePassEndTime = timeInfo[0].dwEndTime;
  1359.  
  1360.                 pkChar->GetDesc()->Packet(&packet, sizeof(TPacketGCExtBattlePassGeneralInfo));
  1361.             }
  1362.         }
  1363.     }
  1364.  
  1365.     // --- NORMAL
  1366.     TMapNormalBattlePassName::iterator it_normal = m_map_normal_battle_pass_name.find(m_dwActiveNormalBattlePassID);
  1367.  
  1368.     if (it_normal != m_map_normal_battle_pass_name.end())
  1369.     {
  1370.         std::string normalBattlePassName = it_normal->second;
  1371.        
  1372.         TNormalMapBattleMissionInfo::iterator itNormalInfo = m_map_normal_battle_pass_mission_info.find(normalBattlePassName);
  1373.         TNormalMapBattlePassReward::iterator itNormalReward = m_map_normal_battle_pass_reward.find(normalBattlePassName);
  1374.  
  1375.         std::vector<TExtBattlePassMissionInfo> normalMissionInfo = itNormalInfo->second;
  1376.         std::vector<TExtBattlePassRewardItem> normalRewardInfo = itNormalReward->second;
  1377.  
  1378.         for (int i = 0; i < normalMissionInfo.size(); i++) {
  1379.             normalMissionInfo[i].dwMissionInfo[2] = pkChar->GetExtBattlePassMissionProgress(1, normalMissionInfo[i].bMissionIndex, normalMissionInfo[i].bMissionType);
  1380.         }
  1381.        
  1382.         if (!normalMissionInfo.empty()) {
  1383.             TPacketGCExtBattlePassMissionInfo packet;
  1384.             packet.bHeader = HEADER_GC_EXT_BATTLE_PASS_MISSION_INFO;
  1385.             packet.wSize = sizeof(packet) + sizeof(TExtBattlePassMissionInfo) * normalMissionInfo.size();
  1386.             packet.wRewardSize = sizeof(TExtBattlePassRewardItem) * normalRewardInfo.size();
  1387.             packet.bBattlePassType = 1;
  1388.             packet.dwBattlePassID = m_dwActiveNormalBattlePassID;
  1389.  
  1390.             pkChar->GetDesc()->BufferedPacket(&packet, sizeof(packet));
  1391.             pkChar->GetDesc()->BufferedPacket(&normalMissionInfo[0], sizeof(TExtBattlePassMissionInfo) * normalMissionInfo.size());
  1392.             pkChar->GetDesc()->Packet(&normalRewardInfo[0], sizeof(TExtBattlePassRewardItem) * normalRewardInfo.size());
  1393.         }
  1394.     }
  1395.    
  1396.     //--- PREMIUM
  1397.     if (pkChar->GetExtBattlePassPremiumID() == m_dwActivePremiumBattlePassID)
  1398.     {
  1399.         TMapPremiumBattlePassName::iterator it_premium = m_map_premium_battle_pass_name.find(m_dwActivePremiumBattlePassID);
  1400.  
  1401.         if (it_premium != m_map_premium_battle_pass_name.end())
  1402.         {
  1403.             std::string premiumBattlePassName = it_premium->second;
  1404.            
  1405.             TPremiumMapBattleMissionInfo::iterator itPremiumInfo = m_map_premium_battle_pass_mission_info.find(premiumBattlePassName);
  1406.             TPremiumMapBattlePassReward::iterator itPremiumReward = m_map_premium_battle_pass_reward.find(premiumBattlePassName);
  1407.  
  1408.             std::vector<TExtBattlePassRewardItem> premiumRewardInfo = itPremiumReward->second;
  1409.             std::vector<TExtBattlePassMissionInfo> premiumMissionInfo = itPremiumInfo->second;
  1410.  
  1411.             for (int i = 0; i < premiumMissionInfo.size(); i++) {
  1412.                 premiumMissionInfo[i].dwMissionInfo[2] = pkChar->GetExtBattlePassMissionProgress(2, premiumMissionInfo[i].bMissionIndex, premiumMissionInfo[i].bMissionType);
  1413.             }
  1414.            
  1415.             if (!premiumMissionInfo.empty()) {
  1416.                 TPacketGCExtBattlePassMissionInfo packet;
  1417.                 packet.bHeader = HEADER_GC_EXT_BATTLE_PASS_MISSION_INFO;
  1418.                 packet.wSize = sizeof(packet) + sizeof(TExtBattlePassMissionInfo) * premiumMissionInfo.size();
  1419.                 packet.wRewardSize = sizeof(TExtBattlePassRewardItem) * premiumRewardInfo.size();
  1420.                 packet.bBattlePassType = 2;
  1421.                 packet.dwBattlePassID = m_dwActivePremiumBattlePassID;
  1422.  
  1423.                 pkChar->GetDesc()->BufferedPacket(&packet, sizeof(packet));
  1424.                 pkChar->GetDesc()->BufferedPacket(&premiumMissionInfo[0], sizeof(TExtBattlePassMissionInfo) * premiumMissionInfo.size());
  1425.                 pkChar->GetDesc()->Packet(&premiumRewardInfo[0], sizeof(TExtBattlePassRewardItem) * premiumRewardInfo.size());
  1426.             }
  1427.         }
  1428.     }
  1429.    
  1430.     //--- EVENT
  1431.     TMapEventBattlePassName::iterator it_event = m_map_event_battle_pass_name.find(m_dwActiveEventBattlePassID);
  1432.  
  1433.     if (it_event != m_map_event_battle_pass_name.end())
  1434.     {
  1435.         std::string eventBattlePassName = it_event->second;
  1436.        
  1437.         TEventMapBattleMissionInfo::iterator itEventInfo = m_map_event_battle_pass_mission_info.find(eventBattlePassName);
  1438.         TEventMapBattlePassReward::iterator itEventReward = m_map_event_battle_pass_reward.find(eventBattlePassName);
  1439.  
  1440.         std::vector<TExtBattlePassRewardItem> eventRewardInfo = itEventReward->second;
  1441.         std::vector<TExtBattlePassMissionInfo> eventMissionInfo = itEventInfo->second;
  1442.  
  1443.         for (int i = 0; i < eventMissionInfo.size(); i++) {
  1444.             eventMissionInfo[i].dwMissionInfo[2] = pkChar->GetExtBattlePassMissionProgress(3, eventMissionInfo[i].bMissionIndex, eventMissionInfo[i].bMissionType);
  1445.         }
  1446.  
  1447.         if (!eventMissionInfo.empty()) {
  1448.             TPacketGCExtBattlePassMissionInfo packet;
  1449.             packet.bHeader = HEADER_GC_EXT_BATTLE_PASS_MISSION_INFO;
  1450.             packet.wSize = sizeof(packet) + sizeof(TExtBattlePassMissionInfo) * eventMissionInfo.size();
  1451.             packet.wRewardSize = sizeof(TExtBattlePassRewardItem) * eventRewardInfo.size();
  1452.             packet.bBattlePassType = 3;
  1453.             packet.dwBattlePassID = m_dwActiveEventBattlePassID;
  1454.  
  1455.             pkChar->GetDesc()->BufferedPacket(&packet, sizeof(packet));
  1456.             pkChar->GetDesc()->BufferedPacket(&eventMissionInfo[0], sizeof(TExtBattlePassMissionInfo) * eventMissionInfo.size());
  1457.             pkChar->GetDesc()->Packet(&eventRewardInfo[0], sizeof(TExtBattlePassRewardItem) * eventRewardInfo.size());
  1458.         }
  1459.     }
  1460.    
  1461.     if (bAfterOpen)
  1462.     {
  1463.         //--- OPEN GUI
  1464.         TPacketGCExtBattlePassOpen packet;
  1465.         packet.bHeader = HEADER_GC_EXT_BATTLE_PASS_OPEN;
  1466.         pkChar->GetDesc()->Packet(&packet, sizeof(packet));
  1467.     }
  1468. }
  1469.  
  1470. void CBattlePassManager::BattlePassRewardMission(LPCHARACTER pkChar, BYTE bBattlePassType, DWORD bMissionType, DWORD bBattlePassId)
  1471. {
  1472.     if (!pkChar)
  1473.         return;
  1474.  
  1475.     if (!pkChar->GetDesc())
  1476.         return;
  1477.  
  1478.     if (bBattlePassType == 1)
  1479.     {
  1480.         TMapNormalBattlePassName::iterator it = m_map_normal_battle_pass_name.find(bBattlePassId);
  1481.         if (it == m_map_normal_battle_pass_name.end())
  1482.             return;
  1483.  
  1484.         std::string battlePassName = it->second;
  1485.         TNormalMapBattleMissionInfo::iterator itInfo = m_map_normal_battle_pass_mission_info.find(battlePassName);
  1486.         if (itInfo == m_map_normal_battle_pass_mission_info.end())
  1487.             return;
  1488.  
  1489.         std::vector<TExtBattlePassMissionInfo> missionInfo = itInfo->second;
  1490.         for (int i = 0; i < missionInfo.size(); i++) {
  1491.             if (missionInfo[i].bMissionType == bMissionType) {
  1492.                 for (int j = 0; j < 3; j++) {
  1493.                     if (missionInfo[i].aRewardList[j].dwVnum && missionInfo[i].aRewardList[j].bCount > 0)
  1494.                         pkChar->AutoGiveItem(missionInfo[i].aRewardList[j].dwVnum, missionInfo[i].aRewardList[j].bCount);
  1495.                 }
  1496.                 break;
  1497.             }
  1498.         }
  1499.     }
  1500.     if (bBattlePassType == 2)
  1501.     {
  1502.         TMapPremiumBattlePassName::iterator it = m_map_premium_battle_pass_name.find(bBattlePassId);
  1503.         if (it == m_map_premium_battle_pass_name.end())
  1504.             return;
  1505.  
  1506.         std::string battlePassName = it->second;
  1507.         TPremiumMapBattleMissionInfo::iterator itInfo = m_map_premium_battle_pass_mission_info.find(battlePassName);
  1508.         if (itInfo == m_map_premium_battle_pass_mission_info.end())
  1509.             return;
  1510.  
  1511.         std::vector<TExtBattlePassMissionInfo> missionInfo = itInfo->second;
  1512.         for (int i = 0; i < missionInfo.size(); i++) {
  1513.             if (missionInfo[i].bMissionType == bMissionType) {
  1514.                 for (int j = 0; j < 3; j++) {
  1515.                     if (missionInfo[i].aRewardList[j].dwVnum && missionInfo[i].aRewardList[j].bCount > 0)
  1516.                         pkChar->AutoGiveItem(missionInfo[i].aRewardList[j].dwVnum, missionInfo[i].aRewardList[j].bCount);
  1517.                 }
  1518.                 break;
  1519.             }
  1520.         }
  1521.     }
  1522.     if (bBattlePassType == 3)
  1523.     {
  1524.         TMapEventBattlePassName::iterator it = m_map_event_battle_pass_name.find(bBattlePassId);
  1525.         if (it == m_map_event_battle_pass_name.end())
  1526.             return;
  1527.  
  1528.         std::string battlePassName = it->second;
  1529.         TEventMapBattleMissionInfo::iterator itInfo = m_map_event_battle_pass_mission_info.find(battlePassName);
  1530.         if (itInfo == m_map_event_battle_pass_mission_info.end())
  1531.             return;
  1532.  
  1533.         std::vector<TExtBattlePassMissionInfo> missionInfo = itInfo->second;
  1534.         for (int i = 0; i < missionInfo.size(); i++) {
  1535.             if (missionInfo[i].bMissionType == bMissionType) {
  1536.                 for (int j = 0; j < 3; j++) {
  1537.                     if (missionInfo[i].aRewardList[j].dwVnum && missionInfo[i].aRewardList[j].bCount > 0)
  1538.                         pkChar->AutoGiveItem(missionInfo[i].aRewardList[j].dwVnum, missionInfo[i].aRewardList[j].bCount);
  1539.                 }
  1540.                 break;
  1541.             }
  1542.         }
  1543.     }
  1544. }
  1545.  
  1546. void CBattlePassManager::BattlePassRequestReward(LPCHARACTER pkChar, BYTE bBattlePassType)
  1547. {
  1548.     if (!pkChar)
  1549.         return;
  1550.  
  1551.     if (!pkChar->GetDesc())
  1552.         return;
  1553.  
  1554.     BYTE bBattlePassID;
  1555.  
  1556.     if (bBattlePassType == 1)
  1557.     {
  1558.         bBattlePassID = GetNormalBattlePassID();
  1559.  
  1560.         TMapNormalBattlePassName::iterator it = m_map_normal_battle_pass_name.find(bBattlePassID);
  1561.         if (it == m_map_normal_battle_pass_name.end())
  1562.             return;
  1563.  
  1564.         std::string battlePassName = it->second;
  1565.         TNormalMapBattleMissionInfo::iterator itInfo = m_map_normal_battle_pass_mission_info.find(battlePassName);
  1566.  
  1567.         if (itInfo == m_map_normal_battle_pass_mission_info.end())
  1568.             return;
  1569.  
  1570.         std::vector<TExtBattlePassMissionInfo> missionInfo = itInfo->second;
  1571.  
  1572.         for (int i = 0; i < missionInfo.size(); i++) {
  1573.             if (!pkChar->IsExtBattlePassCompletedMission(bBattlePassType, missionInfo[i].bMissionIndex, missionInfo[i].bMissionType)) {
  1574.                 pkChar->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("BATTLEPASS_NOT_COMPLETED_ALL_NORMAL_MISSIONS"));
  1575.                 return;
  1576.             }
  1577.         }
  1578.     }
  1579.     if (bBattlePassType == 2)
  1580.     {
  1581.         bBattlePassID = GetPremiumBattlePassID();
  1582.  
  1583.         TMapPremiumBattlePassName::iterator it = m_map_premium_battle_pass_name.find(bBattlePassID);
  1584.         if (it == m_map_premium_battle_pass_name.end())
  1585.             return;
  1586.  
  1587.         std::string battlePassName = it->second;
  1588.         TPremiumMapBattleMissionInfo::iterator itInfo = m_map_premium_battle_pass_mission_info.find(battlePassName);
  1589.  
  1590.         if (itInfo == m_map_premium_battle_pass_mission_info.end())
  1591.             return;
  1592.  
  1593.         std::vector<TExtBattlePassMissionInfo> missionInfo = itInfo->second;
  1594.  
  1595.         for (int i = 0; i < missionInfo.size(); i++) {
  1596.             if (!pkChar->IsExtBattlePassCompletedMission(bBattlePassType, missionInfo[i].bMissionIndex, missionInfo[i].bMissionType)) {
  1597.                 pkChar->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("BATTLEPASS_NOT_COMPLETED_ALL_PREMIUM_MISSIONS"));
  1598.                 return;
  1599.             }
  1600.         }
  1601.     }
  1602.     if (bBattlePassType == 3)
  1603.     {
  1604.         bBattlePassID = GetEventBattlePassID();
  1605.  
  1606.         TMapEventBattlePassName::iterator it = m_map_event_battle_pass_name.find(bBattlePassID);
  1607.         if (it == m_map_event_battle_pass_name.end())
  1608.             return;
  1609.  
  1610.         std::string battlePassName = it->second;
  1611.         TEventMapBattleMissionInfo::iterator itInfo = m_map_event_battle_pass_mission_info.find(battlePassName);
  1612.  
  1613.         if (itInfo == m_map_event_battle_pass_mission_info.end())
  1614.             return;
  1615.  
  1616.         std::vector<TExtBattlePassMissionInfo> missionInfo = itInfo->second;
  1617.  
  1618.         for (int i = 0; i < missionInfo.size(); i++) {
  1619.             if (!pkChar->IsExtBattlePassCompletedMission(bBattlePassType, missionInfo[i].bMissionIndex, missionInfo[i].bMissionType)) {
  1620.                 pkChar->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("BATTLEPASS_NOT_COMPLETED_ALL_EVENT_MISSIONS"));
  1621.                 return;
  1622.             }
  1623.         }
  1624.     }
  1625.  
  1626.     std::unique_ptr<SQLMsg> pMsg(DBManager::instance().DirectQuery("SELECT battlepass_completed FROM player.battlepass_playerindex WHERE player_id = %d and battlepass_type = %d and battlepass_id = %d", pkChar->GetPlayerID(), bBattlePassType, bBattlePassID));
  1627.     if (pMsg->uiSQLErrno)
  1628.         return;
  1629.    
  1630.     MYSQL_ROW row = mysql_fetch_row(pMsg->Get()->pSQLResult);
  1631.     int bHasRecived;
  1632.     str_to_number(bHasRecived, row[0]);
  1633.    
  1634.     if (bHasRecived != 0) {
  1635.         pkChar->ChatPacket(CHAT_TYPE_INFO, LC_TEXT("BATTLEPASS_ALREADY_EARNED_BATTLEPASS_REWARD"));
  1636.         return;
  1637.     }
  1638.    
  1639.     DBManager::instance().DirectQuery("UPDATE player.battlepass_playerindex SET battlepass_completed = 1, end_time = NOW() WHERE player_id = %d and battlepass_type = %d and battlepass_id = %d", pkChar->GetPlayerID(), bBattlePassType, bBattlePassID);
  1640.    
  1641.     if (bBattlePassID)
  1642.         BattlePassReward(pkChar, bBattlePassType, bBattlePassID);
  1643. }
  1644.  
  1645. void CBattlePassManager::BattlePassReward(LPCHARACTER pkChar, BYTE bBattlePassType, BYTE bBattlePassID)
  1646. {
  1647.     if (bBattlePassType == 1)
  1648.     {
  1649.         TMapNormalBattlePassName::iterator it = m_map_normal_battle_pass_name.find(bBattlePassID);
  1650.         if (it == m_map_normal_battle_pass_name.end())
  1651.             return;
  1652.  
  1653.         std::string battlePassName = it->second;
  1654.         TNormalMapBattlePassReward::iterator itReward = m_map_normal_battle_pass_reward.find(battlePassName);
  1655.         if (itReward == m_map_normal_battle_pass_reward.end())
  1656.             return;
  1657.  
  1658.         std::vector<TExtBattlePassRewardItem> rewardInfo = itReward->second;
  1659.         for (int i = 0; i < rewardInfo.size(); i++) {
  1660.             pkChar->AutoGiveItem(rewardInfo[i].dwVnum, rewardInfo[i].bCount);
  1661.         }
  1662.         pkChar->EffectPacket(SE_EFFECT_BP_NORMAL_BATTLEPASS_COMPLETED);
  1663.     }
  1664.     if (bBattlePassType == 2)
  1665.     {
  1666.         TMapPremiumBattlePassName::iterator it = m_map_premium_battle_pass_name.find(bBattlePassID);
  1667.         if (it == m_map_premium_battle_pass_name.end())
  1668.             return;
  1669.  
  1670.         std::string battlePassName = it->second;
  1671.         TPremiumMapBattlePassReward::iterator itReward = m_map_premium_battle_pass_reward.find(battlePassName);
  1672.         if (itReward == m_map_premium_battle_pass_reward.end())
  1673.             return;
  1674.  
  1675.         std::vector<TExtBattlePassRewardItem> rewardInfo = itReward->second;
  1676.         for (int i = 0; i < rewardInfo.size(); i++) {
  1677.             pkChar->AutoGiveItem(rewardInfo[i].dwVnum, rewardInfo[i].bCount);
  1678.         }
  1679.         pkChar->EffectPacket(SE_EFFECT_BP_PREMIUM_BATTLEPASS_COMPLETED);
  1680.     }
  1681.     if (bBattlePassType == 3)
  1682.     {
  1683.         TMapEventBattlePassName::iterator it = m_map_event_battle_pass_name.find(bBattlePassID);
  1684.         if (it == m_map_event_battle_pass_name.end())
  1685.             return;
  1686.  
  1687.         std::string battlePassName = it->second;
  1688.         TEventMapBattlePassReward::iterator itReward = m_map_event_battle_pass_reward.find(battlePassName);
  1689.         if (itReward == m_map_event_battle_pass_reward.end())
  1690.             return;
  1691.  
  1692.         std::vector<TExtBattlePassRewardItem> rewardInfo = itReward->second;
  1693.         for (int i = 0; i < rewardInfo.size(); i++) {
  1694.             pkChar->AutoGiveItem(rewardInfo[i].dwVnum, rewardInfo[i].bCount);
  1695.         }
  1696.         pkChar->EffectPacket(SE_EFFECT_BP_EVENT_BATTLEPASS_COMPLETED);
  1697.     }
  1698. }
  1699.  
  1700. bool CBattlePassManager::BattlePassMissionGetInfo(BYTE bBattlePassType, BYTE bMissionIndex, BYTE bBattlePassId, BYTE bMissionType, DWORD* dwFirstInfo, DWORD* dwSecondInfo)
  1701. {
  1702.     if (bBattlePassType == 1)
  1703.     {
  1704.         TMapNormalBattlePassName::iterator it = m_map_normal_battle_pass_name.find(bBattlePassId);
  1705.         if (it == m_map_normal_battle_pass_name.end())
  1706.             return false;
  1707.  
  1708.         std::string battlePassName = it->second;
  1709.         TNormalMapBattleMissionInfo::iterator itInfo = m_map_normal_battle_pass_mission_info.find(battlePassName);
  1710.  
  1711.         if (itInfo == m_map_normal_battle_pass_mission_info.end())
  1712.             return false;
  1713.  
  1714.         std::vector<TExtBattlePassMissionInfo> missionInfo = itInfo->second;
  1715.  
  1716.         for (int i = 0; i < missionInfo.size(); i++)
  1717.         {
  1718.             if (missionInfo[i].bMissionIndex == bMissionIndex && missionInfo[i].bMissionType == bMissionType)
  1719.             {
  1720.                 *dwFirstInfo = missionInfo[i].dwMissionInfo[0];
  1721.                 *dwSecondInfo = missionInfo[i].dwMissionInfo[1];
  1722.                 return true;
  1723.             }
  1724.         }
  1725.  
  1726.         return false;
  1727.     }
  1728.     else if (bBattlePassType == 2)
  1729.     {
  1730.         TMapPremiumBattlePassName::iterator it = m_map_premium_battle_pass_name.find(bBattlePassId);
  1731.         if (it == m_map_premium_battle_pass_name.end())
  1732.             return false;
  1733.  
  1734.         std::string battlePassName = it->second;
  1735.         TPremiumMapBattleMissionInfo::iterator itInfo = m_map_premium_battle_pass_mission_info.find(battlePassName);
  1736.  
  1737.         if (itInfo == m_map_premium_battle_pass_mission_info.end())
  1738.             return false;
  1739.  
  1740.         std::vector<TExtBattlePassMissionInfo> missionInfo = itInfo->second;
  1741.  
  1742.         for (int i = 0; i < missionInfo.size(); i++)
  1743.         {
  1744.             if (missionInfo[i].bMissionIndex == bMissionIndex && missionInfo[i].bMissionType == bMissionType)
  1745.             {
  1746.                 *dwFirstInfo = missionInfo[i].dwMissionInfo[0];
  1747.                 *dwSecondInfo = missionInfo[i].dwMissionInfo[1];
  1748.                 return true;
  1749.             }
  1750.         }
  1751.         return false;
  1752.     }
  1753.     else if (bBattlePassType == 3)
  1754.     {
  1755.         TMapEventBattlePassName::iterator it = m_map_event_battle_pass_name.find(bBattlePassId);
  1756.         if (it == m_map_event_battle_pass_name.end())
  1757.             return false;
  1758.  
  1759.         std::string battlePassName = it->second;
  1760.         TEventMapBattleMissionInfo::iterator itInfo = m_map_event_battle_pass_mission_info.find(battlePassName);
  1761.  
  1762.         if (itInfo == m_map_event_battle_pass_mission_info.end())
  1763.             return false;
  1764.  
  1765.         std::vector<TExtBattlePassMissionInfo> missionInfo = itInfo->second;
  1766.  
  1767.         for (int i = 0; i < missionInfo.size(); i++)
  1768.         {
  1769.             if (missionInfo[i].bMissionIndex == bMissionIndex && missionInfo[i].bMissionType == bMissionType)
  1770.             {
  1771.                 *dwFirstInfo = missionInfo[i].dwMissionInfo[0];
  1772.                 *dwSecondInfo = missionInfo[i].dwMissionInfo[1];
  1773.                 return true;
  1774.             }
  1775.         }
  1776.  
  1777.         return false;
  1778.     }
  1779.     else
  1780.     {
  1781.         sys_err("Unknown BattlePassType (%d)", bBattlePassType);
  1782.         return false;
  1783.     }
  1784. }
  1785. #endif
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!