public static boolean checkSpace(
final MapleClient c, final int Id, int quantity, final String owner) {
final MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
final MapleInventoryType type = ii.getInventoryType(Id);
if (!type.equals(MapleInventoryType.EQUIP)) {
final short slotMax = ii.getSlotMax(c, Id);
final List<IItem> existing = c.getPlayer().getInventory(type).listById(Id);
if (!InventoryConstants.isRechargable(Id)) {
if (existing.size() > 0) {
for (IItem eItem : existing) {
final short oldQ = eItem.getQuantity();
if (oldQ < slotMax && owner.equals(eItem.getOwner())) {
final short newQ = (short) Math.min(oldQ + quantity, slotMax);
quantity -= (newQ - oldQ);
}
if (quantity <= 0) {
break;
}
}
}
}
final int numSlotsNeeded;
if (slotMax > 0) {
numSlotsNeeded = (int) (Math.ceil(((double) quantity) / slotMax));
} else if (InventoryConstants.isRechargable(Id)) {
numSlotsNeeded = 1;
} else {
numSlotsNeeded = 1;
System.out.println("checkSpace error");
}
return !c.getPlayer().getInventory(type).isFull(numSlotsNeeded - 1);
} else {
return !c.getPlayer().getInventory(type).isFull();
}
}
public static void move(MapleClient c, MapleInventoryType type, byte src, byte dst) {
if (src < 0 || dst < 0) {
return;
}
MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
IItem source = c.getPlayer().getInventory(type).getItem(src);
IItem initialTarget = c.getPlayer().getInventory(type).getItem(dst);
if (source == null) {
return;
}
short olddstQ = -1;
if (initialTarget != null) {
olddstQ = initialTarget.getQuantity();
}
short oldsrcQ = source.getQuantity();
short slotMax = ii.getSlotMax(c, source.getItemId());
c.getPlayer().getInventory(type).move(src, dst, slotMax);
if (!type.equals(MapleInventoryType.EQUIP)
&& initialTarget != null
&& initialTarget.getItemId() == source.getItemId()
&& !ii.isThrowingStar(source.getItemId())
&& !ii.isBullet(source.getItemId())) {
if ((olddstQ + oldsrcQ) > slotMax) {
c.getSession()
.write(
MaplePacketCreator.moveAndMergeWithRestInventoryItem(
type, src, dst, (short) ((olddstQ + oldsrcQ) - slotMax), slotMax));
} else {
c.getSession()
.write(
MaplePacketCreator.moveAndMergeInventoryItem(
type,
src,
dst,
((Item) c.getPlayer().getInventory(type).getItem(dst)).getQuantity()));
}
} else {
c.getSession().write(MaplePacketCreator.moveInventoryItem(type, src, dst));
}
}
public static void move(
final MapleClient c, final MapleInventoryType type, final short src, final short dst) {
if (src < 0 || dst < 0) {
return;
}
final MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
final IItem source = c.getPlayer().getInventory(type).getItem(src);
final IItem initialTarget = c.getPlayer().getInventory(type).getItem(dst);
if (source == null) {
return;
}
short olddstQ = -1;
if (initialTarget != null) {
olddstQ = initialTarget.getQuantity();
}
final short oldsrcQ = source.getQuantity();
final short slotMax = ii.getSlotMax(c, source.getId());
c.getPlayer().getInventory(type).move(src, dst, slotMax);
if (!type.equals(MapleInventoryType.EQUIP)
&& initialTarget != null
&& initialTarget.getId() == source.getId()
&& !InventoryConstants.isRechargable(source.getId())) {
if ((olddstQ + oldsrcQ) > slotMax) {
c.announce(
InventoryFactory.moveAndMergeWithRestInventoryItem(
type, src, dst, (short) ((olddstQ + oldsrcQ) - slotMax), slotMax));
} else {
c.announce(
InventoryFactory.moveAndMergeInventoryItem(
type,
src,
dst,
((Item) c.getPlayer().getInventory(type).getItem(dst)).getQuantity()));
}
} else {
c.announce(InventoryFactory.moveInventoryItem(type, src, dst));
}
}
public static boolean checkSpace(MapleClient c, int itemid, int quantity, String owner) {
MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
MapleInventoryType type = ii.getInventoryType(itemid);
if (!type.equals(MapleInventoryType.EQUIP)) {
short slotMax = ii.getSlotMax(c, itemid);
List<IItem> existing = c.getPlayer().getInventory(type).listById(itemid);
if (!ii.isThrowingStar(itemid) && !ii.isBullet(itemid)) {
if (existing.size() > 0) { // first update all existing slots to slotMax
for (IItem eItem : existing) {
short oldQ = eItem.getQuantity();
if (oldQ < slotMax && owner.equals(eItem.getOwner())) {
short newQ = (short) Math.min(oldQ + quantity, slotMax);
quantity -= (newQ - oldQ);
}
if (quantity <= 0) {
break;
}
}
}
}
// add new slots if there is still something left
final int numSlotsNeeded;
if (slotMax > 0) {
numSlotsNeeded = (int) (Math.ceil(((double) quantity) / slotMax));
} else if (ii.isThrowingStar(itemid) || ii.isBullet(itemid)) {
numSlotsNeeded = 1;
} else {
numSlotsNeeded = 1;
log.error("SUCK ERROR - FIX ME! - 0 slotMax");
}
return !c.getPlayer().getInventory(type).isFull(numSlotsNeeded - 1);
} else {
return !c.getPlayer().getInventory(type).isFull();
}
}
public static boolean addById(
MapleClient c, int itemId, short quantity, String owner, int petid) {
if (quantity >= 4000 || quantity < 0) {
AutobanManager.getInstance()
.autoban(c.getPlayer().getClient(), "PE Item: " + quantity + "x " + itemId);
return false;
}
MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
MapleInventoryType type = ii.getInventoryType(itemId);
if (!type.equals(MapleInventoryType.EQUIP)) {
short slotMax = ii.getSlotMax(c, itemId);
List<IItem> existing = c.getPlayer().getInventory(type).listById(itemId);
if (!ii.isThrowingStar(itemId) && !ii.isBullet(itemId)) {
if (existing.size() > 0) { // first update all existing slots to slotMax
Iterator<IItem> i = existing.iterator();
while (quantity > 0) {
if (i.hasNext()) {
Item eItem = (Item) i.next();
short oldQ = eItem.getQuantity();
if (oldQ < slotMax && (eItem.getOwner().equals(owner) || owner == null)) {
short newQ = (short) Math.min(oldQ + quantity, slotMax);
quantity -= (newQ - oldQ);
eItem.setQuantity(newQ);
c.getSession().write(MaplePacketCreator.updateInventorySlot(type, eItem));
}
} else {
break;
}
}
}
// add new slots if there is still something left
while (quantity > 0 || ii.isThrowingStar(itemId) || ii.isBullet(itemId)) {
short newQ = (short) Math.min(quantity, slotMax);
if (newQ != 0) {
quantity -= newQ;
Item nItem = new Item(itemId, (byte) 0, newQ, petid);
byte newSlot = c.getPlayer().getInventory(type).addItem(nItem);
if (newSlot == -1) {
c.getSession().write(MaplePacketCreator.getInventoryFull());
c.getSession().write(MaplePacketCreator.getShowInventoryFull());
return false;
}
if (owner != null) {
nItem.setOwner(owner);
}
c.getSession().write(MaplePacketCreator.addInventorySlot(type, nItem));
if ((ii.isThrowingStar(itemId) || ii.isBullet(itemId)) && quantity == 0) {
break;
}
} else {
c.getSession().write(MaplePacketCreator.enableActions());
return false;
}
}
} else {
// Throwing Stars and Bullets - Add all into one slot regardless of quantity.
Item nItem = new Item(itemId, (byte) 0, quantity);
byte newSlot = c.getPlayer().getInventory(type).addItem(nItem);
if (newSlot == -1) {
c.getSession().write(MaplePacketCreator.getInventoryFull());
c.getSession().write(MaplePacketCreator.getShowInventoryFull());
return false;
}
c.getSession().write(MaplePacketCreator.addInventorySlot(type, nItem));
c.getSession().write(MaplePacketCreator.enableActions());
}
} else {
if (quantity == 1) {
IItem nEquip = ii.getEquipById(itemId);
if (owner != null) {
nEquip.setOwner(owner);
}
byte newSlot = c.getPlayer().getInventory(type).addItem(nEquip);
if (newSlot == -1) {
c.getSession().write(MaplePacketCreator.getInventoryFull());
c.getSession().write(MaplePacketCreator.getShowInventoryFull());
return false;
}
c.getSession().write(MaplePacketCreator.addInventorySlot(type, nEquip));
} else {
throw new InventoryException("Trying to create equip with non-one quantity");
}
}
return true;
}
public static boolean addFromDrop(MapleClient c, IItem item, boolean show, String owner) {
MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
MapleInventoryType type = ii.getInventoryType(item.getItemId());
if (!c.getChannelServer().allowMoreThanOne()
&& ii.isPickupRestricted(item.getItemId())
&& c.getPlayer().haveItem(item.getItemId(), 1, true, false)) {
c.getSession().write(MaplePacketCreator.getInventoryFull());
c.getSession().write(MaplePacketCreator.showItemUnavailable());
return false;
}
short quantity = item.getQuantity();
if (quantity >= 4000 || quantity < 0) {
AutobanManager.getInstance()
.autoban(c.getPlayer().getClient(), "PE Item: " + quantity + "x " + item.getItemId());
return false;
}
if (!type.equals(MapleInventoryType.EQUIP)) {
short slotMax = ii.getSlotMax(c, item.getItemId());
List<IItem> existing = c.getPlayer().getInventory(type).listById(item.getItemId());
if (!ii.isThrowingStar(item.getItemId()) && !ii.isBullet(item.getItemId())) {
if (existing.size() > 0) { // first update all existing slots to slotMax
Iterator<IItem> i = existing.iterator();
while (quantity > 0) {
if (i.hasNext()) {
Item eItem = (Item) i.next();
short oldQ = eItem.getQuantity();
if (oldQ < slotMax && item.getOwner().equals(eItem.getOwner())) {
short newQ = (short) Math.min(oldQ + quantity, slotMax);
quantity -= (newQ - oldQ);
eItem.setQuantity(newQ);
c.getSession().write(MaplePacketCreator.updateInventorySlot(type, eItem, true));
}
} else {
break;
}
}
}
// add new slots if there is still something left
while (quantity > 0
|| ii.isThrowingStar(item.getItemId())
|| ii.isBullet(item.getItemId())) {
short newQ = (short) Math.min(quantity, slotMax);
quantity -= newQ;
Item nItem = new Item(item.getItemId(), (byte) 0, newQ);
nItem.setOwner(item.getOwner());
byte newSlot = c.getPlayer().getInventory(type).addItem(nItem);
if (newSlot == -1) {
c.getSession().write(MaplePacketCreator.getInventoryFull());
c.getSession().write(MaplePacketCreator.getShowInventoryFull());
item.setQuantity((short) (quantity + newQ));
return false;
}
c.getSession().write(MaplePacketCreator.addInventorySlot(type, nItem, true));
}
} else {
// Throwing Stars and Bullets - Add all into one slot regardless of quantity.
Item nItem = new Item(item.getItemId(), (byte) 0, quantity);
byte newSlot = c.getPlayer().getInventory(type).addItem(nItem);
if (newSlot == -1) {
c.getSession().write(MaplePacketCreator.getInventoryFull());
c.getSession().write(MaplePacketCreator.getShowInventoryFull());
return false;
}
c.getSession().write(MaplePacketCreator.addInventorySlot(type, nItem));
c.getSession().write(MaplePacketCreator.enableActions());
}
} else {
if (quantity == 1) {
byte newSlot = c.getPlayer().getInventory(type).addItem(item);
if (newSlot == -1) {
c.getSession().write(MaplePacketCreator.getInventoryFull());
c.getSession().write(MaplePacketCreator.getShowInventoryFull());
return false;
}
c.getSession().write(MaplePacketCreator.addInventorySlot(type, item, true));
} else {
throw new RuntimeException("Trying to create equip with non-one quantity");
}
}
if (owner != null) {
item.setOwner(owner);
}
if (show) {
c.getSession()
.write(MaplePacketCreator.getShowItemGain(item.getItemId(), item.getQuantity()));
}
return true;
}
public static boolean addById(MapleClient c, int Id, short quantity, String owner, int petid) {
final MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
final MapleInventoryType type = ii.getInventoryType(Id);
if (!type.equals(MapleInventoryType.EQUIP)) {
final short slotMax = ii.getSlotMax(c, Id);
final List<IItem> existing = c.getPlayer().getInventory(type).listById(Id);
if (!InventoryConstants.isRechargable(Id)) {
if (existing.size() > 0) { // first update all existing slots to slotMax
Iterator<IItem> i = existing.iterator();
while (quantity > 0) {
if (i.hasNext()) {
Item eItem = (Item) i.next();
short oldQ = eItem.getQuantity();
if (oldQ < slotMax && (eItem.getOwner().equals(owner) || owner == null)) {
short newQ = (short) Math.min(oldQ + quantity, slotMax);
quantity -= (newQ - oldQ);
eItem.setQuantity(newQ);
c.announce(InventoryFactory.updateInventorySlot(type, eItem));
}
} else {
break;
}
}
}
while (quantity > 0 || InventoryConstants.isRechargable(Id)) {
short newQ = (short) Math.min(quantity, slotMax);
if (newQ != 0) {
quantity -= newQ;
Item nItem = new Item(Id, (short) 0, newQ, petid);
short newSlot = c.getPlayer().getInventory(type).addItem(nItem);
if (newSlot == -1) {
c.announce(InventoryFactory.getInventoryFull());
c.announce(InventoryFactory.getShowInventoryFull());
return false;
}
if (owner != null) {
nItem.setOwner(owner);
}
c.announce(InventoryFactory.addInventorySlot(type, nItem));
if ((InventoryConstants.isRechargable(Id)) && quantity == 0) {
break;
}
} else {
c.announce(IntraPersonalFactory.enableActions());
return false;
}
}
} else {
final Item nItem = new Item(Id, (short) 0, quantity);
final short newSlot = c.getPlayer().getInventory(type).addItem(nItem);
if (newSlot == -1) {
c.announce(InventoryFactory.getInventoryFull());
c.announce(InventoryFactory.getShowInventoryFull());
return false;
}
c.announce(InventoryFactory.addInventorySlot(type, nItem));
c.announce(IntraPersonalFactory.enableActions());
}
} else if (quantity == 1) {
IItem nEquip = ii.getEquipById(Id);
if (owner != null) {
nEquip.setOwner(owner);
}
short newSlot = c.getPlayer().getInventory(type).addItem(nEquip);
if (newSlot == -1) {
c.announce(InventoryFactory.getInventoryFull());
c.announce(InventoryFactory.getShowInventoryFull());
return false;
}
c.announce(InventoryFactory.addInventorySlot(type, nEquip));
} else {
throw new RuntimeException("Trying to create equip with non-one quantity");
}
return true;
}
public static boolean addFromDrop(
final MapleClient c, final IItem item, final boolean show, final boolean showAnyMessage) {
final MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
if (ii.isPickupRestricted(item.getId())
&& c.getPlayer().getItemQuantity(item.getId(), true) > 0
&& showAnyMessage) {
c.announce(InventoryFactory.getInventoryFull());
c.announce(InventoryFactory.showItemUnavailable());
return false;
}
final MapleInventoryType type = ii.getInventoryType(item.getId());
short quantity = item.getQuantity();
if (!type.equals(MapleInventoryType.EQUIP)) {
final short slotMax = ii.getSlotMax(c, item.getId());
final List<IItem> existing = c.getPlayer().getInventory(type).listById(item.getId());
if (!InventoryConstants.isRechargable(item.getId())) {
if (existing.size() > 0) { // first update all existing slots to slotMax
Iterator<IItem> i = existing.iterator();
while (quantity > 0) {
if (i.hasNext()) {
final Item eItem = (Item) i.next();
final short oldQ = eItem.getQuantity();
if (oldQ < slotMax && item.getOwner().equals(eItem.getOwner())) {
short newQ = (short) Math.min(oldQ + quantity, slotMax);
quantity -= (newQ - oldQ);
eItem.setQuantity(newQ);
short newQi = (short) Math.min(quantity, slotMax);
quantity -= newQi;
Item nItem = new Item(item.getId(), (short) 0, newQi);
nItem.setOwner(item.getOwner());
if (c.getPlayer().getInventory(type).fakeAddItem(nItem) == -1) {
eItem.setQuantity(oldQ);
return false;
}
quantity += newQi;
c.announce(InventoryFactory.updateInventorySlot(type, eItem, showAnyMessage));
}
} else {
break;
}
}
}
while (quantity > 0 || InventoryConstants.isRechargable(item.getId())) {
final short newQ = (short) Math.min(quantity, slotMax);
quantity -= newQ;
final Item nItem = new Item(item.getId(), (short) 0, newQ);
nItem.setOwner(item.getOwner());
final short newSlot = c.getPlayer().getInventory(type).addItem(nItem);
if (newSlot == -1) {
if (showAnyMessage) {
c.announce(InventoryFactory.getInventoryFull());
c.announce(InventoryFactory.getShowInventoryFull());
}
item.setQuantity((short) (quantity + newQ));
return false;
}
c.announce(InventoryFactory.addInventorySlot(type, nItem, true));
if ((InventoryConstants.isRechargable(item.getId())) && quantity == 0) {
break;
}
}
} else {
final Item nItem = new Item(item.getId(), (short) 0, quantity);
final short newSlot = c.getPlayer().getInventory(type).addItem(nItem);
if (newSlot == -1) {
if (showAnyMessage) {
c.announce(InventoryFactory.getInventoryFull());
c.announce(InventoryFactory.getShowInventoryFull());
}
return false;
}
c.announce(InventoryFactory.addInventorySlot(type, nItem));
c.announce(IntraPersonalFactory.enableActions());
}
} else if (quantity == 1) {
final short newSlot = c.getPlayer().getInventory(type).addItem(item);
if (newSlot == -1) {
if (showAnyMessage) {
c.announce(InventoryFactory.getInventoryFull());
c.announce(InventoryFactory.getShowInventoryFull());
}
return false;
}
c.announce(InventoryFactory.addInventorySlot(type, item, true));
} else {
return false;
}
if (show) {
c.announce(EffectFactory.getShowItemGain(item.getId(), item.getQuantity()));
}
return true;
}
