开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Java编程 > Applet > 游戏 > 查看源码
MapleItemInformationProvider.java
资源名称：src.rar　[点击查看]
上传用户：gwt600
上传日期：2021-06-03
资源大小：704k
文件大小：41k
源码类别：

游戏

开发平台：

Java

MapleItemInformationProvider.java：源码内容
  1. /*
  2. This file is part of the OdinMS Maple Story Server
  3. Copyright (C) 2008 Patrick Huy <patrick.huy@frz.cc> 
  4. Matthias Butz <matze@odinms.de>
  5. Jan Christian Meyer <vimes@odinms.de>
  7. This program is free software: you can redistribute it and/or modify
  8. it under the terms of the GNU Affero General Public License version 3
  9. as published by the Free Software Foundation. You may not use, modify
  10. or distribute this program under any other version of the
  11. GNU Affero General Public License.
  13. This program is distributed in the hope that it will be useful,
  14. but WITHOUT ANY WARRANTY; without even the implied warranty of
  15. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16. GNU Affero General Public License for more details.
  18. You should have received a copy of the GNU Affero General Public License
  19. along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20.  */
  22. /*
  23.  * MapleItemInformationProvider.java
  24.  * 
  25.  * Created on 26. November 2007, 21:58
  26.  */
  27. package net.sf.odinms.server;
  29. import java.io.File;
  30. import java.util.ArrayList;
  31. import java.util.HashMap;
  32. import java.util.LinkedHashMap;
  33. import java.util.List;
  34. import java.util.Map;
  35. import java.util.Random;
  36. import java.util.Map.Entry;
  38. import net.sf.odinms.client.Equip;
  39. import net.sf.odinms.client.IItem;
  40. import net.sf.odinms.client.MapleClient;
  41. import net.sf.odinms.client.MapleInventoryType;
  42. import net.sf.odinms.client.MapleWeaponType;
  43. import net.sf.odinms.client.SkillFactory;
  44. import net.sf.odinms.net.channel.ChannelServer;
  45. import net.sf.odinms.provider.MapleData;
  46. import net.sf.odinms.provider.MapleDataDirectoryEntry;
  47. import net.sf.odinms.provider.MapleDataFileEntry;
  48. import net.sf.odinms.provider.MapleDataProvider;
  49. import net.sf.odinms.provider.MapleDataProviderFactory;
  50. import net.sf.odinms.provider.MapleDataTool;
  51. import net.sf.odinms.tools.Pair;
  53. /**
  54.  * 
  55.  * @author Matze
  56.  * 
  57.  * TODO: make faster
  58.  * 
  59.  */
  60. public class MapleItemInformationProvider {
  62.     private static MapleItemInformationProvider instance = null;
  63.     protected MapleDataProvider itemData;
  64.     protected MapleDataProvider equipData;
  65.     protected MapleDataProvider stringData;
  66.     protected MapleData cashStringData;
  67.     protected MapleData consumeStringData;
  68.     protected MapleData eqpStringData;
  69.     protected MapleData etcStringData;
  70.     protected MapleData insStringData;
  71.     protected MapleData petStringData;
  72.     protected Map<Integer, MapleInventoryType> inventoryTypeCache = new HashMap<Integer, MapleInventoryType>();
  73.     protected Map<Integer, Short> slotMaxCache = new HashMap<Integer, Short>();
  74.     protected Map<Integer, MapleStatEffect> itemEffects = new HashMap<Integer, MapleStatEffect>();
  75.     protected Map<Integer, Map<String, Integer>> equipStatsCache = new HashMap<Integer, Map<String, Integer>>();
  76.     protected Map<Integer, Equip> equipCache = new HashMap<Integer, Equip>();
  77.     protected Map<Integer, Double> priceCache = new HashMap<Integer, Double>();
  78.     protected Map<Integer, Integer> wholePriceCache = new HashMap<Integer, Integer>();
  79.     protected Map<Integer, Integer> projectileWatkCache = new HashMap<Integer, Integer>();
  80.     protected Map<Integer, String> nameCache = new HashMap<Integer, String>();
  81.     protected Map<Integer, String> descCache = new HashMap<Integer, String>();
  82.     protected Map<Integer, String> msgCache = new HashMap<Integer, String>();
  83.     protected Map<Integer, Boolean> dropRestrictionCache = new HashMap<Integer, Boolean>();
  84.     protected Map<Integer, Boolean> pickupRestrictionCache = new HashMap<Integer, Boolean>();
  85.     protected List<Pair<Integer, String>> itemNameCache = new ArrayList<Pair<Integer, String>>();
  86.     protected Map<Integer, Integer> getMesoCache = new HashMap<Integer, Integer>();
  87.     protected Map<Integer, Integer> getExpCache = new HashMap<Integer, Integer>();
  88.     private static Random rand = new Random();
  90.     /** Creates a new instance of MapleItemInformationProvider */
  91.     protected MapleItemInformationProvider() {
  92.         itemData = MapleDataProviderFactory.getDataProvider(new File(System.getProperty("net.sf.odinms.wzpath") + "/Item.wz"));
  93.         equipData = MapleDataProviderFactory.getDataProvider(new File(System.getProperty("net.sf.odinms.wzpath") + "/Character.wz"));
  94.         stringData = MapleDataProviderFactory.getDataProvider(new File(System.getProperty("net.sf.odinms.wzpath") + "/String.wz"));
  95.         cashStringData = MapleDataProviderFactory.getDataProvider(new File(System.getProperty("net.sf.odinms.wzpath") + "/String.wz")).getData("Cash.img");
  96.         consumeStringData = MapleDataProviderFactory.getDataProvider(new File(System.getProperty("net.sf.odinms.wzpath") + "/String.wz")).getData("Consume.img");
  97.         eqpStringData = MapleDataProviderFactory.getDataProvider(new File(System.getProperty("net.sf.odinms.wzpath") + "/String.wz")).getData("Eqp.img");
  98.         etcStringData = MapleDataProviderFactory.getDataProvider(new File(System.getProperty("net.sf.odinms.wzpath") + "/String.wz")).getData("Etc.img");
  99.         insStringData = MapleDataProviderFactory.getDataProvider(new File(System.getProperty("net.sf.odinms.wzpath") + "/String.wz")).getData("Ins.img");
  100.         petStringData = MapleDataProviderFactory.getDataProvider(new File(System.getProperty("net.sf.odinms.wzpath") + "/String.wz")).getData("Pet.img");
  101.     }
  103.     public static MapleItemInformationProvider getInstance() {
  104.         if (instance == null) {
  105.             instance = new MapleItemInformationProvider();
  106.         }
  107.         return instance;
  108.     }
  110.     /* returns the inventory type for the specified item id */
  111.     public MapleInventoryType getInventoryType(int itemId) {
  112.         if (inventoryTypeCache.containsKey(itemId)) {
  113.             return inventoryTypeCache.get(itemId);
  114.         }
  115.         MapleInventoryType ret;
  116.         String idStr = "0" + String.valueOf(itemId);
  117.         // first look in items...
  118.         MapleDataDirectoryEntry root = itemData.getRoot();
  119.         for (MapleDataDirectoryEntry topDir : root.getSubdirectories()) {
  120.             // we should have .img files here beginning with the first 4 IID
  121.             for (MapleDataFileEntry iFile : topDir.getFiles()) {
  122.                 if (iFile.getName().equals(idStr.substring(0, 4) + ".img")) {
  123.                     ret = MapleInventoryType.getByWZName(topDir.getName());
  124.                     inventoryTypeCache.put(itemId, ret);
  125.                     return ret;
  126.                 } else if (iFile.getName().equals(idStr.substring(1) + ".img")) {
  127.                     ret = MapleInventoryType.getByWZName(topDir.getName());
  128.                     inventoryTypeCache.put(itemId, ret);
  129.                     return ret;
  130.                 }
  131.             }
  132.         }
  133.         // not found? maybe its equip...
  134.         root = equipData.getRoot();
  135.         for (MapleDataDirectoryEntry topDir : root.getSubdirectories()) {
  136.             for (MapleDataFileEntry iFile : topDir.getFiles()) {
  137.                 if (iFile.getName().equals(idStr + ".img")) {
  138.                     ret = MapleInventoryType.EQUIP;
  139.                     inventoryTypeCache.put(itemId, ret);
  140.                     return ret;
  141.                 }
  142.             }
  143.         }
  144.         ret = MapleInventoryType.UNDEFINED;
  145.         inventoryTypeCache.put(itemId, ret);
  146.         return ret;
  147.     }
  149.     public List<Pair<Integer, String>> getAllItems() {
  150.         if (itemNameCache.size() != 0) {
  151.             return itemNameCache;
  152.         }
  153.         List<Pair<Integer, String>> itemPairs = new ArrayList<Pair<Integer, String>>();
  154.         MapleData itemsData;
  156.         itemsData = stringData.getData("Cash.img");
  157.         for (MapleData itemFolder : itemsData.getChildren()) {
  158.             int itemId = Integer.parseInt(itemFolder.getName());
  159.             String itemName = MapleDataTool.getString("name", itemFolder, "NO-NAME");
  160.             itemPairs.add(new Pair<Integer, String>(itemId, itemName));
  161.         }
  163.         itemsData = stringData.getData("Consume.img");
  164.         for (MapleData itemFolder : itemsData.getChildren()) {
  165.             int itemId = Integer.parseInt(itemFolder.getName());
  166.             String itemName = MapleDataTool.getString("name", itemFolder, "NO-NAME");
  167.             itemPairs.add(new Pair<Integer, String>(itemId, itemName));
  168.         }
  170.         itemsData = stringData.getData("Eqp.img").getChildByPath("Eqp");
  171.         for (MapleData eqpType : itemsData.getChildren()) {
  172.             for (MapleData itemFolder : eqpType.getChildren()) {
  173.                 int itemId = Integer.parseInt(itemFolder.getName());
  174.                 String itemName = MapleDataTool.getString("name", itemFolder, "NO-NAME");
  175.                 itemPairs.add(new Pair<Integer, String>(itemId, itemName));
  176.             }
  177.         }
  179.         itemsData = stringData.getData("Etc.img").getChildByPath("Etc");
  180.         for (MapleData itemFolder : itemsData.getChildren()) {
  181.             int itemId = Integer.parseInt(itemFolder.getName());
  182.             String itemName = MapleDataTool.getString("name", itemFolder, "NO-NAME");
  183.             itemPairs.add(new Pair<Integer, String>(itemId, itemName));
  184.         }
  186.         itemsData = stringData.getData("Ins.img");
  187.         for (MapleData itemFolder : itemsData.getChildren()) {
  188.             int itemId = Integer.parseInt(itemFolder.getName());
  189.             String itemName = MapleDataTool.getString("name", itemFolder, "NO-NAME");
  190.             itemPairs.add(new Pair<Integer, String>(itemId, itemName));
  191.         }
  193.         itemsData = stringData.getData("Pet.img");
  194.         for (MapleData itemFolder : itemsData.getChildren()) {
  195.             int itemId = Integer.parseInt(itemFolder.getName());
  196.             String itemName = MapleDataTool.getString("name", itemFolder, "NO-NAME");
  197.             itemPairs.add(new Pair<Integer, String>(itemId, itemName));
  198.         }
  199.         return itemPairs;
  200.     }
  202.     protected MapleData getStringData(int itemId) {
  203.         String cat = "null";
  204.         MapleData theData;
  205.         if (itemId >= 5010000) {
  206.             theData = cashStringData;
  207.         } else if (itemId >= 2000000 && itemId < 3000000) {
  208.             theData = consumeStringData;
  209.         } else if (itemId >= 1010000 && itemId < 1040000 || itemId >= 1122000 && itemId < 1123000) {
  210.             theData = eqpStringData;
  211.             cat = "Accessory";
  212.         } else if (itemId >= 1000000 && itemId < 1010000) {
  213.             theData = eqpStringData;
  214.             cat = "Cap";
  215.         } else if (itemId >= 1102000 && itemId < 1103000) {
  216.             theData = eqpStringData;
  217.             cat = "Cape";
  218.         } else if (itemId >= 1040000 && itemId < 1050000) {
  219.             theData = eqpStringData;
  220.             cat = "Coat";
  221.         } else if (itemId >= 20000 && itemId < 22000) {
  222.             theData = eqpStringData;
  223.             cat = "Face";
  224.         } else if (itemId >= 1080000 && itemId < 1090000) {
  225.             theData = eqpStringData;
  226.             cat = "Glove";
  227.         } else if (itemId >= 30000 && itemId < 32000) {
  228.             theData = eqpStringData;
  229.             cat = "Hair";
  230.         } else if (itemId >= 1050000 && itemId < 1060000) {
  231.             theData = eqpStringData;
  232.             cat = "Longcoat";
  233.         } else if (itemId >= 1060000 && itemId < 1070000) {
  234.             theData = eqpStringData;
  235.             cat = "Pants";
  236.         } else if (itemId >= 1802000 && itemId < 1810000) {
  237.             theData = eqpStringData;
  238.             cat = "PetEquip";
  239.         } else if (itemId >= 1112000 && itemId < 1120000) {
  240.             theData = eqpStringData;
  241.             cat = "Ring";
  242.         } else if (itemId >= 1092000 && itemId < 1100000) {
  243.             theData = eqpStringData;
  244.             cat = "Shield";
  245.         } else if (itemId >= 1070000 && itemId < 1080000) {
  246.             theData = eqpStringData;
  247.             cat = "Shoes";
  248.         } else if (itemId >= 1900000 && itemId < 2000000) {
  249.             theData = eqpStringData;
  250.             cat = "Taming";
  251.         } else if (itemId >= 1300000 && itemId < 1800000) {
  252.             theData = eqpStringData;
  253.             cat = "Weapon";
  254.         } else if (itemId >= 4000000 && itemId < 5000000) {
  255.             theData = etcStringData;
  256.         } else if (itemId >= 3000000 && itemId < 4000000) {
  257.             theData = insStringData;
  258.         } else if (itemId >= 5000000 && itemId < 5010000) {
  259.             theData = petStringData;
  260.         } else {
  261.             return null;
  262.         }
  263.         if (cat.equalsIgnoreCase("null")) {
  264.             return theData.getChildByPath(String.valueOf(itemId));
  265.         } else {
  266.             return theData.getChildByPath(cat + "/" + itemId);
  267.         }
  268.     }
  270.     protected MapleData getItemData(int itemId) {
  271.         MapleData ret = null;
  272.         String idStr = "0" + String.valueOf(itemId);
  273.         MapleDataDirectoryEntry root = itemData.getRoot();
  274.         for (MapleDataDirectoryEntry topDir : root.getSubdirectories()) {
  275.             // we should have .img files here beginning with the first 4 IID
  276.             for (MapleDataFileEntry iFile : topDir.getFiles()) {
  277.                 if (iFile.getName().equals(idStr.substring(0, 4) + ".img")) {
  278.                     ret = itemData.getData(topDir.getName() + "/" + iFile.getName());
  279.                     if (ret == null) {
  280.                         return null;
  281.                     }
  282.                     ret = ret.getChildByPath(idStr);
  283.                     return ret;
  284.                 } else if (iFile.getName().equals(idStr.substring(1) + ".img")) {
  285.                     return itemData.getData(topDir.getName() + "/" + iFile.getName());
  286.                 }
  287.             }
  288.         }
  289.         root = equipData.getRoot();
  290.         for (MapleDataDirectoryEntry topDir : root.getSubdirectories()) {
  291.             for (MapleDataFileEntry iFile : topDir.getFiles()) {
  292.                 if (iFile.getName().equals(idStr + ".img")) {
  293.                     return equipData.getData(topDir.getName() + "/" + iFile.getName());
  294.                 }
  295.             }
  296.         }
  297.         return ret;
  298.     }
  300.     /** returns the maximum of items in one slot */
  301.     public short getSlotMax(MapleClient c, int itemId) {
  302.         if (slotMaxCache.containsKey(itemId)) {
  303.             return slotMaxCache.get(itemId);
  304.         }
  305.         short ret = 0;
  306.         MapleData item = getItemData(itemId);
  307.         if (item != null) {
  308.             MapleData smEntry = item.getChildByPath("info/slotMax");
  309.             if (smEntry == null) {
  310.                 if (getInventoryType(itemId).getType() == MapleInventoryType.EQUIP.getType()) {
  311.                     ret = 1;
  312.                 } else {
  313.                     ret = 100;
  314.                 }
  315.             } else {
  316.                 if (isThrowingStar(itemId) || isBullet(itemId) || (MapleDataTool.getInt(smEntry) == 0)) {
  317.                     ret = 1;
  318.                 }
  319.                 ret = (short) MapleDataTool.getInt(smEntry);
  320.                 if (isThrowingStar(itemId)) {
  321.                     ret += c.getPlayer().getSkillLevel(SkillFactory.getSkill(4100000)) * 10;
  322.                 } else {
  323.                     ret += c.getPlayer().getSkillLevel(SkillFactory.getSkill(5200000)) * 10;
  324.                 }
  326.             }
  327.         }
  328.         if (!isThrowingStar(itemId) && !isBullet(itemId)) {
  329.             slotMaxCache.put(itemId, ret);
  330.         }
  332.         return ret;
  333.     }
  335.     public int getMeso(int itemId) {
  336.         if (getMesoCache.containsKey(itemId)) {
  337.             return getMesoCache.get(itemId);
  338.         }
  339.         MapleData item = getItemData(itemId);
  340.         if (item == null) {
  341.             return -1;
  342.         }
  343.         int pEntry = 0;
  344.         MapleData pData = item.getChildByPath("info/meso");
  345.         if (pData == null) {
  346.             return -1;
  347.         }
  348.         pEntry = MapleDataTool.getInt(pData);
  350.         getMesoCache.put(itemId, pEntry);
  351.         return pEntry;
  352.     }
  354.     public int getExpCache(int itemId) {
  355.         if (this.getExpCache.containsKey(itemId)) {
  356.             return getExpCache.get(itemId);
  357.         }
  358.         MapleData item = getItemData(itemId);
  359.         if (item == null) {
  360.             return 0;
  361.         }
  362.         int pEntry = 0;
  363.         MapleData pData = item.getChildByPath("spec/exp");
  364.         if (pData == null) {
  365.             return 0;
  366.         }
  367.         pEntry = MapleDataTool.getInt(pData);
  369.         getExpCache.put(itemId, pEntry);
  370.         return pEntry;
  371.     }
  373.     public int getWholePrice(int itemId) {
  374.         if (wholePriceCache.containsKey(itemId)) {
  375.             return wholePriceCache.get(itemId);
  376.         }
  377.         MapleData item = getItemData(itemId);
  378.         if (item == null) {
  379.             return -1;
  380.         }
  382.         int pEntry = 0;
  383.         MapleData pData = item.getChildByPath("info/price");
  384.         if (pData == null) {
  385.             return -1;
  386.         }
  387.         pEntry = MapleDataTool.getInt(pData);
  389.         wholePriceCache.put(itemId, pEntry);
  390.         return pEntry;
  391.     }
  393.     public double getPrice(int itemId) {
  394.         if (priceCache.containsKey(itemId)) {
  395.             return priceCache.get(itemId);
  396.         }
  397.         MapleData item = getItemData(itemId);
  398.         if (item == null) {
  399.             return -1;
  400.         }
  402.         double pEntry = 0.0;
  403.         MapleData pData = item.getChildByPath("info/unitPrice");
  404.         if (pData != null) {
  405.             try {
  406.                 pEntry = MapleDataTool.getDouble(pData);
  407.             } catch (Exception e) {
  408.                 pEntry = (double) MapleDataTool.getInt(pData);
  409.             }
  410.         } else {
  411.             pData = item.getChildByPath("info/price");
  412.             if (pData == null) {
  413.                 return -1;
  414.             }
  415.             pEntry = (double) MapleDataTool.getInt(pData);
  416.         }
  418.         priceCache.put(itemId, pEntry);
  419.         return pEntry;
  420.     }
  422.     protected Map<String, Integer> getEquipStats(int itemId) {
  423.         if (equipStatsCache.containsKey(itemId)) {
  424.             return equipStatsCache.get(itemId);
  425.         }
  426.         Map<String, Integer> ret = new LinkedHashMap<String, Integer>();
  427.         MapleData item = getItemData(itemId);
  428.         if (item == null) {
  429.             return null;
  430.         }
  431.         MapleData info = item.getChildByPath("info");
  432.         if (info == null) {
  433.             return null;
  434.         }
  435.         for (MapleData data : info.getChildren()) {
  436.             if (data.getName().startsWith("inc")) {
  437.                 ret.put(data.getName().substring(3), MapleDataTool.getIntConvert(data));
  438.             }
  439.         }
  440.         ret.put("tuc", MapleDataTool.getInt("tuc", info, 0));
  441.         ret.put("reqLevel", MapleDataTool.getInt("reqLevel", info, 0));
  442.         ret.put("cursed", MapleDataTool.getInt("cursed", info, 0));
  443.         ret.put("success", MapleDataTool.getInt("success", info, 0));
  444.         equipStatsCache.put(itemId, ret);
  445.         return ret;
  446.     }
  448.     public int getReqLevel(int itemId) {
  449.         final Integer req = getEquipStats(itemId).get("reqLevel");
  450.         return req == null ? 0 : req.intValue();
  451.     }
  453.     public List<Integer> getScrollReqs(int itemId) {
  454.         List<Integer> ret = new ArrayList<Integer>();
  455.         MapleData data = getItemData(itemId);
  456.         data = data.getChildByPath("req");
  457.         if (data == null) {
  458.             return ret;
  459.         }
  460.         for (MapleData req : data.getChildren()) {
  461.             ret.add(MapleDataTool.getInt(req));
  462.         }
  463.         return ret;
  464.     }
  466.     public boolean isWeapon(int itemId) {
  467.         return itemId >= 1302000 && itemId < 1492024;
  468.     }
  470.     public MapleWeaponType getWeaponType(int itemId) {
  471.         int cat = itemId / 10000;
  472.         cat = cat % 100;
  473.         switch (cat) {
  474.             case 30:
  475.                 return MapleWeaponType.SWORD1H;
  476.             case 31:
  477.                 return MapleWeaponType.AXE1H;
  478.             case 32:
  479.                 return MapleWeaponType.BLUNT1H;
  480.             case 33:
  481.                 return MapleWeaponType.DAGGER;
  482.             case 37:
  483.                 return MapleWeaponType.WAND;
  484.             case 38:
  485.                 return MapleWeaponType.STAFF;
  486.             case 40:
  487.                 return MapleWeaponType.SWORD2H;
  488.             case 41:
  489.                 return MapleWeaponType.AXE2H;
  490.             case 42:
  491.                 return MapleWeaponType.BLUNT2H;
  492.             case 43:
  493.                 return MapleWeaponType.SPEAR;
  494.             case 44:
  495.                 return MapleWeaponType.POLE_ARM;
  496.             case 45:
  497.                 return MapleWeaponType.BOW;
  498.             case 46:
  499.                 return MapleWeaponType.CROSSBOW;
  500.             case 47:
  501.                 return MapleWeaponType.CLAW;
  502.             case 48:
  503.                 return MapleWeaponType.KNUCKLE;
  504.             case 49:
  505.                 return MapleWeaponType.GUN;
  507.         }
  508.         return MapleWeaponType.NOT_A_WEAPON;
  509.     }
  511.     public boolean isShield(int itemId) {
  512.         int cat = itemId / 10000;
  513.         cat = cat % 100;
  514.         return cat == 9;
  515.     }
  517.     public boolean isEquip(int itemId) {
  518.         return itemId / 1000000 == 1;
  519.     }
  521.     public boolean isCleanSlate(int scrollId) {
  522.         switch (scrollId) {
  523.             case 2049000:
  524.             case 2049001:
  525.             case 2049002:
  526.             case 2049003:
  527.                 return true;
  528.         }
  529.         return false;
  531.     }
  533.     public IItem scrollEquipWithId(MapleClient c, IItem equip, int scrollId, boolean usingWhiteScroll) {
  534.         boolean noFail = false;
  535.         if (c.getPlayer().haveItem(2022118, 1, false, true)) {
  536.             noFail = true;
  537.         }
  539.         boolean isGM = false;
  540.         if (c.getPlayer().isGM()) {
  541.             isGM = true;
  542.         }
  544.         if (equip instanceof Equip) {
  545.             Equip nEquip = (Equip) equip;
  546.             Map<String, Integer> stats = this.getEquipStats(scrollId);
  547.             Map<String, Integer> eqstats = this.getEquipStats(equip.getItemId());
  548.             if ((nEquip.getUpgradeSlots() > 0 || isCleanSlate(scrollId)) && Math.ceil(Math.random() * 100.0) <= stats.get("success") || isGM || noFail) {
  549.                 switch (scrollId) {
  550.                     case 2049000:
  551.                     case 2049001:
  552.                     case 2049002:
  553.                     case 2049003:
  554.                         if (nEquip.getLevel() + nEquip.getUpgradeSlots() < eqstats.get("tuc")) {
  555.                             byte newSlots = (byte) (nEquip.getUpgradeSlots() + 1);
  556.                             nEquip.setUpgradeSlots(newSlots);
  557.                         }
  558.                         break;
  559.                     case 2049100:
  560.                     case 2049101:
  561.                     case 2049102:
  562.                         int increase = 1;
  563.                         if (Math.ceil(Math.random() * 100.0) <= 50) {
  564.                             increase = increase * -1;
  565.                         }
  566.                         if (nEquip.getStr() > 0) {
  567.                             short newStat = (short) (nEquip.getStr() + Math.ceil(Math.random() * 5.0) * increase);
  568.                             nEquip.setStr(newStat);
  569.                         }
  570.                         if (nEquip.getDex() > 0) {
  571.                             short newStat = (short) (nEquip.getDex() + Math.ceil(Math.random() * 5.0) * increase);
  572.                             nEquip.setDex(newStat);
  573.                         }
  574.                         if (nEquip.getInt() > 0) {
  575.                             short newStat = (short) (nEquip.getInt() + Math.ceil(Math.random() * 5.0) * increase);
  576.                             nEquip.setInt(newStat);
  577.                         }
  578.                         if (nEquip.getLuk() > 0) {
  579.                             short newStat = (short) (nEquip.getLuk() + Math.ceil(Math.random() * 5.0) * increase);
  580.                             nEquip.setLuk(newStat);
  581.                         }
  582.                         if (nEquip.getWatk() > 0) {
  583.                             short newStat = (short) (nEquip.getWatk() + Math.ceil(Math.random() * 5.0) * increase);
  584.                             nEquip.setWatk(newStat);
  585.                         }
  586.                         if (nEquip.getWdef() > 0) {
  587.                             short newStat = (short) (nEquip.getWdef() + Math.ceil(Math.random() * 5.0) * increase);
  588.                             nEquip.setWdef(newStat);
  589.                         }
  590.                         if (nEquip.getMatk() > 0) {
  591.                             short newStat = (short) (nEquip.getMatk() + Math.ceil(Math.random() * 5.0) * increase);
  592.                             nEquip.setMatk(newStat);
  593.                         }
  594.                         if (nEquip.getMdef() > 0) {
  595.                             short newStat = (short) (nEquip.getMdef() + Math.ceil(Math.random() * 5.0) * increase);
  596.                             nEquip.setMdef(newStat);
  597.                         }
  598.                         if (nEquip.getAcc() > 0) {
  599.                             short newStat = (short) (nEquip.getAcc() + Math.ceil(Math.random() * 5.0) * increase);
  600.                             nEquip.setAcc(newStat);
  601.                         }
  602.                         if (nEquip.getAvoid() > 0) {
  603.                             short newStat = (short) (nEquip.getAvoid() + Math.ceil(Math.random() * 5.0) * increase);
  604.                             nEquip.setAvoid(newStat);
  605.                         }
  606.                         if (nEquip.getSpeed() > 0) {
  607.                             short newStat = (short) (nEquip.getSpeed() + Math.ceil(Math.random() * 5.0) * increase);
  608.                             nEquip.setSpeed(newStat);
  609.                         }
  610.                         if (nEquip.getJump() > 0) {
  611.                             short newStat = (short) (nEquip.getJump() + Math.ceil(Math.random() * 5.0) * increase);
  612.                             nEquip.setJump(newStat);
  613.                         }
  614.                         if (nEquip.getHp() > 0) {
  615.                             short newStat = (short) (nEquip.getHp() + Math.ceil(Math.random() * 5.0) * increase);
  616.                             nEquip.setHp(newStat);
  617.                         }
  618.                         if (nEquip.getMp() > 0) {
  619.                             short newStat = (short) (nEquip.getMp() + Math.ceil(Math.random() * 5.0) * increase);
  620.                             nEquip.setMp(newStat);
  621.                         }
  622.                         break;
  623.                     default:
  624.                         for (Entry<String, Integer> stat : stats.entrySet()) {
  625.                             if (stat.getKey().equals("STR")) {
  626.                                 nEquip.setStr((short) (nEquip.getStr() + stat.getValue().intValue()));
  627.                             } else if (stat.getKey().equals("DEX")) {
  628.                                 nEquip.setDex((short) (nEquip.getDex() + stat.getValue().intValue()));
  629.                             } else if (stat.getKey().equals("INT")) {
  630.                                 nEquip.setInt((short) (nEquip.getInt() + stat.getValue().intValue()));
  631.                             } else if (stat.getKey().equals("LUK")) {
  632.                                 nEquip.setLuk((short) (nEquip.getLuk() + stat.getValue().intValue()));
  633.                             } else if (stat.getKey().equals("PAD")) {
  634.                                 nEquip.setWatk((short) (nEquip.getWatk() + stat.getValue().intValue()));
  635.                             } else if (stat.getKey().equals("PDD")) {
  636.                                 nEquip.setWdef((short) (nEquip.getWdef() + stat.getValue().intValue()));
  637.                             } else if (stat.getKey().equals("MAD")) {
  638.                                 nEquip.setMatk((short) (nEquip.getMatk() + stat.getValue().intValue()));
  639.                             } else if (stat.getKey().equals("MDD")) {
  640.                                 nEquip.setMdef((short) (nEquip.getMdef() + stat.getValue().intValue()));
  641.                             } else if (stat.getKey().equals("ACC")) {
  642.                                 nEquip.setAcc((short) (nEquip.getAcc() + stat.getValue().intValue()));
  643.                             } else if (stat.getKey().equals("EVA")) {
  644.                                 nEquip.setAvoid((short) (nEquip.getAvoid() + stat.getValue().intValue()));
  645.                             } else if (stat.getKey().equals("Speed")) {
  646.                                 nEquip.setSpeed((short) (nEquip.getSpeed() + stat.getValue().intValue()));
  647.                             } else if (stat.getKey().equals("Jump")) {
  648.                                 nEquip.setJump((short) (nEquip.getJump() + stat.getValue().intValue()));
  649.                             } else if (stat.getKey().equals("MHP")) {
  650.                                 nEquip.setHp((short) (nEquip.getHp() + stat.getValue().intValue()));
  651.                             } else if (stat.getKey().equals("MMP")) {
  652.                                 nEquip.setMp((short) (nEquip.getMp() + stat.getValue().intValue()));
  653.                             } else if (stat.getKey().equals("afterImage")) {
  654.                             }
  655.                         }
  656.                         break;
  657.                 }
  659.                 if (noFail && !isGM) {
  660.                     MapleInventoryManipulator.removeById(c, MapleInventoryType.USE, 2022118, 1, true, false);
  661.                 }
  663.                 if (!isCleanSlate(scrollId)) {
  664.                     if (!isGM) {
  665.                         nEquip.setUpgradeSlots((byte) (nEquip.getUpgradeSlots() - 1));
  666.                     }
  667.                     nEquip.setLevel((byte) (nEquip.getLevel() + 1));
  668.                 }
  669.             } else {
  670.                 if (!usingWhiteScroll && !isCleanSlate(scrollId)) {
  671.                     nEquip.setUpgradeSlots((byte) (nEquip.getUpgradeSlots() - 1));
  672.                 }
  673.                 if (Math.ceil(1.0 + Math.random() * 100.0) < stats.get("cursed")) {
  674.                     // DESTROY :) (O.O!)
  675.                     return null;
  676.                 }
  677.             }
  678.         }
  679.         return equip;
  680.     }
  682.     public IItem getEquipById(int equipId) {
  683.         return getEquipById(equipId, -1);
  684.     }
  686.     public IItem getEquipById(int equipId, int ringId) {
  687.         Equip nEquip;
  688.         nEquip = new Equip(equipId, (byte) 0, ringId);
  689.         nEquip.setQuantity((short) 1);
  690.         Map<String, Integer> stats = this.getEquipStats(equipId);
  691.         if (stats != null) {
  692.             for (Entry<String, Integer> stat : stats.entrySet()) {
  693.                 if (stat.getKey().equals("STR")) {
  694.                     nEquip.setStr((short) stat.getValue().intValue());
  695.                 } else if (stat.getKey().equals("DEX")) {
  696.                     nEquip.setDex((short) stat.getValue().intValue());
  697.                 } else if (stat.getKey().equals("INT")) {
  698.                     nEquip.setInt((short) stat.getValue().intValue());
  699.                 } else if (stat.getKey().equals("LUK")) {
  700.                     nEquip.setLuk((short) stat.getValue().intValue());
  701.                 } else if (stat.getKey().equals("PAD")) {
  702.                     nEquip.setWatk((short) stat.getValue().intValue());
  703.                 } else if (stat.getKey().equals("PDD")) {
  704.                     nEquip.setWdef((short) stat.getValue().intValue());
  705.                 } else if (stat.getKey().equals("MAD")) {
  706.                     nEquip.setMatk((short) stat.getValue().intValue());
  707.                 } else if (stat.getKey().equals("MDD")) {
  708.                     nEquip.setMdef((short) stat.getValue().intValue());
  709.                 } else if (stat.getKey().equals("ACC")) {
  710.                     nEquip.setAcc((short) stat.getValue().intValue());
  711.                 } else if (stat.getKey().equals("EVA")) {
  712.                     nEquip.setAvoid((short) stat.getValue().intValue());
  713.                 } else if (stat.getKey().equals("Speed")) {
  714.                     nEquip.setSpeed((short) stat.getValue().intValue());
  715.                 } else if (stat.getKey().equals("Jump")) {
  716.                     nEquip.setJump((short) stat.getValue().intValue());
  717.                 } else if (stat.getKey().equals("MHP")) {
  718.                     nEquip.setHp((short) stat.getValue().intValue());
  719.                 } else if (stat.getKey().equals("MMP")) {
  720.                     nEquip.setMp((short) stat.getValue().intValue());
  721.                 } else if (stat.getKey().equals("tuc")) {
  722.                     nEquip.setUpgradeSlots((byte) stat.getValue().intValue());
  723.                 } else if (stat.getKey().equals("afterImage")) {
  724.                 }
  725.             }
  726.         }
  727.         equipCache.put(equipId, nEquip);
  728.         return nEquip.copy();
  729.     }
  731.     private short getRandStat(short defaultValue, int maxRange, short additionalStats) {
  732.         if (defaultValue == 0) {
  733.             return 0;
  734.         }
  735.         // vary no more than ceil of 10% of stat
  736.         int lMaxRange = (int) Math.min(Math.ceil(defaultValue * 0.1), maxRange);
  737.         return (short) ((defaultValue - lMaxRange) + Math.floor(rand.nextDouble() * (lMaxRange * 2 + 1 * additionalStats)));
  738.     }
  740.     public Equip randomizeStats(MapleClient c, Equip equip) {
  741.         short x = 1;
  742.         ChannelServer cserv = c.getChannelServer();
  743.         if (cserv.isGodlyItems() && Math.ceil(Math.random() * 100.0) <= cserv.getGodlyItemRate()) {
  744.             x = cserv.getItemMultiplier();
  745.         }
  747.         equip.setStr(getRandStat(equip.getStr(), 5, x)); // LMAOO Horrible way. But works :D
  748.         equip.setDex(getRandStat(equip.getDex(), 5, x));
  749.         equip.setInt(getRandStat(equip.getInt(), 5, x));
  750.         equip.setLuk(getRandStat(equip.getLuk(), 5, x));
  751.         equip.setMatk(getRandStat(equip.getMatk(), 5, x));
  752.         equip.setWatk(getRandStat(equip.getWatk(), 5, x));
  753.         equip.setAcc(getRandStat(equip.getAcc(), 5, x));
  754.         equip.setAvoid(getRandStat(equip.getAvoid(), 5, x));
  755.         equip.setJump(getRandStat(equip.getJump(), 5, x));
  756.         equip.setSpeed(getRandStat(equip.getSpeed(), 5, x));
  757.         equip.setWdef(getRandStat(equip.getWdef(), 10, x));
  758.         equip.setMdef(getRandStat(equip.getMdef(), 10, x));
  759.         equip.setHp(getRandStat(equip.getHp(), 10, x));
  760.         equip.setMp(getRandStat(equip.getMp(), 10, x));
  761.         return equip;
  762.     }
  764.     public Equip hardcoreItem(Equip equip, short stat) {
  765.         equip.setStr(stat);
  766.         equip.setDex(stat);
  767.         equip.setInt(stat);
  768.         equip.setLuk(stat);
  769.         equip.setMatk(stat);
  770.         equip.setWatk(stat);
  771.         equip.setAcc(stat);
  772.         equip.setAvoid(stat);
  773.         equip.setJump(stat);
  774.         equip.setSpeed(stat);
  775.         equip.setWdef(stat);
  776.         equip.setMdef(stat);
  777.         equip.setHp(stat);
  778.         equip.setMp(stat);
  779.         return equip;
  780.     }
  782.     public MapleStatEffect getItemEffect(int itemId) {
  783.         MapleStatEffect ret = itemEffects.get(Integer.valueOf(itemId));
  784.         if (ret == null) {
  785.             MapleData item = getItemData(itemId);
  786.             if (item == null) {
  787.                 return null;
  788.             }
  789.             MapleData spec = item.getChildByPath("spec");
  790.             ret = MapleStatEffect.loadItemEffectFromData(spec, itemId);
  791.             itemEffects.put(Integer.valueOf(itemId), ret);
  792.         }
  793.         return ret;
  794.     }
  796.     public int[][] getSummonMobs(int itemId) {
  797.         MapleData data = getItemData(itemId);
  798.         int theInt = data.getChildByPath("mob").getChildren().size();
  799.         int[][] mobs2spawn = new int[theInt][2];
  800.         for (int x = 0; x < theInt; x++) {
  801.             mobs2spawn[x][0] = MapleDataTool.getIntConvert("mob/" + x + "/id", data);
  802.             mobs2spawn[x][1] = MapleDataTool.getIntConvert("mob/" + x + "/prob", data);
  803.         }
  804.         return mobs2spawn;
  805.     }
  807.     public boolean isThrowingStar(int itemId) {
  808.         return (itemId >= 2070000 && itemId < 2080000);
  809.     }
  811.     public boolean isBullet(int itemId) {
  812.         int id = itemId / 10000;
  813.         if (id == 233) {
  814.             return true;
  815.         } else {
  816.             return false;
  817.         }
  818.     }
  820.     public boolean isRechargable(int itemId) {
  821.         int id = itemId / 10000;
  822.         if (id == 233 || id == 207) {
  823.             return true;
  824.         } else {
  825.             return false;
  826.         }
  827.     }
  829.     public boolean isOverall(int itemId) {
  830.         return itemId >= 1050000 && itemId < 1060000;
  831.     }
  833.     public boolean isPet(int itemId) {
  834.         return itemId >= 5000000 && itemId <= 5000100;
  835.     }
  837.     public boolean isArrowForCrossBow(int itemId) {
  838.         return itemId >= 2061000 && itemId < 2062000;
  839.     }
  841.     public boolean isArrowForBow(int itemId) {
  842.         return itemId >= 2060000 && itemId < 2061000;
  843.     }
  845.     public boolean isTwoHanded(int itemId) {
  846.         switch (getWeaponType(itemId)) {
  847.             case AXE2H:
  848.             case BLUNT2H:
  849.             case BOW:
  850.             case CLAW:
  851.             case CROSSBOW:
  852.             case POLE_ARM:
  853.             case SPEAR:
  854.             case SWORD2H:
  855.             case GUN:
  856.             case KNUCKLE:
  857.                 return true;
  858.             default:
  859.                 return false;
  860.         }
  861.     }
  863.     public boolean isTownScroll(int itemId) {
  864.         return (itemId >= 2030000 && itemId < 2030020);
  865.     }
  867.     public boolean isGun(int itemId) {
  868.         return itemId >= 1492000 && itemId <= 1492024;
  869.     }
  871.     public int getWatkForProjectile(int itemId) {
  872.         Integer atk = projectileWatkCache.get(itemId);
  873.         if (atk != null) {
  874.             return atk.intValue();
  875.         }
  876.         MapleData data = getItemData(itemId);
  877.         atk = Integer.valueOf(MapleDataTool.getInt("info/incPAD", data, 0));
  878.         projectileWatkCache.put(itemId, atk);
  879.         return atk.intValue();
  880.     }
  882.     public boolean canScroll(int scrollid, int itemid) {
  883.         int scrollCategoryQualifier = (scrollid / 100) % 100;
  884.         int itemCategoryQualifier = (itemid / 10000) % 100;
  885.         return scrollCategoryQualifier == itemCategoryQualifier;
  886.     }
  888.     public String getName(int itemId) {
  889.         if (nameCache.containsKey(itemId)) {
  890.             return nameCache.get(itemId);
  891.         }
  892.         MapleData strings = getStringData(itemId);
  893.         if (strings == null) {
  894.             return null;
  895.         }
  896.         String ret = MapleDataTool.getString("name", strings, null);
  897.         nameCache.put(itemId, ret);
  898.         return ret;
  899.     }
  901.     public String getDesc(int itemId) {
  902.         if (descCache.containsKey(itemId)) {
  903.             return descCache.get(itemId);
  904.         }
  905.         MapleData strings = getStringData(itemId);
  906.         if (strings == null) {
  907.             return null;
  908.         }
  909.         String ret = MapleDataTool.getString("desc", strings, null);
  910.         descCache.put(itemId, ret);
  911.         return ret;
  912.     }
  914.     public String getMsg(int itemId) {
  915.         if (msgCache.containsKey(itemId)) {
  916.             return msgCache.get(itemId);
  917.         }
  918.         MapleData strings = getStringData(itemId);
  919.         if (strings == null) {
  920.             return null;
  921.         }
  922.         String ret = MapleDataTool.getString("msg", strings, null);
  923.         msgCache.put(itemId, ret);
  924.         return ret;
  925.     }
  927.     public boolean isDropRestricted(int itemId) {
  928.         if (dropRestrictionCache.containsKey(itemId)) {
  929.             return dropRestrictionCache.get(itemId);
  930.         }
  932.         MapleData data = getItemData(itemId);
  934.         boolean bRestricted = MapleDataTool.getIntConvert("info/tradeBlock", data, 0) == 1;
  935.         if (!bRestricted) {
  936.             bRestricted = MapleDataTool.getIntConvert("info/quest", data, 0) == 1;
  937.         }
  938.         dropRestrictionCache.put(itemId, bRestricted);
  940.         return bRestricted;
  941.     }
  943.     public boolean isPickupRestricted(int itemId) {
  944.         if (pickupRestrictionCache.containsKey(itemId)) {
  945.             return pickupRestrictionCache.get(itemId);
  946.         }
  948.         MapleData data = getItemData(itemId);
  949.         boolean bRestricted = MapleDataTool.getIntConvert("info/only", data, 0) == 1;
  951.         pickupRestrictionCache.put(itemId, bRestricted);
  952.         return bRestricted;
  953.     }
  955.     public Map<String, Integer> getSkillStats(int itemId, double playerJob) {
  956.         Map<String, Integer> ret = new LinkedHashMap<String, Integer>();
  957.         MapleData item = getItemData(itemId);
  958.         if (item == null) {
  959.             return null;
  960.         }
  961.         MapleData info = item.getChildByPath("info");
  962.         if (info == null) {
  963.             return null;
  964.         }
  965.         for (MapleData data : info.getChildren()) {
  966.             if (data.getName().startsWith("inc")) {
  967.                 ret.put(data.getName().substring(3), MapleDataTool.getIntConvert(data));
  968.             }
  969.         }
  970.         ret.put("masterLevel", MapleDataTool.getInt("masterLevel", info, 0));
  971.         ret.put("reqSkillLevel", MapleDataTool.getInt("reqSkillLevel", info, 0));
  972.         ret.put("success", MapleDataTool.getInt("success", info, 0));
  974.         MapleData skill = info.getChildByPath("skill");
  975.         int curskill = 1;
  976.         int size = skill.getChildren().size();
  977.         for (int i = 0; i < size; i++) {
  978.             curskill = MapleDataTool.getInt(Integer.toString(i), skill, 0);
  979.             if (curskill == 0) // end - no more;
  980.             {
  981.                 break;
  982.             }
  983.             double skillJob = Math.floor(curskill / 10000);
  984.             if (skillJob == playerJob) {
  985.                 ret.put("skillid", curskill);
  986.                 break;
  987.             }
  988.         }
  990.         if (ret.get("skillid") == null) {
  991.             ret.put("skillid", 0);
  992.         }
  994.         return ret;
  995.     }
  997.     public List<Integer> petsCanConsume(int itemId) {
  998.         List<Integer> ret = new ArrayList<Integer>();
  999.         MapleData data = getItemData(itemId);
  1000.         int curPetId = 0;
  1001.         int size = data.getChildren().size();
  1002.         for (int i = 0; i < size; i++) {
  1003.             curPetId = MapleDataTool.getInt("spec/" + Integer.toString(i), data, 0);
  1004.             if (curPetId == 0) {
  1005.                 break;
  1006.             }
  1007.             ret.add(Integer.valueOf(curPetId));
  1008.         }
  1009.         return ret;
  1010.     }
  1011.     protected Map<Integer, Boolean> isQuestItemCache = new HashMap<Integer, Boolean>();
  1013.     public boolean isQuestItem(int itemId) {
  1014.         if (isQuestItemCache.containsKey(itemId)) {
  1015.             return isQuestItemCache.get(itemId);
  1016.         }
  1017.         MapleData data = getItemData(itemId);
  1018.         boolean questItem = MapleDataTool.getIntConvert("info/quest", data, 0) == 1;
  1019.         isQuestItemCache.put(itemId, questItem);
  1020.         return questItem;
  1021.     }
  1023.     public boolean isMiniDungeonMap(int mapId) {
  1024.         switch (mapId) {
  1025.             case 100020000:
  1026.             case 105040304:
  1027.             case 105050100:
  1028.             case 221023400:
  1029.                 return true;
  1030.             default:
  1031.                 return false;
  1032.         }
  1033.     }
  1036. }