API tools faq
paste
Advertisement
masodikbela

item_manager_read_tables.cpp (m2dev topic)

masodikbela
Jan 17th, 2016
542
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 25.91 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, bool isReloading)
  121. {
  122.     CTextFileLoader loader;
  123.  
  124.     if (!loader.Load(c_pszFileName))
  125.         return false;
  126.  
  127.     std::string stName;
  128.     std::map<DWORD, CSpecialAttrGroup*> tempSpecAttr;
  129.     std::map<DWORD, CSpecialItemGroup*> tempSpecItem;
  130.     std::map<DWORD, CSpecialItemGroup*> tempSpecItemQuest;
  131.     if (isReloading)
  132.         sys_log(0, "RELOADING SpecialDrop");
  133.  
  134.     for (DWORD i = 0; i < loader.GetChildNodeCount(); ++i)
  135.     {
  136.         loader.SetChildNode(i);
  137.  
  138.         loader.GetCurrentNodeName(&stName);
  139.  
  140.         int iVnum;
  141.  
  142.         if (!loader.GetTokenInteger("vnum", &iVnum))
  143.         {
  144.             sys_err("ReadSpecialDropItemFile : Syntax error %s : no vnum, node %s", c_pszFileName, stName.c_str());
  145.             loader.SetParentNode();
  146.             return false;
  147.         }
  148.  
  149.         sys_log(0,"DROP_ITEM_GROUP %s %d", stName.c_str(), iVnum);
  150.  
  151.         TTokenVector * pTok;
  152.  
  153.         //
  154.         std::string stType;
  155.         int type = CSpecialItemGroup::NORMAL;
  156.         if (loader.GetTokenString("type", &stType))
  157.         {
  158.             stl_lowers(stType);
  159.             if (stType == "pct")
  160.             {
  161.                 type = CSpecialItemGroup::PCT;
  162.             }
  163.             else if (stType == "quest")
  164.             {
  165.                 type = CSpecialItemGroup::QUEST;
  166.                 quest::CQuestManager::instance().RegisterNPCVnum(iVnum);
  167.             }
  168.             else if (stType == "special")
  169.             {
  170.                 type = CSpecialItemGroup::SPECIAL;
  171.             }
  172.         }
  173.  
  174.         if ("attr" == stType)
  175.         {
  176.             CSpecialAttrGroup * pkGroup = M2_NEW CSpecialAttrGroup(iVnum);
  177.             for (int k = 1; k < 256; ++k)
  178.             {
  179.                 char buf[4];
  180.                 snprintf(buf, sizeof(buf), "%d", k);
  181.  
  182.                 if (loader.GetTokenVector(buf, &pTok))
  183.                 {
  184.                     DWORD apply_type = 0;
  185.                     int apply_value = 0;
  186.                     str_to_number(apply_type, pTok->at(0).c_str());
  187.                     if (0 == apply_type)
  188.                     {
  189.                         apply_type = FN_get_apply_type(pTok->at(0).c_str());
  190.                         if (0 == apply_type)
  191.                         {
  192.                             sys_err ("Invalid APPLY_TYPE %s in Special Item Group Vnum %d", pTok->at(0).c_str(), iVnum);
  193.                             return false;
  194.                         }
  195.                     }
  196.                     str_to_number(apply_value, pTok->at(1).c_str());
  197.                     if (apply_type > MAX_APPLY_NUM)
  198.                     {
  199.                         sys_err ("Invalid APPLY_TYPE %u in Special Item Group Vnum %d", apply_type, iVnum);
  200.                         M2_DELETE(pkGroup);
  201.                         return false;
  202.                     }
  203.                     pkGroup->m_vecAttrs.push_back(CSpecialAttrGroup::CSpecialAttrInfo(apply_type, apply_value));
  204.                 }
  205.                 else
  206.                 {
  207.                     break;
  208.                 }
  209.             }
  210.             if (loader.GetTokenVector("effect", &pTok))
  211.             {
  212.                 pkGroup->m_stEffectFileName = pTok->at(0);
  213.             }
  214.             loader.SetParentNode();
  215.             if (isReloading)
  216.                 tempSpecAttr.insert(std::make_pair(iVnum, pkGroup));
  217.             else
  218.                 m_map_pkSpecialAttrGroup.insert(std::make_pair(iVnum, pkGroup));
  219.         }
  220.         else
  221.         {
  222.             CSpecialItemGroup * pkGroup = M2_NEW CSpecialItemGroup(iVnum, type);
  223.             for (int k = 1; k < 256; ++k)
  224.             {
  225.                 char buf[4];
  226.                 snprintf(buf, sizeof(buf), "%d", k);
  227.  
  228.                 if (loader.GetTokenVector(buf, &pTok))
  229.                 {
  230.                     const std::string& name = pTok->at(0);
  231.                     DWORD dwVnum = 0;
  232.  
  233.                     if (!GetVnumByOriginalName(name.c_str(), dwVnum))
  234.                     {
  235.                         if (name == "°ćÇčġ" || name == "exp")
  236.                         {
  237.                             dwVnum = CSpecialItemGroup::EXP;
  238.                         }
  239.                         else if (name == "mob")
  240.                         {
  241.                             dwVnum = CSpecialItemGroup::MOB;
  242.                         }
  243.                         else if (name == "slow")
  244.                         {
  245.                             dwVnum = CSpecialItemGroup::SLOW;
  246.                         }
  247.                         else if (name == "drain_hp")
  248.                         {
  249.                             dwVnum = CSpecialItemGroup::DRAIN_HP;
  250.                         }
  251.                         else if (name == "poison")
  252.                         {
  253.                             dwVnum = CSpecialItemGroup::POISON;
  254.                         }
  255.                         else if (name == "group")
  256.                         {
  257.                             dwVnum = CSpecialItemGroup::MOB_GROUP;
  258.                         }
  259.                         else
  260.                         {
  261.                             str_to_number(dwVnum, name.c_str());
  262.                             if (!ITEM_MANAGER::instance().GetTable(dwVnum))
  263.                             {
  264.                                 sys_err("ReadSpecialDropItemFile : there is no item %s : node %s", name.c_str(), stName.c_str());
  265.                                 M2_DELETE(pkGroup);
  266.  
  267.                                 return false;
  268.                             }
  269.                         }
  270.                     }
  271.  
  272.                     int iCount = 0;
  273.                     str_to_number(iCount, pTok->at(1).c_str());
  274.                     int iProb = 0;
  275.                     str_to_number(iProb, pTok->at(2).c_str());
  276.  
  277.                     int iRarePct = 0;
  278.                     if (pTok->size() > 3)
  279.                     {
  280.                         str_to_number(iRarePct, pTok->at(3).c_str());
  281.                     }
  282.  
  283.                     sys_log(0,"        name %s count %d prob %d rare %d", name.c_str(), iCount, iProb, iRarePct);
  284.                     pkGroup->AddItem(dwVnum, iCount, iProb, iRarePct);
  285.  
  286.  
  287.                     // CHECK_UNIQUE_GROUP
  288.                     if (iVnum < 30000)
  289.                     {
  290.                         m_ItemToSpecialGroup[dwVnum] = iVnum;
  291.                     }
  292.                     // END_OF_CHECK_UNIQUE_GROUP
  293.  
  294.                     continue;
  295.                 }
  296.  
  297.                 break;
  298.             }
  299.             loader.SetParentNode();
  300.             if (CSpecialItemGroup::QUEST == type)
  301.             {
  302.                 if (isReloading)
  303.                     tempSpecItemQuest.insert(std::make_pair(iVnum, pkGroup));
  304.                 else
  305.                     m_map_pkQuestItemGroup.insert(std::make_pair(iVnum, pkGroup));
  306.             }
  307.             else
  308.             {
  309.                 if (isReloading)
  310.                     tempSpecItem.insert(std::make_pair(iVnum, pkGroup));
  311.                 else
  312.                     m_map_pkSpecialItemGroup.insert(std::make_pair(iVnum, pkGroup));
  313.             }
  314.         }
  315.     }
  316.  
  317.     if (isReloading)
  318.     {
  319.         for (std::map<DWORD, CSpecialItemGroup*>::iterator it = m_map_pkQuestItemGroup.begin(); it != m_map_pkQuestItemGroup.end(); it++)
  320.             M2_DELETE(it->second);
  321.         m_map_pkQuestItemGroup.clear();
  322.         for (std::map<DWORD, CSpecialItemGroup*>::iterator it = m_map_pkSpecialItemGroup.begin(); it != m_map_pkSpecialItemGroup.end(); it++)
  323.             M2_DELETE(it->second);
  324.         m_map_pkSpecialItemGroup.clear();
  325.         for (std::map<DWORD, CSpecialAttrGroup*>::iterator it = m_map_pkSpecialAttrGroup.begin(); it != m_map_pkSpecialAttrGroup.end(); it++)
  326.             M2_DELETE(it->second);
  327.         m_map_pkSpecialAttrGroup.clear();
  328.  
  329.         for (std::map<DWORD, CSpecialAttrGroup*>::iterator it = tempSpecAttr.begin(); it != tempSpecAttr.end(); it++)
  330.         {
  331.             m_map_pkSpecialAttrGroup[it->first] = it->second;
  332.         }
  333.  
  334.         for (std::map<DWORD, CSpecialItemGroup*>::iterator it = tempSpecItem.begin(); it != tempSpecItem.end(); it++)
  335.         {
  336.             m_map_pkSpecialItemGroup[it->first] = it->second;
  337.         }
  338.  
  339.         for (std::map<DWORD, CSpecialItemGroup*>::iterator it = tempSpecItemQuest.begin(); it != tempSpecItemQuest.end(); it++)
  340.         {
  341.             m_map_pkQuestItemGroup[it->first] = it->second;
  342.         }
  343.     }
  344.  
  345.     return true;
  346. }
  347.  
  348.  
  349. bool ITEM_MANAGER::ConvSpecialDropItemFile()
  350. {
  351.     char szSpecialItemGroupFileName[256];
  352.     snprintf(szSpecialItemGroupFileName, sizeof(szSpecialItemGroupFileName),
  353.         "%s/special_item_group.txt", LocaleService_GetBasePath().c_str());
  354.  
  355.     FILE *fp = fopen("special_item_group_vnum.txt", "w");
  356.     if (!fp)
  357.     {
  358.         sys_err("could not open file (%s)", "special_item_group_vnum.txt");
  359.         return false;
  360.     }
  361.  
  362.     CTextFileLoader loader;
  363.  
  364.     if (!loader.Load(szSpecialItemGroupFileName))
  365.     {
  366.         fclose(fp);
  367.         return false;
  368.     }
  369.  
  370.     std::string stName;
  371.  
  372.     for (DWORD i = 0; i < loader.GetChildNodeCount(); ++i)
  373.     {
  374.         loader.SetChildNode(i);
  375.  
  376.         loader.GetCurrentNodeName(&stName);
  377.  
  378.         int iVnum;
  379.  
  380.         if (!loader.GetTokenInteger("vnum", &iVnum))
  381.         {
  382.             sys_err("ConvSpecialDropItemFile : Syntax error %s : no vnum, node %s", szSpecialItemGroupFileName, stName.c_str());
  383.             loader.SetParentNode();
  384.             fclose(fp);
  385.             return false;
  386.         }
  387.  
  388.         std::string str;
  389.         int type = 0;
  390.         if (loader.GetTokenString("type", &str))
  391.         {
  392.             stl_lowers(str);
  393.             if (str == "pct")
  394.             {
  395.                 type = 1;
  396.             }
  397.         }
  398.  
  399.         TTokenVector * pTok;
  400.  
  401.         fprintf(fp, "Group  %s\n", stName.c_str());
  402.         fprintf(fp, "{\n");
  403.         fprintf(fp, "   Vnum    %i\n", iVnum);
  404.         if (type)
  405.             fprintf(fp, "   Type    Pct");
  406.  
  407.         for (int k = 1; k < 256; ++k)
  408.         {
  409.             char buf[4];
  410.             snprintf(buf, sizeof(buf), "%d", k);
  411.  
  412.             if (loader.GetTokenVector(buf, &pTok))
  413.             {
  414.                 const std::string& name = pTok->at(0);
  415.                 DWORD dwVnum = 0;
  416.  
  417.                 if (!GetVnumByOriginalName(name.c_str(), dwVnum))
  418.                 {
  419.                     if (    name == "°ćÇčġ" ||
  420.                         name == "mob" ||
  421.                         name == "slow" ||
  422.                         name == "drain_hp" ||
  423.                         name == "poison" ||
  424.                         name == "group")
  425.                     {
  426.                         dwVnum = 0;
  427.                     }
  428.                     else
  429.                     {
  430.                         str_to_number(dwVnum, name.c_str());
  431.                         if (!ITEM_MANAGER::instance().GetTable(dwVnum))
  432.                         {
  433.                             sys_err("ReadSpecialDropItemFile : there is no item %s : node %s", name.c_str(), stName.c_str());
  434.                             fclose(fp);
  435.  
  436.                             return false;
  437.                         }
  438.                     }
  439.                 }
  440.  
  441.                 int iCount = 0;
  442.                 str_to_number(iCount, pTok->at(1).c_str());
  443.                 int iProb = 0;
  444.                 str_to_number(iProb, pTok->at(2).c_str());
  445.  
  446.                 int iRarePct = 0;
  447.                 if (pTok->size() > 3)
  448.                 {
  449.                     str_to_number(iRarePct, pTok->at(3).c_str());
  450.                 }
  451.  
  452.                 //    1   "±âĽú Ľö·ĂĽ­"   1   100
  453.                 if (0 == dwVnum)
  454.                     fprintf(fp, "   %d  %s  %d  %d\n", k, name.c_str(), iCount, iProb);
  455.                 else
  456.                     fprintf(fp, "   %d  %u  %d  %d\n", k, dwVnum, iCount, iProb);
  457.  
  458.                 continue;
  459.             }
  460.  
  461.             break;
  462.         }
  463.         fprintf(fp, "}\n");
  464.         fprintf(fp, "\n");
  465.  
  466.         loader.SetParentNode();
  467.     }
  468.  
  469.     fclose(fp);
  470.     return true;
  471. }
  472.  
  473. bool ITEM_MANAGER::ReadEtcDropItemFile(const char * c_pszFileName, bool isReloading)
  474. {
  475.     FILE * fp = fopen(c_pszFileName, "r");
  476.  
  477.     if (!fp)
  478.     {
  479.         sys_err("Cannot open %s", c_pszFileName);
  480.         return false;
  481.     }
  482.  
  483.     std::map<DWORD, DWORD> tempLoader;
  484.     if (isReloading)
  485.     {
  486.         sys_log(0, "RELOADING EtcDrop");
  487.     }
  488.  
  489.     char buf[512];
  490.  
  491.     int lines = 0;
  492.  
  493.     while (fgets(buf, 512, fp))
  494.     {
  495.         ++lines;
  496.  
  497.         if (!*buf || *buf == '\n')
  498.             continue;
  499.  
  500.         char szItemName[256];
  501.         float fProb = 0.0f;
  502.  
  503.         strlcpy(szItemName, buf, sizeof(szItemName));
  504.         char * cpTab = strrchr(szItemName, '\t');
  505.  
  506.         if (!cpTab)
  507.             continue;
  508.  
  509.         *cpTab = '\0';
  510.         fProb = atof(cpTab + 1);
  511.  
  512.         if (!*szItemName || fProb == 0.0f)
  513.             continue;
  514.  
  515.         DWORD dwItemVnum;
  516.  
  517.         if (!ITEM_MANAGER::instance().GetVnumByOriginalName(szItemName, dwItemVnum))
  518.         {
  519.             sys_err("No such an item (name: %s)", szItemName);
  520.             fclose(fp);
  521.             return false;
  522.         }
  523.         if (isReloading)
  524.             tempLoader[dwItemVnum] = (DWORD)(fProb * 10000.0f);
  525.         else
  526.             m_map_dwEtcItemDropProb[dwItemVnum] = (DWORD) (fProb * 10000.0f);
  527.         sys_log(0, "ETC_DROP_ITEM: %s prob %f", szItemName, fProb);
  528.     }
  529.  
  530.     fclose(fp);
  531.     if (isReloading)
  532.     {
  533.         m_map_dwEtcItemDropProb.clear();
  534.         for (std::map<DWORD, DWORD>::iterator it = tempLoader.begin(); it != tempLoader.end(); it++)
  535.         {
  536.             m_map_dwEtcItemDropProb[it->first] = it->second;
  537.         }
  538.     }
  539.     return true;
  540. }
  541.  
  542. bool ITEM_MANAGER::ReadMonsterDropItemGroup(const char * c_pszFileName, bool isReloading)
  543. {
  544.     CTextFileLoader loader;
  545.  
  546.     if (!loader.Load(c_pszFileName))
  547.         return false;
  548.     std::map<DWORD, CMobItemGroup*> temMobItemGr;
  549.     std::map<DWORD, CDropItemGroup*> tempDropItemGr;
  550.     std::map<DWORD, CLevelItemGroup*> tempLevelItemGr;
  551.     std::map<DWORD, CBuyerThiefGlovesItemGroup*> tempThiefGlovesGr;
  552.     if (isReloading)
  553.     {
  554.         sys_log(0, "RELOADING MonsterDrop");
  555.     }
  556.  
  557.     for (DWORD i = 0; i < loader.GetChildNodeCount(); ++i)
  558.     {
  559.         std::string stName("");
  560.  
  561.         loader.GetCurrentNodeName(&stName);
  562.  
  563.         if (strncmp (stName.c_str(), "kr_", 3) == 0)
  564.         {
  565.             if (LC_IsYMIR())
  566.             {
  567.                 stName.assign(stName, 3, stName.size() - 3);
  568.             }
  569.             else
  570.             {
  571.                 continue;
  572.             }
  573.         }
  574.  
  575.         loader.SetChildNode(i);
  576.  
  577.         int iMobVnum = 0;
  578.         int iKillDrop = 0;
  579.         int iLevelLimit = 0;
  580.  
  581.         std::string strType("");
  582.  
  583.         if (!loader.GetTokenString("type", &strType))
  584.         {
  585.             sys_err("ReadMonsterDropItemGroup : Syntax error %s : no type (kill|drop), node %s", c_pszFileName, stName.c_str());
  586.             loader.SetParentNode();
  587.             return false;
  588.         }
  589.  
  590.         if (!loader.GetTokenInteger("mob", &iMobVnum))
  591.         {
  592.             sys_err("ReadMonsterDropItemGroup : Syntax error %s : no mob vnum, node %s", c_pszFileName, stName.c_str());
  593.             loader.SetParentNode();
  594.             return false;
  595.         }
  596.  
  597.         if (strType == "kill")
  598.         {
  599.             if (!loader.GetTokenInteger("kill_drop", &iKillDrop))
  600.             {
  601.                 sys_err("ReadMonsterDropItemGroup : Syntax error %s : no kill drop count, node %s", c_pszFileName, stName.c_str());
  602.                 loader.SetParentNode();
  603.                 return false;
  604.             }
  605.         }
  606.         else
  607.         {
  608.             iKillDrop = 1;
  609.         }
  610.  
  611.         if ( strType == "limit" )
  612.         {
  613.             if ( !loader.GetTokenInteger("level_limit", &iLevelLimit) )
  614.             {
  615.                 sys_err("ReadmonsterDropItemGroup : Syntax error %s : no level_limit, node %s", c_pszFileName, stName.c_str());
  616.                 loader.SetParentNode();
  617.                 return false;
  618.             }
  619.         }
  620.         else
  621.         {
  622.             iLevelLimit = 0;
  623.         }
  624.  
  625.         sys_log(0,"MOB_ITEM_GROUP %s [%s] %d %d", stName.c_str(), strType.c_str(), iMobVnum, iKillDrop);
  626.  
  627.         if (iKillDrop == 0)
  628.         {
  629.             loader.SetParentNode();
  630.             continue;
  631.         }
  632.  
  633.         TTokenVector* pTok = NULL;
  634.  
  635.         if (strType == "kill")
  636.         {
  637.             CMobItemGroup * pkGroup = M2_NEW CMobItemGroup(iMobVnum, iKillDrop, stName);
  638.  
  639.             for (int k = 1; k < 256; ++k)
  640.             {
  641.                 char buf[4];
  642.                 snprintf(buf, sizeof(buf), "%d", k);
  643.  
  644.                 if (loader.GetTokenVector(buf, &pTok))
  645.                 {
  646.                     //sys_log(1, "               %s %s", pTok->at(0).c_str(), pTok->at(1).c_str());
  647.                     std::string& name = pTok->at(0);
  648.                     DWORD dwVnum = 0;
  649.  
  650.                     if (!GetVnumByOriginalName(name.c_str(), dwVnum))
  651.                     {
  652.                         str_to_number(dwVnum, name.c_str());
  653.                         if (!ITEM_MANAGER::instance().GetTable(dwVnum))
  654.                         {
  655.                             sys_err("ReadMonsterDropItemGroup : there is no item %s : node %s : vnum %d", name.c_str(), stName.c_str(), dwVnum);
  656.  
  657.                             return false;
  658.                         }
  659.                     }
  660.  
  661.                     int iCount = 0;
  662.                     str_to_number(iCount, pTok->at(1).c_str());
  663.  
  664.                     if (iCount<1)
  665.                     {
  666.                         sys_err("ReadMonsterDropItemGroup : there is no count for item %s : node %s : vnum %d, count %d", name.c_str(), stName.c_str(), dwVnum, iCount);
  667.  
  668.                         return false;
  669.                     }
  670.  
  671.                     int iPartPct = 0;
  672.                     str_to_number(iPartPct, pTok->at(2).c_str());
  673.  
  674.                     if (iPartPct == 0)
  675.                     {
  676.                         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);
  677.  
  678.                         return false;
  679.                     }
  680.  
  681.                     int iRarePct = 0;
  682.                     str_to_number(iRarePct, pTok->at(3).c_str());
  683.                     iRarePct = MINMAX(0, iRarePct, 100);
  684.  
  685.                     sys_log(0,"        %s count %d rare %d", name.c_str(), iCount, iRarePct);
  686.                     pkGroup->AddItem(dwVnum, iCount, iPartPct, iRarePct);
  687.  
  688.                     continue;
  689.                 }
  690.  
  691.                 break;
  692.             }
  693.             if (isReloading)
  694.                 temMobItemGr.insert(std::map<DWORD, CMobItemGroup*>::value_type(iMobVnum, pkGroup));
  695.             else
  696.                 m_map_pkMobItemGroup.insert(std::map<DWORD, CMobItemGroup*>::value_type(iMobVnum, pkGroup));
  697.  
  698.         }
  699.         else if (strType == "drop")
  700.         {
  701.             CDropItemGroup* pkGroup;
  702.             bool bNew = true;
  703.             if (isReloading)
  704.             {
  705.                 itertype(tempDropItemGr) it = tempDropItemGr.find(iMobVnum);
  706.                 if (it == tempDropItemGr.end())
  707.                 {
  708.                     pkGroup = M2_NEW CDropItemGroup(0, iMobVnum, stName);
  709.                 }
  710.                 else
  711.                 {
  712.                     bNew = false;
  713.                     CDropItemGroup* pkGroup = it->second;
  714.                 }
  715.             }
  716.             else
  717.             {
  718.                 itertype(m_map_pkDropItemGroup) it = m_map_pkDropItemGroup.find(iMobVnum);
  719.                 if (it == m_map_pkDropItemGroup.end())
  720.                 {
  721.                     pkGroup = M2_NEW CDropItemGroup(0, iMobVnum, stName);
  722.                 }
  723.                 else
  724.                 {
  725.                     bNew = false;
  726.                     CDropItemGroup* pkGroup = it->second;
  727.                 }
  728.             }
  729.  
  730.             for (int k = 1; k < 256; ++k)
  731.             {
  732.                 char buf[4];
  733.                 snprintf(buf, sizeof(buf), "%d", k);
  734.  
  735.                 if (loader.GetTokenVector(buf, &pTok))
  736.                 {
  737.                     std::string& name = pTok->at(0);
  738.                     DWORD dwVnum = 0;
  739.  
  740.                     if (!GetVnumByOriginalName(name.c_str(), dwVnum))
  741.                     {
  742.                         str_to_number(dwVnum, name.c_str());
  743.                         if (!ITEM_MANAGER::instance().GetTable(dwVnum))
  744.                         {
  745.                             sys_err("ReadDropItemGroup : there is no item %s : node %s", name.c_str(), stName.c_str());
  746.                             M2_DELETE(pkGroup);
  747.  
  748.                             return false;
  749.                         }
  750.                     }
  751.  
  752.                     int iCount = 0;
  753.                     str_to_number(iCount, pTok->at(1).c_str());
  754.  
  755.                     if (iCount < 1)
  756.                     {
  757.                         sys_err("ReadMonsterDropItemGroup : there is no count for item %s : node %s", name.c_str(), stName.c_str());
  758.                         M2_DELETE(pkGroup);
  759.  
  760.                         return false;
  761.                     }
  762.  
  763.                     float fPercent = atof(pTok->at(2).c_str());
  764.  
  765.                     DWORD dwPct = (DWORD)(10000.0f * fPercent);
  766.  
  767.                     sys_log(0,"        name %s pct %d count %d", name.c_str(), dwPct, iCount);
  768.                     pkGroup->AddItem(dwVnum, dwPct, iCount);
  769.  
  770.                     continue;
  771.                 }
  772.  
  773.                 break;
  774.             }
  775.             if (bNew)
  776.             {
  777.                 if (isReloading)
  778.                     tempDropItemGr.insert(std::map<DWORD, CDropItemGroup*>::value_type(iMobVnum, pkGroup));
  779.                 else
  780.                     m_map_pkDropItemGroup.insert(std::map<DWORD, CDropItemGroup*>::value_type(iMobVnum, pkGroup));
  781.             }
  782.  
  783.         }
  784.         else if ( strType == "limit" )
  785.         {
  786.             CLevelItemGroup* pkLevelItemGroup = M2_NEW CLevelItemGroup(iLevelLimit);
  787.  
  788.             for ( int k=1; k < 256; k++ )
  789.             {
  790.                 char buf[4];
  791.                 snprintf(buf, sizeof(buf), "%d", k);
  792.  
  793.                 if ( loader.GetTokenVector(buf, &pTok) )
  794.                 {
  795.                     std::string& name = pTok->at(0);
  796.                     DWORD dwItemVnum = 0;
  797.  
  798.                     if (false == GetVnumByOriginalName(name.c_str(), dwItemVnum))
  799.                     {
  800.                         str_to_number(dwItemVnum, name.c_str());
  801.                         if ( !ITEM_MANAGER::instance().GetTable(dwItemVnum) )
  802.                         {
  803.                             M2_DELETE(pkLevelItemGroup);
  804.                             return false;
  805.                         }
  806.                     }
  807.  
  808.                     int iCount = 0;
  809.                     str_to_number(iCount, pTok->at(1).c_str());
  810.  
  811.                     if (iCount < 1)
  812.                     {
  813.                         M2_DELETE(pkLevelItemGroup);
  814.                         return false;
  815.                     }
  816.  
  817.                     float fPct = atof(pTok->at(2).c_str());
  818.                     DWORD dwPct = (DWORD)(10000.0f * fPct);
  819.  
  820.                     pkLevelItemGroup->AddItem(dwItemVnum, dwPct, iCount);
  821.  
  822.                     continue;
  823.                 }
  824.  
  825.                 break;
  826.             }
  827.  
  828.             if (isReloading)
  829.                 tempLevelItemGr.insert(std::map<DWORD, CLevelItemGroup*>::value_type(iMobVnum, pkLevelItemGroup));
  830.             else
  831.                 m_map_pkLevelItemGroup.insert(std::map<DWORD, CLevelItemGroup*>::value_type(iMobVnum, pkLevelItemGroup));
  832.         }
  833.         else if (strType == "thiefgloves")
  834.         {
  835.             CBuyerThiefGlovesItemGroup* pkGroup = M2_NEW CBuyerThiefGlovesItemGroup(0, iMobVnum, stName);
  836.  
  837.             for (int k = 1; k < 256; ++k)
  838.             {
  839.                 char buf[4];
  840.                 snprintf(buf, sizeof(buf), "%d", k);
  841.  
  842.                 if (loader.GetTokenVector(buf, &pTok))
  843.                 {
  844.                     std::string& name = pTok->at(0);
  845.                     DWORD dwVnum = 0;
  846.  
  847.                     if (!GetVnumByOriginalName(name.c_str(), dwVnum))
  848.                     {
  849.                         str_to_number(dwVnum, name.c_str());
  850.                         if (!ITEM_MANAGER::instance().GetTable(dwVnum))
  851.                         {
  852.                             sys_err("ReadDropItemGroup : there is no item %s : node %s", name.c_str(), stName.c_str());
  853.                             M2_DELETE(pkGroup);
  854.  
  855.                             return false;
  856.                         }
  857.                     }
  858.  
  859.                     int iCount = 0;
  860.                     str_to_number(iCount, pTok->at(1).c_str());
  861.  
  862.                     if (iCount < 1)
  863.                     {
  864.                         sys_err("ReadMonsterDropItemGroup : there is no count for item %s : node %s", name.c_str(), stName.c_str());
  865.                         M2_DELETE(pkGroup);
  866.  
  867.                         return false;
  868.                     }
  869.  
  870.                     float fPercent = atof(pTok->at(2).c_str());
  871.  
  872.                     DWORD dwPct = (DWORD)(10000.0f * fPercent);
  873.  
  874.                     sys_log(0,"        name %s pct %d count %d", name.c_str(), dwPct, iCount);
  875.                     pkGroup->AddItem(dwVnum, dwPct, iCount);
  876.  
  877.                     continue;
  878.                 }
  879.  
  880.                 break;
  881.             }
  882.             if (isReloading)
  883.                 tempThiefGlovesGr.insert(std::map<DWORD, CBuyerThiefGlovesItemGroup*>::value_type(iMobVnum, pkGroup));
  884.             else
  885.                 m_map_pkGloveItemGroup.insert(std::map<DWORD, CBuyerThiefGlovesItemGroup*>::value_type(iMobVnum, pkGroup));
  886.         }
  887.         else
  888.         {
  889.             sys_err("ReadMonsterDropItemGroup : Syntax error %s : invalid type %s (kill|drop), node %s", c_pszFileName, strType.c_str(), stName.c_str());
  890.             loader.SetParentNode();
  891.             return false;
  892.         }
  893.  
  894.         loader.SetParentNode();
  895.     }
  896.     if (isReloading)
  897.     {
  898.         for (std::map<DWORD, CBuyerThiefGlovesItemGroup*>::iterator it = m_map_pkGloveItemGroup.begin(); it != m_map_pkGloveItemGroup.end(); it++)
  899.             M2_DELETE(it->second);
  900.         m_map_pkGloveItemGroup.clear();
  901.         for (std::map<DWORD, CLevelItemGroup*>::iterator it = m_map_pkLevelItemGroup.begin(); it != m_map_pkLevelItemGroup.end(); it++)
  902.             M2_DELETE(it->second);
  903.         m_map_pkLevelItemGroup.clear();
  904.         for (std::map<DWORD, CDropItemGroup*>::iterator it = m_map_pkDropItemGroup.begin(); it != m_map_pkDropItemGroup.end(); it++)
  905.             M2_DELETE(it->second);
  906.         m_map_pkDropItemGroup.clear();
  907.         for (std::map<DWORD, CMobItemGroup*>::iterator it = m_map_pkMobItemGroup.begin(); it != m_map_pkMobItemGroup.end(); it++)
  908.             M2_DELETE(it->second);
  909.         m_map_pkMobItemGroup.clear();
  910.  
  911.         for (std::map<DWORD, CBuyerThiefGlovesItemGroup*>::iterator it = tempThiefGlovesGr.begin(); it != tempThiefGlovesGr.end(); it++)
  912.         {
  913.             m_map_pkGloveItemGroup[it->first] = it->second;
  914.         }
  915.  
  916.         for (std::map<DWORD, CLevelItemGroup*>::iterator it = tempLevelItemGr.begin(); it != tempLevelItemGr.end(); it++)
  917.         {
  918.             m_map_pkLevelItemGroup[it->first] = it->second;
  919.         }
  920.  
  921.         for (std::map<DWORD, CDropItemGroup*>::iterator it = tempDropItemGr.begin(); it != tempDropItemGr.end(); it++)
  922.         {
  923.             m_map_pkDropItemGroup[it->first] = it->second;
  924.         }
  925.  
  926.         for (std::map<DWORD, CMobItemGroup*>::iterator it = temMobItemGr.begin(); it != temMobItemGr.end(); it++)
  927.         {
  928.             m_map_pkMobItemGroup[it->first] = it->second;
  929.         }
  930.     }
  931.     return true;
  932. }
  933.  
  934. bool ITEM_MANAGER::ReadDropItemGroup(const char * c_pszFileName)
  935. {
  936.     CTextFileLoader loader;
  937.  
  938.     if (!loader.Load(c_pszFileName))
  939.         return false;
  940.  
  941.     std::string stName;
  942.  
  943.     for (DWORD i = 0; i < loader.GetChildNodeCount(); ++i)
  944.     {
  945.         loader.SetChildNode(i);
  946.  
  947.         loader.GetCurrentNodeName(&stName);
  948.  
  949.         int iVnum;
  950.         int iMobVnum;
  951.  
  952.         if (!loader.GetTokenInteger("vnum", &iVnum))
  953.         {
  954.             sys_err("ReadDropItemGroup : Syntax error %s : no vnum, node %s", c_pszFileName, stName.c_str());
  955.             loader.SetParentNode();
  956.             return false;
  957.         }
  958.  
  959.         if (!loader.GetTokenInteger("mob", &iMobVnum))
  960.         {
  961.             sys_err("ReadDropItemGroup : Syntax error %s : no mob vnum, node %s", c_pszFileName, stName.c_str());
  962.             loader.SetParentNode();
  963.             return false;
  964.         }
  965.  
  966.         sys_log(0,"DROP_ITEM_GROUP %s %d", stName.c_str(), iMobVnum);
  967.  
  968.         TTokenVector * pTok;
  969.  
  970.         itertype(m_map_pkDropItemGroup) it = m_map_pkDropItemGroup.find(iMobVnum);
  971.  
  972.         CDropItemGroup* pkGroup;
  973.  
  974.         if (it == m_map_pkDropItemGroup.end())
  975.             pkGroup = M2_NEW CDropItemGroup(iVnum, iMobVnum, stName);
  976.         else
  977.             pkGroup = it->second;
  978.  
  979.         for (int k = 1; k < 256; ++k)
  980.         {
  981.             char buf[4];
  982.             snprintf(buf, sizeof(buf), "%d", k);
  983.  
  984.             if (loader.GetTokenVector(buf, &pTok))
  985.             {
  986.                 std::string& name = pTok->at(0);
  987.                 DWORD dwVnum = 0;
  988.  
  989.                 if (!GetVnumByOriginalName(name.c_str(), dwVnum))
  990.                 {
  991.                     str_to_number(dwVnum, name.c_str());
  992.                     if (!ITEM_MANAGER::instance().GetTable(dwVnum))
  993.                     {
  994.                         sys_err("ReadDropItemGroup : there is no item %s : node %s", name.c_str(), stName.c_str());
  995.  
  996.                         if (it == m_map_pkDropItemGroup.end())
  997.                             M2_DELETE(pkGroup);
  998.  
  999.                         return false;
  1000.                     }
  1001.                 }
  1002.  
  1003.                 float fPercent = atof(pTok->at(1).c_str());
  1004.  
  1005.                 DWORD dwPct = (DWORD)(10000.0f * fPercent);
  1006.  
  1007.                 int iCount = 1;
  1008.                 if (pTok->size() > 2)
  1009.                     str_to_number(iCount, pTok->at(2).c_str());
  1010.  
  1011.                 if (iCount < 1)
  1012.                 {
  1013.                     sys_err("ReadDropItemGroup : there is no count for item %s : node %s", name.c_str(), stName.c_str());
  1014.  
  1015.                     if (it == m_map_pkDropItemGroup.end())
  1016.                         M2_DELETE(pkGroup);
  1017.  
  1018.                     return false;
  1019.                 }
  1020.  
  1021.                 sys_log(0,"        %s %d %d", name.c_str(), dwPct, iCount);
  1022.                 pkGroup->AddItem(dwVnum, dwPct, iCount);
  1023.                 continue;
  1024.             }
  1025.  
  1026.             break;
  1027.         }
  1028.  
  1029.         if (it == m_map_pkDropItemGroup.end())
  1030.             m_map_pkDropItemGroup.insert(std::map<DWORD, CDropItemGroup*>::value_type(iMobVnum, pkGroup));
  1031.  
  1032.         loader.SetParentNode();
  1033.     }
  1034.  
  1035.     return true;
  1036. }
  1037.  
  1038. bool ITEM_MANAGER::ReadItemVnumMaskTable(const char * c_pszFileName)
  1039. {
  1040.     FILE *fp = fopen(c_pszFileName, "r");
  1041.     if (!fp)
  1042.     {
  1043.         return false;
  1044.     }
  1045.  
  1046.     int ori_vnum, new_vnum;
  1047.     while (fscanf(fp, "%u %u", &ori_vnum, &new_vnum) != EOF)
  1048.     {
  1049.         m_map_new_to_ori.insert (TMapDW2DW::value_type (new_vnum, ori_vnum));
  1050.     }
  1051.     fclose(fp);
  1052.     return true;
  1053. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!