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

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

游戏

开发平台：

Java

MapleInventoryManipulator.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.  * MapleInventoryManipulator.java
  24.  * 
  25.  * Created on 27. November 2007, 16:19
  26.  */
  27. package net.sf.odinms.server;
  29. import java.awt.Point;
  30. import java.util.Iterator;
  31. import java.util.List;
  33. import net.sf.odinms.client.Equip;
  34. import net.sf.odinms.client.IItem;
  35. import net.sf.odinms.client.InventoryException;
  36. import net.sf.odinms.client.Item;
  37. import net.sf.odinms.client.MapleBuffStat;
  38. import net.sf.odinms.client.MapleCharacter;
  39. import net.sf.odinms.client.MapleClient;
  40. import net.sf.odinms.client.MapleInventoryType;
  41. import net.sf.odinms.tools.MaplePacketCreator;
  43. import org.slf4j.Logger;
  44. import org.slf4j.LoggerFactory;
  46. /**
  47.  * 
  48.  * @author Matze
  49.  */
  50. public class MapleInventoryManipulator {
  52.     private static Logger log = LoggerFactory.getLogger(MapleInventoryManipulator.class);
  54.     /** Creates a new instance of MapleInventoryManipulator */
  55.     private MapleInventoryManipulator() {
  56.     }
  58.     public static boolean addRing(MapleCharacter chr, int itemId, int ringId) {
  59.         MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
  60.         MapleInventoryType type = ii.getInventoryType(itemId);
  61.         IItem nEquip = ii.getEquipById(itemId, ringId);
  63.         byte newSlot = chr.getInventory(type).addItem(nEquip);
  64.         if (newSlot == -1) {
  65.             return false;
  66.         }
  67.         chr.getClient().getSession().write(MaplePacketCreator.addInventorySlot(type, nEquip));
  68.         return true;
  69.     }
  71.     public static boolean addById(MapleClient c, int itemId, short quantity) {
  72.         return addById(c, itemId, quantity, null);
  73.     }
  75.     public static boolean addById(MapleClient c, int itemId, short quantity, String owner) {
  76.         return addById(c, itemId, quantity, owner, -1);
  77.     }
  79.     public static boolean addById(MapleClient c, int itemId, short quantity, String owner, int petid) {
  80.         MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
  81.         MapleInventoryType type = ii.getInventoryType(itemId);
  82.         if (!type.equals(MapleInventoryType.EQUIP)) {
  83.             short slotMax = ii.getSlotMax(c, itemId);
  84.             List<IItem> existing = c.getPlayer().getInventory(type).listById(itemId);
  85.             if (!ii.isThrowingStar(itemId) && !ii.isBullet(itemId)) {
  86.                 if (existing.size() > 0) { // first update all existing slots to slotMax
  88.                     Iterator<IItem> i = existing.iterator();
  89.                     while (quantity > 0) {
  90.                         if (i.hasNext()) {
  91.                             Item eItem = (Item) i.next();
  92.                             short oldQ = eItem.getQuantity();
  93.                             if (oldQ < slotMax && (eItem.getOwner().equals(owner) || owner == null)) {
  94.                                 short newQ = (short) Math.min(oldQ + quantity, slotMax);
  95.                                 quantity -= (newQ - oldQ);
  96.                                 eItem.setQuantity(newQ);
  97.                                 c.getSession().write(MaplePacketCreator.updateInventorySlot(type, eItem));
  98.                             }
  99.                         } else {
  100.                             break;
  101.                         }
  102.                     }
  103.                 }
  104.                 // add new slots if there is still something left
  105.                 while (quantity > 0 || ii.isThrowingStar(itemId) || ii.isBullet(itemId)) {
  106.                     short newQ = (short) Math.min(quantity, slotMax);
  107.                     if (newQ != 0) {
  108.                         quantity -= newQ;
  109.                         Item nItem = new Item(itemId, (byte) 0, newQ, petid);
  110.                         byte newSlot = c.getPlayer().getInventory(type).addItem(nItem);
  111.                         if (newSlot == -1) {
  112.                             c.getSession().write(MaplePacketCreator.getInventoryFull());
  113.                             c.getSession().write(MaplePacketCreator.getShowInventoryFull());
  114.                             return false;
  115.                         }
  116.                         if (owner != null) {
  117.                             nItem.setOwner(owner);
  118.                         }
  119.                         c.getSession().write(MaplePacketCreator.addInventorySlot(type, nItem));
  120.                         if ((ii.isThrowingStar(itemId) || ii.isBullet(itemId)) && quantity == 0) {
  121.                             break;
  122.                         }
  123.                     } else {
  124.                         c.getSession().write(MaplePacketCreator.enableActions());
  125.                         return false;
  126.                     }
  127.                 }
  128.             } else {
  129.                 // Throwing Stars and Bullets - Add all into one slot regardless of quantity.
  130.                 Item nItem = new Item(itemId, (byte) 0, quantity);
  131.                 byte newSlot = c.getPlayer().getInventory(type).addItem(nItem);
  133.                 if (newSlot == -1) {
  134.                     c.getSession().write(MaplePacketCreator.getInventoryFull());
  135.                     c.getSession().write(MaplePacketCreator.getShowInventoryFull());
  136.                     return false;
  137.                 }
  138.                 c.getSession().write(MaplePacketCreator.addInventorySlot(type, nItem));
  139.                 c.getSession().write(MaplePacketCreator.enableActions());
  140.             }
  141.         } else {
  142.             if (quantity == 1) {
  143.                 IItem nEquip = ii.getEquipById(itemId);
  144.                 if (owner != null) {
  145.                     nEquip.setOwner(owner);
  146.                 }
  148.                 byte newSlot = c.getPlayer().getInventory(type).addItem(nEquip);
  149.                 if (newSlot == -1) {
  150.                     c.getSession().write(MaplePacketCreator.getInventoryFull());
  151.                     c.getSession().write(MaplePacketCreator.getShowInventoryFull());
  152.                     return false;
  153.                 }
  154.                 c.getSession().write(MaplePacketCreator.addInventorySlot(type, nEquip));
  155.             } else {
  156.                 throw new InventoryException("Trying to create equip with non-one quantity");
  157.             }
  158.         }
  159.         return true;
  160.     }
  162.     public static boolean addFromDrop(MapleClient c, IItem item) {
  163.         return addFromDrop(c, item, true);
  164.     }
  166.     public static boolean addFromDrop(MapleClient c, IItem item, boolean show) {
  167.         return addFromDrop(c, item, show, null);
  168.     }
  170.     public static boolean addFromDrop(MapleClient c, IItem item, boolean show, String owner) {
  171.         MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
  172.         MapleInventoryType type = ii.getInventoryType(item.getItemId());
  174.         if (!c.getChannelServer().allowMoreThanOne() && ii.isPickupRestricted(item.getItemId()) && c.getPlayer().haveItem(item.getItemId(), 1, true, false)) {
  175.             c.getSession().write(MaplePacketCreator.getInventoryFull());
  176.             c.getSession().write(MaplePacketCreator.showItemUnavailable());
  177.             return false;
  178.         }
  180.         short quantity = item.getQuantity();
  181.         if (!type.equals(MapleInventoryType.EQUIP)) {
  182.             short slotMax = ii.getSlotMax(c, item.getItemId());
  183.             List<IItem> existing = c.getPlayer().getInventory(type).listById(item.getItemId());
  184.             if (!ii.isThrowingStar(item.getItemId()) && !ii.isBullet(item.getItemId())) {
  185.                 if (existing.size() > 0) { // first update all existing slots to slotMax
  187.                     Iterator<IItem> i = existing.iterator();
  188.                     while (quantity > 0) {
  189.                         if (i.hasNext()) {
  190.                             Item eItem = (Item) i.next();
  191.                             short oldQ = eItem.getQuantity();
  192.                             if (oldQ < slotMax && item.getOwner().equals(eItem.getOwner())) {
  193.                                 short newQ = (short) Math.min(oldQ + quantity, slotMax);
  194.                                 quantity -= (newQ - oldQ);
  195.                                 eItem.setQuantity(newQ);
  196.                                 c.getSession().write(MaplePacketCreator.updateInventorySlot(type, eItem, true));
  197.                             }
  198.                         } else {
  199.                             break;
  200.                         }
  201.                     }
  202.                 }
  203.                 // add new slots if there is still something left
  204.                 while (quantity > 0 || ii.isThrowingStar(item.getItemId()) || ii.isBullet(item.getItemId())) {
  205.                     short newQ = (short) Math.min(quantity, slotMax);
  206.                     quantity -= newQ;
  207.                     Item nItem = new Item(item.getItemId(), (byte) 0, newQ);
  208.                     nItem.setOwner(item.getOwner());
  209.                     byte newSlot = c.getPlayer().getInventory(type).addItem(nItem);
  210.                     if (newSlot == -1) {
  211.                         c.getSession().write(MaplePacketCreator.getInventoryFull());
  212.                         c.getSession().write(MaplePacketCreator.getShowInventoryFull());
  213.                         item.setQuantity((short) (quantity + newQ));
  214.                         return false;
  215.                     }
  216.                     c.getSession().write(MaplePacketCreator.addInventorySlot(type, nItem, true));
  217.                 }
  218.             } else {
  219.                 // Throwing Stars and Bullets - Add all into one slot regardless of quantity.
  220.                 Item nItem = new Item(item.getItemId(), (byte) 0, quantity);
  221.                 byte newSlot = c.getPlayer().getInventory(type).addItem(nItem);
  222.                 if (newSlot == -1) {
  223.                     c.getSession().write(MaplePacketCreator.getInventoryFull());
  224.                     c.getSession().write(MaplePacketCreator.getShowInventoryFull());
  225.                     return false;
  226.                 }
  227.                 c.getSession().write(MaplePacketCreator.addInventorySlot(type, nItem));
  228.                 c.getSession().write(MaplePacketCreator.enableActions());
  229.             }
  230.         } else {
  231.             if (quantity == 1) {
  232.                 byte newSlot = c.getPlayer().getInventory(type).addItem(item);
  234.                 if (newSlot == -1) {
  235.                     c.getSession().write(MaplePacketCreator.getInventoryFull());
  236.                     c.getSession().write(MaplePacketCreator.getShowInventoryFull());
  237.                     return false;
  238.                 }
  239.                 c.getSession().write(MaplePacketCreator.addInventorySlot(type, item, true));
  240.             } else {
  241.                 throw new RuntimeException("Trying to create equip with non-one quantity");
  242.             }
  243.         }
  244.         if (owner != null) {
  245.             item.setOwner(owner);
  246.         }
  247.         if (show) {
  248.             c.getSession().write(MaplePacketCreator.getShowItemGain(item.getItemId(), item.getQuantity()));
  249.         }
  250.         return true;
  251.     }
  253.     public static boolean checkSpace(MapleClient c, int itemid, int quantity, String owner) {
  254.         MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
  255.         MapleInventoryType type = ii.getInventoryType(itemid);
  257.         if (!type.equals(MapleInventoryType.EQUIP)) {
  258.             short slotMax = ii.getSlotMax(c, itemid);
  259.             List<IItem> existing = c.getPlayer().getInventory(type).listById(itemid);
  260.             if (!ii.isThrowingStar(itemid) && !ii.isBullet(itemid)) {
  261.                 if (existing.size() > 0) { // first update all existing slots to slotMax
  263.                     for (IItem eItem : existing) {
  264.                         short oldQ = eItem.getQuantity();
  265.                         if (oldQ < slotMax && owner.equals(eItem.getOwner())) {
  266.                             short newQ = (short) Math.min(oldQ + quantity, slotMax);
  267.                             quantity -= (newQ - oldQ);
  268.                         }
  269.                         if (quantity <= 0) {
  270.                             break;
  271.                         }
  272.                     }
  273.                 }
  274.             }
  275.             // add new slots if there is still something left
  276.             final int numSlotsNeeded;
  277.             if (slotMax > 0) {
  278.                 numSlotsNeeded = (int) (Math.ceil(((double) quantity) / slotMax));
  279.             } else if (ii.isThrowingStar(itemid) || ii.isBullet(itemid)) {
  280.                 numSlotsNeeded = 1;
  281.             } else {
  282.                 numSlotsNeeded = 1;
  283.                 System.err.println("SUCK ERROR - FIX ME! - 0 slotMax");
  284.             }
  285.             return !c.getPlayer().getInventory(type).isFull(numSlotsNeeded - 1);
  286.         } else {
  287.             return !c.getPlayer().getInventory(type).isFull();
  288.         }
  289.     }
  291.     public static void removeFromSlot(MapleClient c, MapleInventoryType type, byte slot, short quantity, boolean fromDrop) {
  292.         removeFromSlot(c, type, slot, quantity, fromDrop, false);
  293.     }
  295.     public static void removeFromSlot(MapleClient c, MapleInventoryType type, byte slot, short quantity, boolean fromDrop, boolean consume) {
  296.         IItem item = c.getPlayer().getInventory(type).getItem(slot);
  297.         MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
  298.         boolean allowZero = consume && (ii.isThrowingStar(item.getItemId()) || ii.isBullet(item.getItemId()));
  299.         c.getPlayer().getInventory(type).removeItem(slot, quantity, allowZero);
  300.         if (item.getQuantity() == 0 && !allowZero) {
  301.             c.getSession().write(MaplePacketCreator.clearInventoryItem(type, item.getPosition(), fromDrop));
  302.         } else {
  303.             c.getSession().write(MaplePacketCreator.updateInventorySlot(type, (Item) item, fromDrop));
  304.         }
  305.     }
  307.     public static void removeById(MapleClient c, MapleInventoryType type, int itemId, int quantity, boolean fromDrop, boolean consume, boolean v) {
  308.         List<IItem> items = c.getPlayer().getInventory(type).listById(itemId);
  309.         int remremove = quantity;
  310.         for (IItem item : items) {
  311.             if (remremove <= item.getQuantity()) {
  312.                 removeFromSlot(c, type, item.getPosition(), (short) remremove, fromDrop, consume);
  313.                 remremove = 0;
  314.                 break;
  315.             } else {
  316.                 remremove -= item.getQuantity();
  317.                 removeFromSlot(c, type, item.getPosition(), item.getQuantity(), fromDrop, consume);
  318.             }
  319.         }
  320.         if (remremove > 0) {
  321.             throw new InventoryException("[h4x] Not enough cheese available (" + itemId + ", " + (quantity - remremove) +
  322.                     "/" + quantity + ")");
  323.         }
  324.     }
  326.     public static void removeById(MapleClient c, MapleInventoryType type, int itemId, int quantity, boolean fromDrop, boolean consume) {
  327.         List<IItem> items = c.getPlayer().getInventory(type).listById(itemId);
  328.         int remremove = quantity;
  329.         for (IItem item : items) {
  330.             if (remremove <= item.getQuantity()) {
  331.                 removeFromSlot(c, type, item.getPosition(), (short) remremove, fromDrop, consume);
  332.                 remremove = 0;
  333.                 break;
  334.             } else {
  335.                 remremove -= item.getQuantity();
  336.                 removeFromSlot(c, type, item.getPosition(), item.getQuantity(), fromDrop, consume);
  337.             }
  338.         }
  339.         if (remremove > 0) {
  340.             throw new InventoryException("[h4x] Not enough cheese available (" + itemId + ", " + (quantity - remremove) +
  341.                     "/" + quantity + ")");
  342.         }
  343.     }
  345.     public static void removeAllById(MapleClient c, int itemId, boolean checkEquipped) {
  346.         MapleInventoryType type = MapleItemInformationProvider.getInstance().getInventoryType(itemId);
  347.         for (IItem item : c.getPlayer().getInventory(type).listById(itemId)) {
  348.             if (item != null) {
  349.                 removeFromSlot(c, type, item.getPosition(), item.getQuantity(), true, false);
  350.             }
  351.         }
  352.         if (checkEquipped) {
  353.             IItem ii = c.getPlayer().getInventory(type).findById(itemId);
  354.             if (ii != null) {
  355.                 c.getPlayer().getInventory(MapleInventoryType.EQUIPPED).removeItem(ii.getPosition());
  356.                 c.getPlayer().equipChanged();
  357.             }
  358.         }
  359.     }
  361.     public static void move(MapleClient c, MapleInventoryType type, byte src, byte dst) {
  362.         if (src < 0 || dst < 0) {
  363.             return;
  364.         }
  365.         MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
  366.         IItem source = c.getPlayer().getInventory(type).getItem(src);
  367.         IItem initialTarget = c.getPlayer().getInventory(type).getItem(dst);
  368.         if (source == null) {
  369.             return;
  370.         }
  371.         short olddstQ = -1;
  372.         if (initialTarget != null) {
  373.             olddstQ = initialTarget.getQuantity();
  374.         }
  375.         short oldsrcQ = source.getQuantity();
  376.         short slotMax = ii.getSlotMax(c, source.getItemId());
  377.         c.getPlayer().getInventory(type).move(src, dst, slotMax);
  378.         if (!type.equals(MapleInventoryType.EQUIP) && initialTarget != null && initialTarget.getItemId() == source.getItemId() && !ii.isThrowingStar(source.getItemId()) && !ii.isBullet(source.getItemId())) {
  379.             if ((olddstQ + oldsrcQ) > slotMax) {
  380.                 c.getSession().write(MaplePacketCreator.moveAndMergeWithRestInventoryItem(type, src, dst, (short) ((olddstQ + oldsrcQ) - slotMax), slotMax));
  381.             } else {
  382.                 c.getSession().write(MaplePacketCreator.moveAndMergeInventoryItem(type, src, dst, ((Item) c.getPlayer().getInventory(type).getItem(dst)).getQuantity()));
  383.             }
  384.         } else {
  385.             c.getSession().write(MaplePacketCreator.moveInventoryItem(type, src, dst));
  386.         }
  387.     }
  389.     public static void equip(MapleClient c, byte src, byte dst) {
  390.         MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
  391.         Equip source = (Equip) c.getPlayer().getInventory(MapleInventoryType.EQUIP).getItem(src);
  392.         Equip target = (Equip) c.getPlayer().getInventory(MapleInventoryType.EQUIPPED).getItem(dst);
  393.         if (source == null) {
  394.             return;
  395.         }
  396.         if (source.getItemId() == 1812006) {
  397.             removeAllById(c, source.getItemId(), false);
  398.             c.getPlayer().dropMessage(1, "Magic Scale Has Been Blocked");
  399.             return;
  400.         }
  401.         if (dst == -6) {
  402.             // unequip the overall
  403.             IItem top = c.getPlayer().getInventory(MapleInventoryType.EQUIPPED).getItem((byte) -5);
  404.             if (top != null && ii.isOverall(top.getItemId())) {
  405.                 if (c.getPlayer().getInventory(MapleInventoryType.EQUIP).isFull()) {
  406.                     c.getSession().write(MaplePacketCreator.getInventoryFull());
  407.                     c.getSession().write(MaplePacketCreator.getShowInventoryFull());
  408.                     return;
  409.                 }
  410.                 unequip(c, (byte) -5, c.getPlayer().getInventory(MapleInventoryType.EQUIP).getNextFreeSlot());
  411.             }
  412.         } else if (dst == -5) {
  413.             // unequip the bottom and top
  414.             IItem top = c.getPlayer().getInventory(MapleInventoryType.EQUIPPED).getItem((byte) -5);
  415.             IItem bottom = c.getPlayer().getInventory(MapleInventoryType.EQUIPPED).getItem((byte) -6);
  416.             if (top != null && ii.isOverall(source.getItemId())) {
  417.                 if (c.getPlayer().getInventory(MapleInventoryType.EQUIP).isFull(bottom != null && ii.isOverall(source.getItemId()) ? 1 : 0)) {
  418.                     c.getSession().write(MaplePacketCreator.getInventoryFull());
  419.                     c.getSession().write(MaplePacketCreator.getShowInventoryFull());
  420.                     return;
  421.                 }
  422.                 unequip(c, (byte) -5, c.getPlayer().getInventory(MapleInventoryType.EQUIP).getNextFreeSlot());
  423.             }
  424.             if (bottom != null && ii.isOverall(source.getItemId())) {
  425.                 if (c.getPlayer().getInventory(MapleInventoryType.EQUIP).isFull()) {
  426.                     c.getSession().write(MaplePacketCreator.getInventoryFull());
  427.                     c.getSession().write(MaplePacketCreator.getShowInventoryFull());
  428.                     return;
  429.                 }
  430.                 unequip(c, (byte) -6, c.getPlayer().getInventory(MapleInventoryType.EQUIP).getNextFreeSlot());
  431.             }
  432.         } else if (dst == -10) {
  433.             // check if weapon is two-handed
  434.             IItem weapon = c.getPlayer().getInventory(MapleInventoryType.EQUIPPED).getItem((byte) -11);
  435.             if (weapon != null && ii.isTwoHanded(weapon.getItemId())) {
  436.                 if (c.getPlayer().getInventory(MapleInventoryType.EQUIP).isFull()) {
  437.                     c.getSession().write(MaplePacketCreator.getInventoryFull());
  438.                     c.getSession().write(MaplePacketCreator.getShowInventoryFull());
  439.                     return;
  440.                 }
  441.                 unequip(c, (byte) -11, c.getPlayer().getInventory(MapleInventoryType.EQUIP).getNextFreeSlot());
  442.             }
  443.         } else if (dst == -11) {
  444.             IItem shield = c.getPlayer().getInventory(MapleInventoryType.EQUIPPED).getItem((byte) -10);
  445.             if (shield != null && ii.isTwoHanded(source.getItemId())) {
  446.                 if (c.getPlayer().getInventory(MapleInventoryType.EQUIP).isFull()) {
  447.                     c.getSession().write(MaplePacketCreator.getInventoryFull());
  448.                     c.getSession().write(MaplePacketCreator.getShowInventoryFull());
  449.                     return;
  450.                 }
  451.                 unequip(c, (byte) -10, c.getPlayer().getInventory(MapleInventoryType.EQUIP).getNextFreeSlot());
  452.             }
  453.         } else if (dst == -18) {
  454.             c.getPlayer().getMount().setItemId(source.getItemId());
  455.         }
  456.         source = (Equip) c.getPlayer().getInventory(MapleInventoryType.EQUIP).getItem(src);
  457.         target = (Equip) c.getPlayer().getInventory(MapleInventoryType.EQUIPPED).getItem(dst);
  458.         c.getPlayer().getInventory(MapleInventoryType.EQUIP).removeSlot(src);
  459.         if (target != null) {
  460.             c.getPlayer().getInventory(MapleInventoryType.EQUIPPED).removeSlot(dst);
  461.         }
  462.         source.setPosition(dst);
  463.         c.getPlayer().getInventory(MapleInventoryType.EQUIPPED).addFromDB(source);
  464.         if (target != null) {
  465.             target.setPosition(src);
  466.             c.getPlayer().getInventory(MapleInventoryType.EQUIP).addFromDB(target);
  467.         }
  468.         if (c.getPlayer().getBuffedValue(MapleBuffStat.BOOSTER) != null && ii.isWeapon(source.getItemId())) {
  469.             c.getPlayer().cancelBuffStats(MapleBuffStat.BOOSTER);
  470.         }
  471.         c.getSession().write(MaplePacketCreator.moveInventoryItem(MapleInventoryType.EQUIP, src, dst, (byte) 2));
  472.         c.getPlayer().equipChanged();
  473.     }
  475.     public static void unequip(MapleClient c, byte src, byte dst) {
  476.         Equip source = (Equip) c.getPlayer().getInventory(MapleInventoryType.EQUIPPED).getItem(src);
  477.         Equip target = (Equip) c.getPlayer().getInventory(MapleInventoryType.EQUIP).getItem(dst);
  478.         if (dst < 0) {
  479.             log.warn("Unequipping to negative slot. ({}: {}->{})", new Object[]{c.getPlayer().getName(), src, dst});
  480.         }
  481.         if (source == null) {
  482.             return;
  483.         }
  484.         if (target != null && src <= 0) {
  485.             // do not allow switching with equip
  486.             c.getSession().write(MaplePacketCreator.getInventoryFull());
  487.             return;
  488.         }
  489.         c.getPlayer().getInventory(MapleInventoryType.EQUIPPED).removeSlot(src);
  490.         if (target != null) {
  491.             c.getPlayer().getInventory(MapleInventoryType.EQUIP).removeSlot(dst);
  492.         }
  493.         source.setPosition(dst);
  494.         c.getPlayer().getInventory(MapleInventoryType.EQUIP).addFromDB(source);
  495.         if (target != null) {
  496.             target.setPosition(src);
  497.             c.getPlayer().getInventory(MapleInventoryType.EQUIPPED).addFromDB(target);
  498.         }
  499.         c.getSession().write(MaplePacketCreator.moveInventoryItem(MapleInventoryType.EQUIP, src, dst, (byte) 1));
  500.         c.getPlayer().equipChanged();
  501.     }
  503.     public static void drop(MapleClient c, MapleInventoryType type, byte src, short quantity) {
  504.         MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
  505.         if (src < 0) {
  506.             type = MapleInventoryType.EQUIPPED;
  507.         }
  508.         IItem source = c.getPlayer().getInventory(type).getItem(src);
  509.         int itemId = source.getItemId();
  511.         if (c.getPlayer().getItemEffect() == itemId && source.getQuantity() == 1) {
  512.             c.getPlayer().setItemEffect(0);
  513.             c.getPlayer().getMap().broadcastMessage(MaplePacketCreator.itemEffect(c.getPlayer().getId(), 0));
  514.         } else if (itemId == 5370000 || itemId == 5370001) {
  515.             if (c.getPlayer().getItemQuantity(itemId, false) == 1) {
  516.                 c.getPlayer().setChalkboard(null);
  517.             }
  518.         }
  520.         if (quantity < 0 || source == null || quantity == 0 && !ii.isThrowingStar(itemId) && !ii.isBullet(itemId)) {
  521.             String message = "Dropping " + quantity + " " + (source == null ? "?" : itemId) + " (" +
  522.                     type.name() + "/" + src + ")";
  523.             //AutobanManager.getInstance().addPoints(c, 1000, 0, message);
  524.             log.info(MapleClient.getLogMessage(c, message));
  525.             c.getSession().close(); // disconnect the client as is inventory is inconsistent with the serverside inventory -> fuck
  527.             return;
  528.         }
  529.         Point dropPos = new Point(c.getPlayer().getPosition());
  530.         //dropPos.y -= 99;
  531.         if (quantity < source.getQuantity() && !ii.isThrowingStar(itemId) && !ii.isBullet(itemId)) {
  532.             IItem target = source.copy();
  533.             target.setQuantity(quantity);
  534.             source.setQuantity((short) (source.getQuantity() - quantity));
  535.             c.getSession().write(MaplePacketCreator.dropInventoryItemUpdate(type, source));
  536.             boolean weddingRing = source.getItemId() == 1112803 || source.getItemId() == 1112806 || source.getItemId() == 1112807 || source.getItemId() == 1112809;
  537.             if (weddingRing) {
  538.                 c.getPlayer().getMap().disappearingItemDrop(c.getPlayer(), c.getPlayer(), target, dropPos);
  539.             } else if (c.getPlayer().getMap().getEverlast()) {
  540.                 if (!c.getChannelServer().allowUndroppablesDrop() && ii.isDropRestricted(target.getItemId())) {
  541.                     c.getPlayer().getMap().disappearingItemDrop(c.getPlayer(), c.getPlayer(), target, dropPos);
  542.                 } else {
  543.                     c.getPlayer().getMap().spawnItemDrop(c.getPlayer(), c.getPlayer(), target, dropPos, true, false);
  544.                 }
  545.             } else {
  546.                 if (!c.getChannelServer().allowUndroppablesDrop() && ii.isDropRestricted(target.getItemId())) {
  547.                     c.getPlayer().getMap().disappearingItemDrop(c.getPlayer(), c.getPlayer(), target, dropPos);
  548.                 } else {
  549.                     c.getPlayer().getMap().spawnItemDrop(c.getPlayer(), c.getPlayer(), target, dropPos, true, true);
  550.                 }
  551.             }
  552.         } else {
  553.             c.getPlayer().getInventory(type).removeSlot(src);
  554.             c.getSession().write(MaplePacketCreator.dropInventoryItem(
  555.                     (src < 0 ? MapleInventoryType.EQUIP : type), src));
  556.             if (src < 0) {
  557.                 c.getPlayer().equipChanged();
  558.             }
  559.             if (c.getPlayer().getMap().getEverlast()) {
  560.                 if (!c.getChannelServer().allowUndroppablesDrop() && ii.isDropRestricted(itemId)) {
  561.                     c.getPlayer().getMap().disappearingItemDrop(c.getPlayer(), c.getPlayer(), source, dropPos);
  562.                 } else {
  563.                     c.getPlayer().getMap().spawnItemDrop(c.getPlayer(), c.getPlayer(), source, dropPos, true, false);
  564.                 }
  565.             } else {
  566.                 if (!c.getChannelServer().allowUndroppablesDrop() && ii.isDropRestricted(itemId)) {
  567.                     c.getPlayer().getMap().disappearingItemDrop(c.getPlayer(), c.getPlayer(), source, dropPos);
  568.                 } else {
  569.                     c.getPlayer().getMap().spawnItemDrop(c.getPlayer(), c.getPlayer(), source, dropPos, true, true);
  570.                 }
  571.             }
  572.         }
  573.     }
  574. }