API tools faq
paste
Guest User

Untitled

a guest
Dec 23rd, 2019
164
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 21.22 KB | None | 0 0
raw download clone embed print report
  1. #include "stdafx.h"
  2. #include "utils.h"
  3. #include "config.h"
  4. #include "char.h"
  5. #include "char_manager.h"
  6. #include "desc_client.h"
  7. #include "db.h"
  8. #include "log.h"
  9. #include "skill.h"
  10. #include "text_file_loader.h"
  11. #include "priv_manager.h"
  12. #include "questmanager.h"
  13. #include "unique_item.h"
  14. #include "safebox.h"
  15. #include "blend_item.h"
  16. #include "dev_log.h"
  17. #include "locale_service.h"
  18. #include "item.h"
  19. #include "item_manager.h"
  20. #include "item_manager_private_types.h"
  21. #include "group_text_parse_tree.h"
  22.  
  23. std::vector<CItemDropInfo> g_vec_pkCommonDropItem[MOB_RANK_MAX_NUM];
  24.  
  25. bool ITEM_MANAGER::ReadCommonDropItemFile(const char * c_pszFileName)
  26. {
  27.     FILE * fp = fopen(c_pszFileName, "r");
  28.  
  29.     if (!fp)
  30.     {
  31.         sys_err("Cannot open %s", c_pszFileName);
  32.         return false;
  33.     }
  34.  
  35.     char buf[1024];
  36.  
  37.     int lines = 0;
  38.  
  39.     while (fgets(buf, 1024, fp))
  40.     {
  41.         ++lines;
  42.  
  43.         if (!*buf || *buf == '\n')
  44.             continue;
  45.  
  46.         TDropItem d[MOB_RANK_MAX_NUM];
  47.         char szTemp[64];
  48.  
  49.         memset(&d, 0, sizeof(d));
  50.  
  51.         char * p = buf;
  52.         char * p2;
  53.  
  54.         for (int i = 0; i <= MOB_RANK_S_KNIGHT; ++i)
  55.         {
  56.             for (int j = 0; j < 6; ++j)
  57.             {
  58.                 p2 = strchr(p, '\t');
  59.  
  60.                 if (!p2)
  61.                     break;
  62.  
  63.                 strlcpy(szTemp, p, MIN(sizeof(szTemp), (p2 - p) + 1));
  64.                 p = p2 + 1;
  65.  
  66.                 switch (j)
  67.                 {
  68.                 case 0: break;
  69.                 case 1: str_to_number(d[i].iLvStart, szTemp);   break;
  70.                 case 2: str_to_number(d[i].iLvEnd, szTemp); break;
  71.                 case 3: d[i].fPercent = atof(szTemp);   break;
  72.                 case 4: strlcpy(d[i].szItemName, szTemp, sizeof(d[i].szItemName));  break;
  73.                 case 5: str_to_number(d[i].iCount, szTemp); break;
  74.                 }
  75.             }
  76.  
  77.             DWORD dwPct = (DWORD) (d[i].fPercent * 10000.0f);
  78.             DWORD dwItemVnum = 0;
  79.  
  80.             if (!ITEM_MANAGER::instance().GetVnumByOriginalName(d[i].szItemName, dwItemVnum))
  81.             {
  82.                 // 이름으로 못찾으면 번호로 검색
  83.                 str_to_number(dwItemVnum, d[i].szItemName);
  84.                 if (!ITEM_MANAGER::instance().GetTable(dwItemVnum))
  85.                 {
  86.                     sys_err("No such an item (name: %s)", d[i].szItemName);
  87.                     fclose(fp);
  88.                     return false;
  89.                 }
  90.             }
  91.  
  92.             if (d[i].iLvStart == 0)
  93.                 continue;
  94.  
  95.             g_vec_pkCommonDropItem[i].push_back(CItemDropInfo(d[i].iLvStart, d[i].iLvEnd, dwPct, dwItemVnum));
  96.         }
  97.     }
  98.  
  99.     fclose(fp);
  100.  
  101.     for (int i = 0; i < MOB_RANK_MAX_NUM; ++i)
  102.     {
  103.         std::vector<CItemDropInfo> & v = g_vec_pkCommonDropItem[i];
  104.         std::sort(v.begin(), v.end());
  105.  
  106.         std::vector<CItemDropInfo>::iterator it = v.begin();
  107.  
  108.         sys_log(1, "CommonItemDrop rank %d", i);
  109.  
  110.         while (it != v.end())
  111.         {
  112.             const CItemDropInfo & c = *(it++);
  113.             sys_log(1, "CommonItemDrop %d %d %d %u", c.m_iLevelStart, c.m_iLevelEnd, c.m_iPercent, c.m_dwVnum);
  114.         }
  115.     }
  116.  
  117.     return true;
  118. }
  119.  
  120. bool ITEM_MANAGER::ReadSpecialDropItemFile(const char * c_pszFileName)
  121. {
  122.     CTextFileLoader loader;
  123.  
  124.     if (!loader.Load(c_pszFileName))
  125.         return false;
  126.  
  127.     std::string stName;
  128.  
  129.     for (DWORD i = 0; i < loader.GetChildNodeCount(); ++i)
  130.     {
  131.         loader.SetChildNode(i);
  132.  
  133.         loader.GetCurrentNodeName(&stName);
  134.  
  135.         int iVnum;
  136.  
  137.         if (!loader.GetTokenInteger("vnum", &iVnum))
  138.         {
  139.             sys_err("ReadSpecialDropItemFile : Syntax error %s : no vnum, node %s", c_pszFileName, stName.c_str());
  140.             loader.SetParentNode();
  141.             return false;
  142.         }
  143.  
  144.         sys_log(0,"DROP_ITEM_GROUP %s %d", stName.c_str(), iVnum);
  145.  
  146.         TTokenVector * pTok;
  147.  
  148.         //
  149.         std::string stType;
  150.         int type = CSpecialItemGroup::NORMAL;
  151.         if (loader.GetTokenString("type", &stType))
  152.         {
  153.             stl_lowers(stType);
  154.             if (stType == "pct")
  155.             {
  156.                 type = CSpecialItemGroup::PCT;
  157.             }
  158.             else if (stType == "quest")
  159.             {
  160.                 type = CSpecialItemGroup::QUEST;
  161.                 quest::CQuestManager::instance().RegisterNPCVnum(iVnum);
  162.             }
  163.             else if (stType == "special")
  164.             {
  165.                 type = CSpecialItemGroup::SPECIAL;
  166.             }
  167.         }
  168.  
  169.         if ("attr" == stType)
  170.         {
  171.             CSpecialAttrGroup * pkGroup = M2_NEW CSpecialAttrGroup(iVnum);
  172.             for (int k = 1; k < 256; ++k)
  173.             {
  174.                 char buf[4];
  175.                 snprintf(buf, sizeof(buf), "%d", k);
  176.  
  177.                 if (loader.GetTokenVector(buf, &pTok))
  178.                 {
  179.                     DWORD apply_type = 0;
  180.                     int apply_value = 0;
  181.                     str_to_number(apply_type, pTok->at(0).c_str());
  182.                     if (0 == apply_type)
  183.                     {
  184.                         apply_type = FN_get_apply_type(pTok->at(0).c_str());
  185.                         if (0 == apply_type)
  186.                         {
  187.                             sys_err ("Invalid APPLY_TYPE %s in Special Item Group Vnum %d", pTok->at(0).c_str(), iVnum);
  188.                             return false;
  189.                         }
  190.                     }
  191.                     str_to_number(apply_value, pTok->at(1).c_str());
  192.                     if (apply_type > MAX_APPLY_NUM)
  193.                     {
  194.                         sys_err ("Invalid APPLY_TYPE %u in Special Item Group Vnum %d", apply_type, iVnum);
  195.                         M2_DELETE(pkGroup);
  196.                         return false;
  197.                     }
  198.                     pkGroup->m_vecAttrs.push_back(CSpecialAttrGroup::CSpecialAttrInfo(apply_type, apply_value));
  199.                 }
  200.                 else
  201.                 {
  202.                     break;
  203.                 }
  204.             }
  205.             if (loader.GetTokenVector("effect", &pTok))
  206.             {
  207.                 pkGroup->m_stEffectFileName = pTok->at(0);
  208.             }
  209.             loader.SetParentNode();
  210.             m_map_pkSpecialAttrGroup.insert(std::make_pair(iVnum, pkGroup));
  211.         }
  212.         else
  213.         {
  214.             CSpecialItemGroup * pkGroup = M2_NEW CSpecialItemGroup(iVnum, type);
  215.             for (int k = 1; k < 256; ++k)
  216.             {
  217.                 char buf[4];
  218.                 snprintf(buf, sizeof(buf), "%d", k);
  219.  
  220.                 if (loader.GetTokenVector(buf, &pTok))
  221.                 {
  222.                     const std::string& name = pTok->at(0);
  223.                     DWORD dwVnum = 0;
  224.  
  225.                     if (!GetVnumByOriginalName(name.c_str(), dwVnum))
  226.                     {
  227.                         if (name == "경험치" || name == "exp")
  228.                         {
  229.                             dwVnum = CSpecialItemGroup::EXP;
  230.                         }
  231.                         else if (name == "mob")
  232.                         {
  233.                             dwVnum = CSpecialItemGroup::MOB;
  234.                         }
  235.                         else if (name == "slow")
  236.                         {
  237.                             dwVnum = CSpecialItemGroup::SLOW;
  238.                         }
  239.                         else if (name == "drain_hp")
  240.                         {
  241.                             dwVnum = CSpecialItemGroup::DRAIN_HP;
  242.                         }
  243.                         else if (name == "poison")
  244.                         {
  245.                             dwVnum = CSpecialItemGroup::POISON;
  246.                         }
  247.                         else if (name == "group")
  248.                         {
  249.                             dwVnum = CSpecialItemGroup::MOB_GROUP;
  250.                         }
  251.                         else
  252.                         {
  253.                             str_to_number(dwVnum, name.c_str());
  254.                             if (!ITEM_MANAGER::instance().GetTable(dwVnum))
  255.                             {
  256.                                 sys_err("ReadSpecialDropItemFile : there is no item %s : node %s", name.c_str(), stName.c_str());
  257.                                 M2_DELETE(pkGroup);
  258.  
  259.                                 return false;
  260.                             }
  261.                         }
  262.                     }
  263.  
  264.                     int iCount = 0;
  265.                     str_to_number(iCount, pTok->at(1).c_str());
  266.                     int iProb = 0;
  267.                     str_to_number(iProb, pTok->at(2).c_str());
  268.  
  269.                     int iRarePct = 0;
  270.                     if (pTok->size() > 3)
  271.                     {
  272.                         str_to_number(iRarePct, pTok->at(3).c_str());
  273.                     }
  274.  
  275.                     sys_log(0,"        name %s count %d prob %d rare %d", name.c_str(), iCount, iProb, iRarePct);
  276.                     pkGroup->AddItem(dwVnum, iCount, iProb, iRarePct);
  277.  
  278.                     // CHECK_UNIQUE_GROUP
  279.                     if (iVnum < 30000)
  280.                     {
  281.                         m_ItemToSpecialGroup[dwVnum] = iVnum;
  282.                     }
  283.                     // END_OF_CHECK_UNIQUE_GROUP
  284.  
  285.                     continue;
  286.                 }
  287.  
  288.                 break;
  289.             }
  290.             loader.SetParentNode();
  291.             if (CSpecialItemGroup::QUEST == type)
  292.             {
  293.                 m_map_pkQuestItemGroup.insert(std::make_pair(iVnum, pkGroup));
  294.             }
  295.             else
  296.             {
  297.                 m_map_pkSpecialItemGroup.insert(std::make_pair(iVnum, pkGroup));
  298.             }
  299.         }
  300.     }
  301.  
  302.     return true;
  303. }
  304.  
  305.  
  306. bool ITEM_MANAGER::ConvSpecialDropItemFile()
  307. {
  308.     char szSpecialItemGroupFileName[256];
  309.     snprintf(szSpecialItemGroupFileName, sizeof(szSpecialItemGroupFileName),
  310.         "%s/special_item_group.txt", LocaleService_GetBasePath().c_str());
  311.  
  312.     FILE *fp = fopen("special_item_group_vnum.txt", "w");
  313.     if (!fp)
  314.     {
  315.         sys_err("could not open file (%s)", "special_item_group_vnum.txt");
  316.         return false;
  317.     }
  318.  
  319.     CTextFileLoader loader;
  320.  
  321.     if (!loader.Load(szSpecialItemGroupFileName))
  322.     {
  323.         fclose(fp);
  324.         return false;
  325.     }
  326.  
  327.     std::string stName;
  328.  
  329.     for (DWORD i = 0; i < loader.GetChildNodeCount(); ++i)
  330.     {
  331.         loader.SetChildNode(i);
  332.  
  333.         loader.GetCurrentNodeName(&stName);
  334.  
  335.         int iVnum;
  336.  
  337.         if (!loader.GetTokenInteger("vnum", &iVnum))
  338.         {
  339.             sys_err("ConvSpecialDropItemFile : Syntax error %s : no vnum, node %s", szSpecialItemGroupFileName, stName.c_str());
  340.             loader.SetParentNode();
  341.             fclose(fp);
  342.             return false;
  343.         }
  344.  
  345.         std::string str;
  346.         int type = 0;
  347.         if (loader.GetTokenString("type", &str))
  348.         {
  349.             stl_lowers(str);
  350.             if (str == "pct")
  351.             {
  352.                 type = 1;
  353.             }
  354.         }
  355.  
  356.         TTokenVector * pTok;
  357.  
  358.         fprintf(fp, "Group  %s\n", stName.c_str());
  359.         fprintf(fp, "{\n");
  360.         fprintf(fp, "   Vnum    %i\n", iVnum);
  361.         if (type)
  362.             fprintf(fp, "   Type    Pct");
  363.  
  364.         for (int k = 1; k < 256; ++k)
  365.         {
  366.             char buf[4];
  367.             snprintf(buf, sizeof(buf), "%d", k);
  368.  
  369.             if (loader.GetTokenVector(buf, &pTok))
  370.             {
  371.                 const std::string& name = pTok->at(0);
  372.                 DWORD dwVnum = 0;
  373.  
  374.                 if (!GetVnumByOriginalName(name.c_str(), dwVnum))
  375.                 {
  376.                     if (    name == "경험치" ||
  377.                         name == "mob" ||
  378.                         name == "slow" ||
  379.                         name == "drain_hp" ||
  380.                         name == "poison" ||
  381.                         name == "group")
  382.                     {
  383.                         dwVnum = 0;
  384.                     }
  385.                     else
  386.                     {
  387.                         str_to_number(dwVnum, name.c_str());
  388.                         if (!ITEM_MANAGER::instance().GetTable(dwVnum))
  389.                         {
  390.                             sys_err("ReadSpecialDropItemFile : there is no item %s : node %s", name.c_str(), stName.c_str());
  391.                             fclose(fp);
  392.  
  393.                             return false;
  394.                         }
  395.                     }
  396.                 }
  397.  
  398.                 int iCount = 0;
  399.                 str_to_number(iCount, pTok->at(1).c_str());
  400.                 int iProb = 0;
  401.                 str_to_number(iProb, pTok->at(2).c_str());
  402.  
  403.                 int iRarePct = 0;
  404.                 if (pTok->size() > 3)
  405.                 {
  406.                     str_to_number(iRarePct, pTok->at(3).c_str());
  407.                 }
  408.  
  409.                 //    1   "기술 수련서"   1   100
  410.                 if (0 == dwVnum)
  411.                     fprintf(fp, "   %d  %s  %d  %d\n", k, name.c_str(), iCount, iProb);
  412.                 else
  413.                     fprintf(fp, "   %d  %u  %d  %d\n", k, dwVnum, iCount, iProb);
  414.  
  415.                 continue;
  416.             }
  417.  
  418.             break;
  419.         }
  420.         fprintf(fp, "}\n");
  421.         fprintf(fp, "\n");
  422.  
  423.         loader.SetParentNode();
  424.     }
  425.  
  426.     fclose(fp);
  427.     return true;
  428. }
  429.  
  430. bool ITEM_MANAGER::ReadEtcDropItemFile(const char * c_pszFileName)
  431. {
  432.     FILE * fp = fopen(c_pszFileName, "r");
  433.  
  434.     if (!fp)
  435.     {
  436.         sys_err("Cannot open %s", c_pszFileName);
  437.         return false;
  438.     }
  439.  
  440.     char buf[512];
  441.  
  442.     int lines = 0;
  443.  
  444.     while (fgets(buf, 512, fp))
  445.     {
  446.         ++lines;
  447.  
  448.         if (!*buf || *buf == '\n')
  449.             continue;
  450.  
  451.         char szItemName[256];
  452.         float fProb = 0.0f;
  453.  
  454.         strlcpy(szItemName, buf, sizeof(szItemName));
  455.         char * cpTab = strrchr(szItemName, '\t');
  456.  
  457.         if (!cpTab)
  458.             continue;
  459.  
  460.         *cpTab = '\0';
  461.         fProb = atof(cpTab + 1);
  462.  
  463.         if (!*szItemName || fProb == 0.0f)
  464.             continue;
  465.  
  466.         DWORD dwItemVnum;
  467.  
  468.         if (!ITEM_MANAGER::instance().GetVnumByOriginalName(szItemName, dwItemVnum))
  469.         {
  470.             sys_err("No such an item (name: %s)", szItemName);
  471.             fclose(fp);
  472.             return false;
  473.         }
  474.  
  475.         m_map_dwEtcItemDropProb[dwItemVnum] = (DWORD) (fProb * 10000.0f);
  476.         sys_log(0, "ETC_DROP_ITEM: %s prob %f", szItemName, fProb);
  477.     }
  478.  
  479.     fclose(fp);
  480.     return true;
  481. }
  482.  
  483. bool ITEM_MANAGER::ReadMonsterDropItemGroup(const char * c_pszFileName)
  484. {
  485.     CTextFileLoader loader;
  486.  
  487.     if (!loader.Load(c_pszFileName))
  488.         return false;
  489.  
  490.     for (DWORD i = 0; i < loader.GetChildNodeCount(); ++i)
  491.     {
  492.         std::string stName("");
  493.  
  494.         loader.GetCurrentNodeName(&stName);
  495.  
  496.         if (strncmp (stName.c_str(), "kr_", 3) == 0)
  497.         {
  498.             if (LC_IsYMIR())
  499.             {
  500.                 stName.assign(stName, 3, stName.size() - 3);
  501.             }
  502.             else
  503.             {
  504.                 continue;
  505.             }
  506.         }
  507.  
  508.         loader.SetChildNode(i);
  509.  
  510.         int iMobVnum = 0;
  511.         int iKillDrop = 0;
  512.         int iLevelLimit = 0;
  513.  
  514.         std::string strType("");
  515.  
  516.         if (!loader.GetTokenString("type", &strType))
  517.         {
  518.             sys_err("ReadMonsterDropItemGroup : Syntax error %s : no type (kill|drop), node %s", c_pszFileName, stName.c_str());
  519.             loader.SetParentNode();
  520.             return false;
  521.         }
  522.  
  523.         if (!loader.GetTokenInteger("mob", &iMobVnum))
  524.         {
  525.             sys_err("ReadMonsterDropItemGroup : Syntax error %s : no mob vnum, node %s", c_pszFileName, stName.c_str());
  526.             loader.SetParentNode();
  527.             return false;
  528.         }
  529.  
  530.         if (strType == "kill")
  531.         {
  532.             if (!loader.GetTokenInteger("kill_drop", &iKillDrop))
  533.             {
  534.                 sys_err("ReadMonsterDropItemGroup : Syntax error %s : no kill drop count, node %s", c_pszFileName, stName.c_str());
  535.                 loader.SetParentNode();
  536.                 return false;
  537.             }
  538.         }
  539.         else
  540.         {
  541.             iKillDrop = 1;
  542.         }
  543.  
  544.         if ( strType == "limit" )
  545.         {
  546.             if ( !loader.GetTokenInteger("level_limit", &iLevelLimit) )
  547.             {
  548.                 sys_err("ReadmonsterDropItemGroup : Syntax error %s : no level_limit, node %s", c_pszFileName, stName.c_str());
  549.                 loader.SetParentNode();
  550.                 return false;
  551.             }
  552.         }
  553.         else
  554.         {
  555.             iLevelLimit = 0;
  556.         }
  557.  
  558.         sys_log(0,"MOB_ITEM_GROUP %s [%s] %d %d", stName.c_str(), strType.c_str(), iMobVnum, iKillDrop);
  559.  
  560.         if (iKillDrop == 0)
  561.         {
  562.             loader.SetParentNode();
  563.             continue;
  564.         }
  565.  
  566.         TTokenVector* pTok = NULL;
  567.  
  568.         if (strType == "kill")
  569.         {
  570.             CMobItemGroup * pkGroup = M2_NEW CMobItemGroup(iMobVnum, iKillDrop, stName);
  571.  
  572.             for (int k = 1; k < 256; ++k)
  573.             {
  574.                 char buf[4];
  575.                 snprintf(buf, sizeof(buf), "%d", k);
  576.  
  577.                 if (loader.GetTokenVector(buf, &pTok))
  578.                 {
  579.                     //sys_log(1, "               %s %s", pTok->at(0).c_str(), pTok->at(1).c_str());
  580.                     std::string& name = pTok->at(0);
  581.                     DWORD dwVnum = 0;
  582.  
  583.                     if (!GetVnumByOriginalName(name.c_str(), dwVnum))
  584.                     {
  585.                         str_to_number(dwVnum, name.c_str());
  586.                         if (!ITEM_MANAGER::instance().GetTable(dwVnum))
  587.                         {
  588.                             sys_err("ReadMonsterDropItemGroup : there is no item %s : node %s : vnum %d", name.c_str(), stName.c_str(), dwVnum);
  589.                             return false;
  590.                         }
  591.                     }
  592.  
  593.                     int iCount = 0;
  594.                     str_to_number(iCount, pTok->at(1).c_str());
  595.  
  596.                     if (iCount<1)
  597.                     {
  598.                         sys_err("ReadMonsterDropItemGroup : there is no count for item %s : node %s : vnum %d, count %d", name.c_str(), stName.c_str(), dwVnum, iCount);
  599.                         return false;
  600.                     }
  601.  
  602.                     int iPartPct = 0;
  603.                     str_to_number(iPartPct, pTok->at(2).c_str());
  604.  
  605.                     if (iPartPct == 0)
  606.                     {
  607.                         sys_err("ReadMonsterDropItemGroup : there is no drop percent for item %s : node %s : vnum %d, count %d, pct %d", name.c_str(), stName.c_str(), iPartPct);
  608.                         return false;
  609.                     }
  610.  
  611.                     int iRarePct = 0;
  612.                     str_to_number(iRarePct, pTok->at(3).c_str());
  613.                     iRarePct = MINMAX(0, iRarePct, 100);
  614.  
  615.                     sys_log(0,"        %s count %d rare %d", name.c_str(), iCount, iRarePct);
  616.                     pkGroup->AddItem(dwVnum, iCount, iPartPct, iRarePct);
  617.                     continue;
  618.                 }
  619.  
  620.                 break;
  621.             }
  622.             m_map_pkMobItemGroup.insert(std::map<DWORD, CMobItemGroup*>::value_type(iMobVnum, pkGroup));
  623.  
  624.         }
  625.         else if (strType == "drop")
  626.         {
  627.             CDropItemGroup* pkGroup;
  628.             bool bNew = true;
  629.             itertype(m_map_pkDropItemGroup) it = m_map_pkDropItemGroup.find (iMobVnum);
  630.             if (it == m_map_pkDropItemGroup.end())
  631.             {
  632.                 pkGroup = M2_NEW CDropItemGroup(0, iMobVnum, stName);
  633.             }
  634.             else
  635.             {
  636.                 bNew = false;
  637.                 CDropItemGroup* pkGroup = it->second;
  638.                 (void)pkGroup;
  639.             }
  640.  
  641.             for (int k = 1; k < 256; ++k)
  642.             {
  643.                 char buf[4];
  644.                 snprintf(buf, sizeof(buf), "%d", k);
  645.  
  646.                 if (loader.GetTokenVector(buf, &pTok))
  647.                 {
  648.                     std::string& name = pTok->at(0);
  649.                     DWORD dwVnum = 0;
  650.  
  651.                     if (!GetVnumByOriginalName(name.c_str(), dwVnum))
  652.                     {
  653.                         str_to_number(dwVnum, name.c_str());
  654.                         if (!ITEM_MANAGER::instance().GetTable(dwVnum))
  655.                         {
  656.                             sys_err("ReadDropItemGroup : there is no item %s : node %s", name.c_str(), stName.c_str());
  657.                             M2_DELETE(pkGroup);
  658.  
  659.                             return false;
  660.                         }
  661.                     }
  662.  
  663.                     int iCount = 0;
  664.                     str_to_number(iCount, pTok->at(1).c_str());
  665.  
  666.                     if (iCount < 1)
  667.                     {
  668.                         sys_err("ReadMonsterDropItemGroup : there is no count for item %s : node %s", name.c_str(), stName.c_str());
  669.                         M2_DELETE(pkGroup);
  670.  
  671.                         return false;
  672.                     }
  673.  
  674.                     float fPercent = atof(pTok->at(2).c_str());
  675.  
  676.                     DWORD dwPct = (DWORD)(10000.0f * fPercent);
  677.  
  678.                     sys_log(0,"        name %s pct %d count %d", name.c_str(), dwPct, iCount);
  679.                     pkGroup->AddItem(dwVnum, dwPct, iCount);
  680.  
  681.                     continue;
  682.                 }
  683.  
  684.                 break;
  685.             }
  686.             if (bNew)
  687.                 m_map_pkDropItemGroup.insert(std::map<DWORD, CDropItemGroup*>::value_type(iMobVnum, pkGroup));
  688.  
  689.         }
  690.         else if ( strType == "limit" )
  691.         {
  692.             CLevelItemGroup* pkLevelItemGroup = M2_NEW CLevelItemGroup(iLevelLimit);
  693.  
  694.             for ( int k=1; k < 256; k++ )
  695.             {
  696.                 char buf[4];
  697.                 snprintf(buf, sizeof(buf), "%d", k);
  698.  
  699.                 if ( loader.GetTokenVector(buf, &pTok) )
  700.                 {
  701.                     std::string& name = pTok->at(0);
  702.                     DWORD dwItemVnum = 0;
  703.  
  704.                     if (false == GetVnumByOriginalName(name.c_str(), dwItemVnum))
  705.                     {
  706.                         str_to_number(dwItemVnum, name.c_str());
  707.                         if ( !ITEM_MANAGER::instance().GetTable(dwItemVnum) )
  708.                         {
  709.                             M2_DELETE(pkLevelItemGroup);
  710.                             return false;
  711.                         }
  712.                     }
  713.  
  714.                     int iCount = 0;
  715.                     str_to_number(iCount, pTok->at(1).c_str());
  716.  
  717.                     if (iCount < 1)
  718.                     {
  719.                         M2_DELETE(pkLevelItemGroup);
  720.                         return false;
  721.                     }
  722.  
  723.                     float fPct = atof(pTok->at(2).c_str());
  724.                     DWORD dwPct = (DWORD)(10000.0f * fPct);
  725.  
  726.                     pkLevelItemGroup->AddItem(dwItemVnum, dwPct, iCount);
  727.  
  728.                     continue;
  729.                 }
  730.  
  731.                 break;
  732.             }
  733.  
  734.             m_map_pkLevelItemGroup.insert(std::map<DWORD, CLevelItemGroup*>::value_type(iMobVnum, pkLevelItemGroup));
  735.         }
  736.         else if (strType == "thiefgloves")
  737.         {
  738.             CBuyerThiefGlovesItemGroup* pkGroup = M2_NEW CBuyerThiefGlovesItemGroup(0, iMobVnum, stName);
  739.  
  740.             for (int k = 1; k < 256; ++k)
  741.             {
  742.                 char buf[4];
  743.                 snprintf(buf, sizeof(buf), "%d", k);
  744.  
  745.                 if (loader.GetTokenVector(buf, &pTok))
  746.                 {
  747.                     std::string& name = pTok->at(0);
  748.                     DWORD dwVnum = 0;
  749.  
  750.                     if (!GetVnumByOriginalName(name.c_str(), dwVnum))
  751.                     {
  752.                         str_to_number(dwVnum, name.c_str());
  753.                         if (!ITEM_MANAGER::instance().GetTable(dwVnum))
  754.                         {
  755.                             sys_err("ReadDropItemGroup : there is no item %s : node %s", name.c_str(), stName.c_str());
  756.                             M2_DELETE(pkGroup);
  757.  
  758.                             return false;
  759.                         }
  760.                     }
  761.  
  762.                     int iCount = 0;
  763.                     str_to_number(iCount, pTok->at(1).c_str());
  764.  
  765.                     if (iCount < 1)
  766.                     {
  767.                         sys_err("ReadMonsterDropItemGroup : there is no count for item %s : node %s", name.c_str(), stName.c_str());
  768.                         M2_DELETE(pkGroup);
  769.  
  770.                         return false;
  771.                     }
  772.  
  773.                     float fPercent = atof(pTok->at(2).c_str());
  774.  
  775.                     DWORD dwPct = (DWORD)(10000.0f * fPercent);
  776.  
  777.                     sys_log(0,"        name %s pct %d count %d", name.c_str(), dwPct, iCount);
  778.                     pkGroup->AddItem(dwVnum, dwPct, iCount);
  779.  
  780.                     continue;
  781.                 }
  782.  
  783.                 break;
  784.             }
  785.  
  786.             m_map_pkGloveItemGroup.insert(std::map<DWORD, CBuyerThiefGlovesItemGroup*>::value_type(iMobVnum, pkGroup));
  787.         }
  788.         else
  789.         {
  790.             sys_err("ReadMonsterDropItemGroup : Syntax error %s : invalid type %s (kill|drop), node %s", c_pszFileName, strType.c_str(), stName.c_str());
  791.             loader.SetParentNode();
  792.             return false;
  793.         }
  794.  
  795.         loader.SetParentNode();
  796.     }
  797.  
  798.     return true;
  799. }
  800.  
  801. bool ITEM_MANAGER::ReadDropItemGroup(const char * c_pszFileName)
  802. {
  803.     CTextFileLoader loader;
  804.  
  805.     if (!loader.Load(c_pszFileName))
  806.         return false;
  807.  
  808.     std::string stName;
  809.  
  810.     for (DWORD i = 0; i < loader.GetChildNodeCount(); ++i)
  811.     {
  812.         loader.SetChildNode(i);
  813.  
  814.         loader.GetCurrentNodeName(&stName);
  815.  
  816.         int iVnum;
  817.         int iMobVnum;
  818.  
  819.         if (!loader.GetTokenInteger("vnum", &iVnum))
  820.         {
  821.             sys_err("ReadDropItemGroup : Syntax error %s : no vnum, node %s", c_pszFileName, stName.c_str());
  822.             loader.SetParentNode();
  823.             return false;
  824.         }
  825.  
  826.         if (!loader.GetTokenInteger("mob", &iMobVnum))
  827.         {
  828.             sys_err("ReadDropItemGroup : Syntax error %s : no mob vnum, node %s", c_pszFileName, stName.c_str());
  829.             loader.SetParentNode();
  830.             return false;
  831.         }
  832.  
  833.         sys_log(0,"DROP_ITEM_GROUP %s %d", stName.c_str(), iMobVnum);
  834.  
  835.         TTokenVector * pTok;
  836.  
  837.         itertype(m_map_pkDropItemGroup) it = m_map_pkDropItemGroup.find(iMobVnum);
  838.  
  839.         CDropItemGroup* pkGroup;
  840.  
  841.         if (it == m_map_pkDropItemGroup.end())
  842.             pkGroup = M2_NEW CDropItemGroup(iVnum, iMobVnum, stName);
  843.         else
  844.             pkGroup = it->second;
  845.  
  846.         for (int k = 1; k < 256; ++k)
  847.         {
  848.             char buf[4];
  849.             snprintf(buf, sizeof(buf), "%d", k);
  850.  
  851.             if (loader.GetTokenVector(buf, &pTok))
  852.             {
  853.                 std::string& name = pTok->at(0);
  854.                 DWORD dwVnum = 0;
  855.  
  856.                 if (!GetVnumByOriginalName(name.c_str(), dwVnum))
  857.                 {
  858.                     str_to_number(dwVnum, name.c_str());
  859.                     if (!ITEM_MANAGER::instance().GetTable(dwVnum))
  860.                     {
  861.                         sys_err("ReadDropItemGroup : there is no item %s : node %s", name.c_str(), stName.c_str());
  862.  
  863.                         if (it == m_map_pkDropItemGroup.end())
  864.                             M2_DELETE(pkGroup);
  865.  
  866.                         return false;
  867.                     }
  868.                 }
  869.  
  870.                 float fPercent = atof(pTok->at(1).c_str());
  871.  
  872.                 DWORD dwPct = (DWORD)(10000.0f * fPercent);
  873.  
  874.                 int iCount = 1;
  875.                 if (pTok->size() > 2)
  876.                     str_to_number(iCount, pTok->at(2).c_str());
  877.  
  878.                 if (iCount < 1)
  879.                 {
  880.                     sys_err("ReadDropItemGroup : there is no count for item %s : node %s", name.c_str(), stName.c_str());
  881.  
  882.                     if (it == m_map_pkDropItemGroup.end())
  883.                         M2_DELETE(pkGroup);
  884.  
  885.                     return false;
  886.                 }
  887.  
  888.                 sys_log(0,"        %s %d %d", name.c_str(), dwPct, iCount);
  889.                 pkGroup->AddItem(dwVnum, dwPct, iCount);
  890.                 continue;
  891.             }
  892.  
  893.             break;
  894.         }
  895.  
  896.         if (it == m_map_pkDropItemGroup.end())
  897.             m_map_pkDropItemGroup.insert(std::map<DWORD, CDropItemGroup*>::value_type(iMobVnum, pkGroup));
  898.  
  899.         loader.SetParentNode();
  900.     }
  901.  
  902.     return true;
  903. }
  904.  
  905. bool ITEM_MANAGER::ReadItemVnumMaskTable(const char * c_pszFileName)
  906. {
  907.     FILE *fp = fopen(c_pszFileName, "r");
  908.     if (!fp)
  909.     {
  910.         return false;
  911.     }
  912.  
  913.     int ori_vnum, new_vnum;
  914.     while (fscanf(fp, "%u %u", &ori_vnum, &new_vnum) != EOF)
  915.     {
  916.         m_map_new_to_ori.insert (TMapDW2DW::value_type (new_vnum, ori_vnum));
  917.     }
  918.     fclose(fp);
  919.     return true;
  920. }
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!