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 void move(byte sSlot, byte dSlot, short slotMax) {
Item source = (Item) inventory.get(sSlot);
Item target = (Item) inventory.get(dSlot);
if (source == null) {
throw new RuntimeException("Trying to move empty slot");
}
if (target == null) {
source.setPosition(dSlot);
inventory.put(dSlot, source);
inventory.remove(sSlot);
} else if (target.getItemId() == source.getItemId()
&& !InventoryConstants.isRechargable(source.getItemId())) {
if (type.getType() == MapleInventoryType.EQUIP.getType()) {
swap(target, source);
}
if (source.getQuantity() + target.getQuantity() > slotMax) {
short rest = (short) ((source.getQuantity() + target.getQuantity()) - slotMax);
source.setQuantity(rest);
target.setQuantity(slotMax);
} else {
target.setQuantity((short) (source.getQuantity() + target.getQuantity()));
inventory.remove(sSlot);
}
} else {
swap(target, source);
}
}
public static void drop(MapleClient c, MapleInventoryType type, short src, short quantity) {
if (src < 0) {
type = MapleInventoryType.EQUIPPED;
}
IItem source = c.getPlayer().getInventory(type).getItem(src);
int Id = source.getId();
if (c.getPlayer().getItemEffect() == Id && source.getQuantity() == 1) {
c.getPlayer().setItemEffect(0);
c.getPlayer().getMap().broadcastMessage(EffectFactory.itemEffect(c.getPlayer().getId(), 0));
} else if (Id == 5370000 || Id == 5370001) { // not actually possible
if (c.getPlayer().getItemQuantity(Id, false) == 1) {
c.getPlayer().setChalkboard(null);
}
} else if ((Id >= 5000000 && Id <= 5000100) || Id == 4031284) {
c.getPlayer().dropMessage("This item may not be dropped.");
return;
}
if (c.getPlayer().getItemQuantity(Id, true) < quantity
|| quantity < 0
|| source == null
|| source.getFlag() == InventoryConstants.LOCK
|| (quantity == 0 && !InventoryConstants.isRechargable(Id))) {
return;
}
Point dropPos = new Point(c.getPlayer().getPosition());
if (quantity < source.getQuantity() && !InventoryConstants.isRechargable(Id)) {
IItem target = source.copy();
target.setQuantity(quantity);
source.setQuantity((short) (source.getQuantity() - quantity));
c.announce(InventoryFactory.dropInventoryItemUpdate(type, source));
dropItem(c, target, dropPos);
} else {
c.getPlayer().getInventory(type).removeSlot(src);
c.announce(
InventoryFactory.dropInventoryItem((src < 0 ? MapleInventoryType.EQUIP : type), src));
if (src < 0) {
c.getPlayer().equipChanged();
}
dropItem(c, source, dropPos);
}
}
public static void removeFromSlot(
final MapleClient c,
final MapleInventoryType type,
final short slot,
final short quantity,
final boolean fromDrop,
final boolean consume) {
final IItem item = c.getPlayer().getInventory(type).getItem(slot);
final boolean allowZero = consume && InventoryConstants.isRechargable(item.getId());
c.getPlayer().getInventory(type).removeItem(slot, quantity, allowZero);
if (item.getQuantity() == 0 && !allowZero) {
c.announce(InventoryFactory.clearInventoryItem(type, item.getPosition(), fromDrop));
} else {
c.announce(InventoryFactory.updateInventorySlot(type, (Item) item, fromDrop));
}
}
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 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;
}
public final void handlePacket(SeekableLittleEndianAccessor slea, MapleClient c) {
c.getPlayer().resetAfkTime();
byte operation = slea.readByte();
if (operation == Actions.TOSERVER_SEND_ITEM.getCode()) {
final int fee = 5000;
byte inventId = slea.readByte();
short itemPos = slea.readShort();
short amount = slea.readShort();
int mesos = slea.readInt();
String recipient = slea.readMapleAsciiString();
if (amount < 0 || amount > 2000 || itemPos < 0 || inventId > 5 || inventId < 0) {
return;
}
if (mesos < 0
|| (long) mesos > Integer.MAX_VALUE
|| ((long) mesos + fee + getFee(mesos)) > Integer.MAX_VALUE) {
return;
}
int finalcost = mesos + fee + getFee(mesos);
boolean send = false;
if (c.getPlayer().getMeso() >= finalcost) {
int accid = getAccIdFromCNAME(recipient, true);
if (accid != -1) {
if (accid != c.getAccID()) {
c.getPlayer().gainMeso(-finalcost, false);
c.getSession()
.write(
MaplePacketCreator.sendDueyMSG(Actions.TOCLIENT_SUCCESSFULLY_SENT.getCode()));
send = true;
} else {
c.getSession()
.write(MaplePacketCreator.sendDueyMSG(Actions.TOCLIENT_SAMEACC_ERROR.getCode()));
}
} else {
c.getSession()
.write(
MaplePacketCreator.sendDueyMSG(Actions.TOCLIENT_NAME_DOES_NOT_EXIST.getCode()));
}
} else {
c.getSession()
.write(MaplePacketCreator.sendDueyMSG(Actions.TOCLIENT_NOT_ENOUGH_MESOS.getCode()));
}
boolean recipientOn = false;
MapleClient rClient = null;
try {
int channel = c.getChannelServer().getWorldInterface().find(recipient);
if (channel > -1) {
recipientOn = true;
ChannelServer rcserv = ChannelServer.getInstance(channel);
rClient = rcserv.getPlayerStorage().getCharacterByName(recipient).getClient();
}
} catch (RemoteException re) {
c.getChannelServer().reconnectWorld();
}
if (send) {
if (inventId > 0) {
MapleInventoryType inv = MapleInventoryType.getByType(inventId);
IItem item = c.getPlayer().getInventory(inv).getItem((byte) itemPos);
if (item != null && c.getPlayer().getItemQuantity(item.getItemId(), false) > amount) {
if (InventoryConstants.isRechargable(item.getItemId())) {
MapleInventoryManipulator.removeFromSlot(
c, inv, (byte) itemPos, item.getQuantity(), true);
} else {
MapleInventoryManipulator.removeFromSlot(c, inv, (byte) itemPos, amount, true, false);
}
addItemToDB(
item, amount, mesos, c.getPlayer().getName(), getAccIdFromCNAME(recipient, false));
} else {
return;
}
} else {
addMesoToDB(mesos, c.getPlayer().getName(), getAccIdFromCNAME(recipient, false));
}
if (recipientOn && rClient != null) {
rClient
.getSession()
.write(MaplePacketCreator.sendDueyMSG(Actions.TOCLIENT_PACKAGE_MSG.getCode()));
}
c.getPlayer().gainMeso(-fee, false);
}
} else if (operation == Actions.TOSERVER_REMOVE_PACKAGE.getCode()) {
int packageid = slea.readInt();
removeItemFromDB(packageid);
c.getSession().write(MaplePacketCreator.removeItemFromDuey(true, packageid));
} else if (operation == Actions.TOSERVER_CLAIM_PACKAGE.getCode()) {
int packageid = slea.readInt();
List<DueyPackages> packages = new LinkedList<DueyPackages>();
DueyPackages dp = null;
Connection con = DatabaseConnection.getConnection();
try {
PreparedStatement ps =
con.prepareStatement(
"SELECT * FROM dueypackages LEFT JOIN dueyitems USING (PackageId) WHERE PackageId = ?"); // PLEASE WORK D:
ps.setInt(1, packageid);
ResultSet rs = ps.executeQuery();
DueyPackages dueypack = null;
if (rs.next()) {
dueypack = getItemByPID(rs);
dueypack.setSender(rs.getString("SenderName"));
dueypack.setMesos(rs.getInt("Mesos"));
dueypack.setSentTime(rs.getString("TimeStamp"));
packages.add(dueypack);
}
rs.close();
ps.close();
dp = dueypack;
} catch (SQLException e) {
}
if (dp.getItem() != null) {
if (!MapleInventoryManipulator.checkSpace(
c, dp.getItem().getItemId(), dp.getItem().getQuantity(), dp.getItem().getOwner())) {
c.getPlayer().dropMessage(1, "Your inventory is full");
c.getSession().write(MaplePacketCreator.enableActions());
return;
} else {
MapleInventoryManipulator.addFromDrop(c, dp.getItem(), false);
}
}
int gainmesos = 0;
long totalmesos = (long) dp.getMesos() + (long) c.getPlayer().getMeso();
if (totalmesos >= Integer.MAX_VALUE) {
gainmesos = 2147383647 - c.getPlayer().getMeso();
} else if (totalmesos < 0 || dp.getMesos() < 0) {
// do nothing
} else {
c.getPlayer().gainMeso(gainmesos, false);
}
removeItemFromDB(packageid);
c.getSession().write(MaplePacketCreator.removeItemFromDuey(false, packageid));
}
}
