content: /*
   This file is part of the OdinMS Maple Story Server
   Copyright (C) 2008 Patrick Huy <patrick.huy@frz.cc>
   Matthias Butz <matze@odinms.de>
   Jan Christian Meyer <vimes@odinms.de>
  
   This program is free software: you can redistribute it and/or modify
   it under the terms of the GNU Affero General Public License as
   published by the Free Software Foundation version 3 as published by
   the Free Software Foundation. You may not use, modify or distribute
   this program under any other version of the GNU Affero General Public
   License.
  
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU Affero General Public License for more details.
  
   You should have received a copy of the GNU Affero General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
  package net.server.channel.handlers;
  
  import client.MapleCharacter;
  import client.MapleClient;
  import client.Skill;
  import client.SkillFactory;
  import client.SkillMacro;
  import client.creator.veteran.*;
  import client.inventory.Equip;
  import client.inventory.Equip.ScrollResult;
  import client.inventory.Item;
  import client.inventory.MapleInventory;
  import client.inventory.MapleInventoryType;
  import client.inventory.MaplePet;
  import client.inventory.ModifyInventory;
  import client.inventory.manipulator.MapleInventoryManipulator;
  import client.inventory.manipulator.MapleKarmaManipulator;
  import client.processor.stat.AssignAPProcessor;
  import client.processor.stat.AssignSPProcessor;
  import client.processor.npc.DueyProcessor;
  import config.YamlConfig;
  import constants.game.GameConstants;
  import constants.inventory.ItemConstants;
  
  import java.sql.SQLException;
  import java.util.ArrayList;
  import java.util.LinkedList;
  import java.util.List;
  
  import net.AbstractMaplePacketHandler;
  import net.server.Server;
  import server.MapleItemInformationProvider;
  import server.MapleShop;
  import server.MapleShopFactory;
  import server.TimerManager;
  import server.maps.AbstractMapleMapObject;
  import server.maps.FieldLimit;
  import server.maps.MaplePlayerShopItem;
  import server.maps.MapleKite;
  import server.maps.MapleMap;
  import server.maps.MapleTVEffect;
  import tools.MaplePacketCreator;
  import tools.Pair;
  import tools.data.input.SeekableLittleEndianAccessor;
  
  public final class UseCashItemHandler extends AbstractMaplePacketHandler {
  
      @Override
      public final void handlePacket(SeekableLittleEndianAccessor slea, MapleClient c) {
          final MapleCharacter player = c.getPlayer();
          
          long timeNow = currentServerTime();
          if (timeNow - player.getLastUsedCashItem() < 3000) {
              player.dropMessage(1, "You have used a cash item recently. Wait a moment, then try again.");
              c.announce(MaplePacketCreator.enableActions());
              return;
          }
          player.setLastUsedCashItem(timeNow);
          
          MapleItemInformationProvider ii = MapleItemInformationProvider.getInstance();
          short position = slea.readShort();
          int itemId = slea.readInt();
          int itemType = itemId / 10000;
          
          MapleInventory cashInv = player.getInventory(MapleInventoryType.CASH);
          Item toUse = cashInv.getItem(position);
          if (toUse == null || toUse.getItemId() != itemId) {
              toUse = cashInv.findById(itemId);
              
              if (toUse == null) {
                  c.announce(MaplePacketCreator.enableActions());
                  return;
              }
              
              position = toUse.getPosition();
          }
          
          if (toUse.getQuantity() < 1) {
              c.announce(MaplePacketCreator.enableActions());
              return;
          }
          
          String medal = "";
          Item medalItem = player.getInventory(MapleInventoryType.EQUIPPED).getItem((short) -49);
          if (medalItem != null) {
              medal = "<" + ii.getName(medalItem.getItemId()) + "> ";
          }
          
          if (itemType == 504) { // vip teleport rock
              String error1 = "Either the player could not be found or you were trying to teleport to an illegal location.";
              boolean vip = slea.readByte() == 1 && itemId / 1000 >= 5041;
              remove(c, position, itemId);
              boolean success = false;
              if (!vip) {
                  int mapId = slea.readInt();
                  if (itemId / 1000 >= 5041 || mapId / 100000000 == player.getMapId() / 100000000) { //check vip or same continent
                      MapleMap targetMap = c.getChannelServer().getMapFactory().getMap(mapId);
                      if (!FieldLimit.CANNOTVIPROCK.check(targetMap.getFieldLimit()) && (targetMap.getForcedReturnId() == 999999999 || mapId < 100000000)) {
                          player.forceChangeMap(targetMap, targetMap.getRandomPlayerSpawnpoint());
                          success = true;
                      } else {
                          player.dropMessage(1, error1);
                      }
                  } else {
                      player.dropMessage(1, "You cannot teleport between continents with this teleport rock.");
                  }
              } else {
                  String name = slea.readMapleAsciiString();
                  MapleCharacter victim = c.getChannelServer().getPlayerStorage().getCharacterByName(name);
                  
                  if (victim != null) {
                      MapleMap targetMap = victim.getMap();
                      if (!FieldLimit.CANNOTVIPROCK.check(targetMap.getFieldLimit()) && (targetMap.getForcedReturnId() == 999999999 || targetMap.getId() < 100000000)) {
                          if (!victim.isGM() || victim.gmLevel() <= player.gmLevel()) {   // thanks Yoboes for noticing non-GM's being unreachable through rocks
                              player.forceChangeMap(targetMap, targetMap.findClosestPlayerSpawnpoint(victim.getPosition()));
                              success = true;
                          } else {
                              player.dropMessage(1, error1);
                          }
                      } else {
                          player.dropMessage(1, "You cannot teleport to this map.");
                      }
                  } else {
                      player.dropMessage(1, "Player could not be found in this channel.");
                  }
              }
              
              if (!success) {
                  MapleInventoryManipulator.addById(c, itemId, (short) 1);
                  c.announce(MaplePacketCreator.enableActions());
              }
          } else if (itemType == 505) { // AP/SP reset
              if(!player.isAlive()) {
                  c.announce(MaplePacketCreator.enableActions());
                  return;
              }
              
              if (itemId > 5050000) {
                  int SPTo = slea.readInt();
                  if (!AssignSPProcessor.canSPAssign(c, SPTo)) {  // exploit found thanks to Arnah
                      return;
                  }
                  
                  int SPFrom = slea.readInt();
                  Skill skillSPTo = SkillFactory.getSkill(SPTo);
                  Skill skillSPFrom = SkillFactory.getSkill(SPFrom);
                  byte curLevel = player.getSkillLevel(skillSPTo);
                  byte curLevelSPFrom = player.getSkillLevel(skillSPFrom);
                  if ((curLevel < skillSPTo.getMaxLevel()) && curLevelSPFrom > 0) {
                      player.changeSkillLevel(skillSPFrom, (byte) (curLevelSPFrom - 1), player.getMasterLevel(skillSPFrom), -1);
                      player.changeSkillLevel(skillSPTo, (byte) (curLevel + 1), player.getMasterLevel(skillSPTo), -1);
                      
                      // update macros, thanks to Arnah
                      if((curLevelSPFrom - 1) == 0){
                          boolean updated = false;
                          for(SkillMacro macro : player.getMacros()){
                              if(macro == null) continue;
                              
                              boolean update = false;// cleaner?
                              if(macro.getSkill1() == SPFrom){
                                  update = true;
                                  macro.setSkill1(0);
                              }
                              if(macro.getSkill2() == SPFrom){
                                  update = true;
                                  macro.setSkill2(0);
                              }
                              if(macro.getSkill3() == SPFrom){
                                  update = true;
                                  macro.setSkill3(0);
                              }
                              if(update){
                                  updated = true;
                                  player.updateMacros(macro.getPosition(), macro);
                              }
                          }
                          if(updated) player.sendMacros();
                      }
                  }
              } else {
                  int APTo = slea.readInt();
                  int APFrom = slea.readInt();
                  
                  if(!AssignAPProcessor.APResetAction(c, APFrom, APTo)) {
                      return;
                  }
              }
              remove(c, position, itemId);
          } else if (itemType == 506) {
              Item eq = null;
              if (itemId == 5060000) { // Item tag.
                  int equipSlot = slea.readShort();
                  if (equipSlot == 0) {
                      return;
                  }
                  eq = player.getInventory(MapleInventoryType.EQUIPPED).getItem((short) equipSlot);
                  eq.setOwner(player.getName());
              } else if (itemId == 5060001 || itemId == 5061000 || itemId == 5061001 || itemId == 5061002 || itemId == 5061003) { // Sealing lock
                  MapleInventoryType type = MapleInventoryType.getByType((byte) slea.readInt());
                  eq = player.getInventory(type).getItem((short) slea.readInt());
                  if (eq == null) { //Check if the type is EQUIPMENT?
                      return;
                  }
                  short flag = eq.getFlag();
                  flag |= ItemConstants.LOCK;
                  if (eq.getExpiration() > -1) {
                      return; //No perma items pls
                  }
                  eq.setFlag(flag);
  
                  long period = 0;
                  if (itemId == 5061000) {
                      period = 7;
                  } else if (itemId == 5061001) {
                      period = 30;
                  } else if (itemId == 5061002) {
                      period = 90;
                  } else if (itemId == 5061003) {
                      period = 365;
                  }
  
                  if (period > 0) {
                      eq.setExpiration(currentServerTime() + (period * 60 * 60 * 24 * 1000));
                  }
  
                  // double-remove found thanks to BHB
              } else if (itemId == 5060002) { // Incubator
                  byte inventory2 = (byte) slea.readInt();
                  short slot2 = (short) slea.readInt();
                  Item item2 = player.getInventory(MapleInventoryType.getByType(inventory2)).getItem(slot2);
                  if (item2 == null) // hacking
                  {
                      return;
                  }
                  if (getIncubatedItem(c, itemId)) {
                      MapleInventoryManipulator.removeFromSlot(c, MapleInventoryType.getByType(inventory2), slot2, (short) 1, false);
                      remove(c, position, itemId);
                  }
                  return;
              }
              slea.readInt(); // time stamp
              if (eq != null) {
                  player.forceUpdateItem(eq);
                  remove(c, position, itemId);
              }
          } else if (itemType == 507) {
              boolean whisper;
              switch ((itemId / 1000) % 10) {
                  case 1: // Megaphone
                      if (player.getLevel() > 9) {
                          player.getClient().getChannelServer().broadcastPacket(MaplePacketCreator.serverNotice(2, medal + player.getName() + " : " + slea.readMapleAsciiString()));
                      } else {
                          player.dropMessage(1, "You may not use this until you're level 10.");
                          return;
                      }
                      break;
                  case 2: // Super megaphone
                      Server.getInstance().broadcastMessage(c.getWorld(), MaplePacketCreator.serverNotice(3, c.getChannel(), medal + player.getName() + " : " + slea.readMapleAsciiString(), (slea.readByte() != 0)));
                      break;
                  case 5: // Maple TV
                      int tvType = itemId % 10;
                      boolean megassenger = false;
                      boolean ear = false;
                      MapleCharacter victim = null;
                      if (tvType != 1) {
                          if (tvType >= 3) {
                              megassenger = true;
                              if (tvType == 3) {
                                  slea.readByte();
                              }
                              ear = 1 == slea.readByte();
                          } else if (tvType != 2) {
                              slea.readByte();
                          }
                          if (tvType != 4) {
                              victim = c.getChannelServer().getPlayerStorage().getCharacterByName(slea.readMapleAsciiString());
                          }
                      }
                      List<String> messages = new LinkedList<>();
                      StringBuilder builder = new StringBuilder();
                      for (int i = 0; i < 5; i++) {
                          String message = slea.readMapleAsciiString();
                          if (megassenger) {
                              builder.append(" ").append(message);
                          }
                          messages.add(message);
                      }
                      slea.readInt();
                      
                      if (!MapleTVEffect.broadcastMapleTVIfNotActive(player, victim, messages, tvType)) {
                          player.dropMessage(1, "MapleTV is already in use.");
                          return;
                      }
                      
                      if (megassenger) {
                          Server.getInstance().broadcastMessage(c.getWorld(), MaplePacketCreator.serverNotice(3, c.getChannel(), medal + player.getName() + " : " + builder.toString(), ear));
                      }
                      
                      break;
                  case 6: //item megaphone
                      String msg = medal + player.getName() + " : " + slea.readMapleAsciiString();
                      whisper = slea.readByte() == 1;
                      Item item = null;
                      if (slea.readByte() == 1) { //item
                          item = player.getInventory(MapleInventoryType.getByType((byte) slea.readInt())).getItem((short) slea.readInt());
                          if (item == null) //hack
                          {
                              return;
                          }
                          
                          // thanks Conrad for noticing that untradeable items should be allowed in megas
                      }
                      Server.getInstance().broadcastMessage(c.getWorld(), MaplePacketCreator.itemMegaphone(msg, whisper, c.getChannel(), item));
                      break;
                  case 7: //triple megaphone
                      int lines = slea.readByte();
                      if (lines < 1 || lines > 3) //hack
                      {
                          return;
                      }
                      String[] msg2 = new String[lines];
                      for (int i = 0; i < lines; i++) {
                          msg2[i] = medal + player.getName() + " : " + slea.readMapleAsciiString();
                      }
                      whisper = slea.readByte() == 1;
                      Server.getInstance().broadcastMessage(c.getWorld(), MaplePacketCreator.getMultiMegaphone(msg2, c.getChannel(), whisper));
                      break;
              }
              remove(c, position, itemId);
          } else if (itemType == 508) {   // thanks tmskdl12 for graduation banner; thanks ratency for first pointing lack of Kite handling
              MapleKite kite = new MapleKite(player, slea.readMapleAsciiString(), itemId);
              
              if (!GameConstants.isFreeMarketRoom(player.getMapId())) {
                  player.getMap().spawnKite(kite);
                  remove(c, position, itemId);
              } else {
                  c.announce(MaplePacketCreator.sendCannotSpawnKite());
              }
          } else if (itemType == 509) {
              String sendTo = slea.readMapleAsciiString();
              String msg = slea.readMapleAsciiString();
              try {
                  player.sendNote(sendTo, msg, (byte) 0);
              } catch (SQLException e) {
                  e.printStackTrace();
              }
              remove(c, position, itemId);
          } else if (itemType == 510) {
              player.getMap().broadcastMessage(MaplePacketCreator.musicChange("Jukebox/Congratulation"));
              remove(c, position, itemId);
          } else if (itemType == 512) {
              if (ii.getStateChangeItem(itemId) != 0) {
                  for (MapleCharacter mChar : player.getMap().getCharacters()) {
                      ii.getItemEffect(ii.getStateChangeItem(itemId)).applyTo(mChar);
                  }
              }
              player.getMap().startMapEffect(ii.getMsg(itemId).replaceFirst("%s", player.getName()).replaceFirst("%s", slea.readMapleAsciiString()), itemId);
              remove(c, position, itemId);
          } else if (itemType == 517) {
              MaplePet pet = player.getPet(0);
              if (pet == null) {
                  c.announce(MaplePacketCreator.enableActions());
                  return;
              }
              String newName = slea.readMapleAsciiString();
              pet.setName(newName);
              pet.saveToDb();
              
              Item item = player.getInventory(MapleInventoryType.CASH).getItem(pet.getPosition());
              if (item != null)
                  player.forceUpdateItem(item);
              
              player.getMap().broadcastMessage(player, MaplePacketCreator.changePetName(player, newName, 1), true);
              c.announce(MaplePacketCreator.enableActions());
              remove(c, position, itemId);
          } else if (itemType == 520) {
              player.gainMeso(ii.getMeso(itemId), true, false, true);
              remove(c, position, itemId);
              c.announce(MaplePacketCreator.enableActions());
          } else if (itemType == 523) {
              int itemid = slea.readInt();
              
              if(!YamlConfig.config.server.USE_ENFORCE_ITEM_SUGGESTION) c.getWorldServer().addOwlItemSearch(itemid);
              player.setOwlSearch(itemid);
              List<Pair<MaplePlayerShopItem, AbstractMapleMapObject>> hmsAvailable = c.getWorldServer().getAvailableItemBundles(itemid);
              if(!hmsAvailable.isEmpty()) remove(c, position, itemId);
              
              c.announce(MaplePacketCreator.owlOfMinerva(c, itemid, hmsAvailable));
              c.announce(MaplePacketCreator.enableActions());
              
          } else if (itemType == 524) {
              for (byte i = 0; i < 3; i++) {
                  MaplePet pet = player.getPet(i);
                  if (pet != null) {
                      Pair<Integer, Boolean> p = pet.canConsume(itemId);
                      
                      if (p.getRight()) {
                          pet.gainClosenessFullness(player, p.getLeft(), 100, 1);
                          remove(c, position, itemId);
                          break;
                      }
                  } else {
                      break;
                  }
              }
              c.announce(MaplePacketCreator.enableActions());
          } else if (itemType == 530) {
              ii.getItemEffect(itemId).applyTo(player);
              remove(c, position, itemId);
          } else if (itemType == 533) {
              DueyProcessor.dueySendTalk(c, true);
          } else if (itemType == 537) {
              if (GameConstants.isFreeMarketRoom(player.getMapId())) {
                  player.dropMessage(5, "You cannot use the chalkboard here.");
                  player.getClient().announce(MaplePacketCreator.enableActions());
                  return;
              }
              
              player.setChalkboard(slea.readMapleAsciiString());
              player.getMap().broadcastMessage(MaplePacketCreator.useChalkboard(player, false));
              player.getClient().announce(MaplePacketCreator.enableActions());
              //remove(c, position, itemId);  thanks Conrad for noticing chalkboards shouldn't be depleted upon use
          } else if (itemType == 539) {
              List<String> strLines = new LinkedList<>();
              for (int i = 0; i < 4; i++) {
                  strLines.add(slea.readMapleAsciiString());
              }
              
              final int world = c.getWorld();
              Server.getInstance().broadcastMessage(world, MaplePacketCreator.getAvatarMega(player, medal, c.getChannel(), itemId, strLines, (slea.readByte() != 0)));
              TimerManager.getInstance().schedule(new Runnable() {
              	@Override
              	public void run() {
              		Server.getInstance().broadcastMessage(world, MaplePacketCreator.byeAvatarMega());
              	}
              }, 1000 * 10);
              remove(c, position, itemId);
          } else if (itemType == 540) {
              slea.readByte();
              slea.readInt();
              if(itemId == 5400000) { //name change
                  c.announce(MaplePacketCreator.showNameChangeCancel(player.cancelPendingNameChange()));
              } else if(itemId == 5401000) { //world transfer
                  c.announce(MaplePacketCreator.showWorldTransferCancel(player.cancelPendingWorldTranfer()));
              }
              remove(c, position, itemId);
              c.announce(MaplePacketCreator.enableActions());
          } else if (itemType == 543) {
              if(itemId == 5432000 && !c.gainCharacterSlot()) {
                  player.dropMessage(1, "You have already used up all 12 extra character slots.");
                  c.announce(MaplePacketCreator.enableActions());
                  return;
              }
              
              String name = slea.readMapleAsciiString();
              int face = slea.readInt();
              int hair = slea.readInt();
              int haircolor = slea.readInt();
              int skin = slea.readInt();
              int gender = slea.readInt();
              int jobid = slea.readInt();
              int improveSp = slea.readInt();
              
              int createStatus;
              switch(jobid) {
                  case 0:
                      createStatus = WarriorCreator.createCharacter(c, name, face, hair + haircolor, skin, gender, improveSp);
                      break;
                      
                  case 1:
                      createStatus = MagicianCreator.createCharacter(c, name, face, hair + haircolor, skin, gender, improveSp);
                      break;
                      
                  case 2:
                      createStatus = BowmanCreator.createCharacter(c, name, face, hair + haircolor, skin, gender, improveSp);
                      break;
                      
                  case 3:
                      createStatus = ThiefCreator.createCharacter(c, name, face, hair + haircolor, skin, gender, improveSp);
                      break;
                      
                  default:
                      createStatus = PirateCreator.createCharacter(c, name, face, hair + haircolor, skin, gender, improveSp);
              }
              
              if(createStatus == 0) {
                  c.announce(MaplePacketCreator.sendMapleLifeError(0));   // success!
                  
                  player.showHint("#bSuccess#k on creation of the new character through the Maple Life card.");
                  remove(c, position, itemId);
              } else {
                  if(createStatus == -1) {    // check name
                      c.announce(MaplePacketCreator.sendMapleLifeNameError());
                  } else {
                      c.announce(MaplePacketCreator.sendMapleLifeError(-1 * createStatus));
                  }
              }
          } else if (itemType == 545) { // MiuMiu's travel store
              if (player.getShop() == null) {
                  MapleShop shop = MapleShopFactory.getInstance().getShop(1338);
                  if (shop != null) {
                      shop.sendShop(c);
                      remove(c, position, itemId);
                  }
              } else {
                  c.announce(MaplePacketCreator.enableActions());
              }
          } else if (itemType == 550) { //Extend item expiration
              c.announce(MaplePacketCreator.enableActions());
          } else if (itemType == 552) {
              MapleInventoryType type = MapleInventoryType.getByType((byte) slea.readInt());
              short slot = (short) slea.readInt();
              Item item = player.getInventory(type).getItem(slot);
              if (item == null || item.getQuantity() <= 0 || MapleKarmaManipulator.hasKarmaFlag(item) || !ii.isKarmaAble(item.getItemId())) {
                  c.announce(MaplePacketCreator.enableActions());
                  return;
              }
              
              MapleKarmaManipulator.setKarmaFlag(item);
              player.forceUpdateItem(item);
              remove(c, position, itemId);
              c.announce(MaplePacketCreator.enableActions());
          } else if (itemType == 552) { //DS EGG THING
              c.announce(MaplePacketCreator.enableActions());
          } else if (itemType == 557) {
              slea.readInt();
              int itemSlot = slea.readInt();
              slea.readInt();
              final Equip equip = (Equip) player.getInventory(MapleInventoryType.EQUIP).getItem((short) itemSlot);
              if (equip.getVicious() >= 2 || player.getInventory(MapleInventoryType.CASH).findById(5570000) == null) {
                  return;
              }
              equip.setVicious(equip.getVicious() + 1);
              equip.setUpgradeSlots(equip.getUpgradeSlots() + 1);
              remove(c, position, itemId);
              c.announce(MaplePacketCreator.enableActions());
              c.announce(MaplePacketCreator.sendHammerData(equip.getVicious()));
              player.forceUpdateItem(equip);
          } else if (itemType == 561) { //VEGA'S SPELL
              if (slea.readInt() != 1) {
                  return;
              }
              
              final byte eSlot = (byte) slea.readInt();
              final Item eitem = player.getInventory(MapleInventoryType.EQUIP).getItem(eSlot);
              
              if (slea.readInt() != 2) {
                  return;
              }
              
              final byte uSlot = (byte) slea.readInt();
              final Item uitem = player.getInventory(MapleInventoryType.USE).getItem(uSlot);
              if (eitem == null || uitem == null) {
                  return;
              }
              
              Equip toScroll = (Equip) eitem;
              if (toScroll.getUpgradeSlots() < 1) {
                  c.announce(MaplePacketCreator.getInventoryFull());
                  return;
              }
              
              //should have a check here against PE hacks
              if(itemId / 1000000 != 5) itemId = 0;
              
              player.toggleBlockCashShop();
              
              final int curlevel = toScroll.getLevel();
              c.announce(MaplePacketCreator.sendVegaScroll(0x40));
              
              final Equip scrolled = (Equip) ii.scrollEquipWithId(toScroll, uitem.getItemId(), false, itemId, player.isGM());
              c.announce(MaplePacketCreator.sendVegaScroll(scrolled.getLevel() > curlevel ? 0x41 : 0x43));
              //opcodes 0x42, 0x44: "this item cannot be used"; 0x39, 0x45: crashes
              
              MapleInventoryManipulator.removeFromSlot(c, MapleInventoryType.USE, uSlot, (short) 1, false);
              remove(c, position, itemId);
              
              final MapleClient client = c;
              TimerManager.getInstance().schedule(new Runnable() {
              	@Override
              	public void run() {
                      if(!player.isLoggedin()) return;
                      
                      player.toggleBlockCashShop();
                      
                      final List<ModifyInventory> mods = new ArrayList<>();
                      mods.add(new ModifyInventory(3, scrolled));
                      mods.add(new ModifyInventory(0, scrolled));
                      client.announce(MaplePacketCreator.modifyInventory(true, mods));
  
                      ScrollResult scrollResult = scrolled.getLevel() > curlevel ? ScrollResult.SUCCESS : ScrollResult.FAIL;
                      player.getMap().broadcastMessage(MaplePacketCreator.getScrollEffect(player.getId(), scrollResult, false, false));
                      if (eSlot < 0 && (scrollResult == ScrollResult.SUCCESS)) {
                          player.equipChanged();
                      }
  
                      client.announce(MaplePacketCreator.enableActions());
              	}
              }, 1000 * 3);
          } else {
              System.out.println("NEW CASH ITEM: " + itemType + "\n" + slea.toString());
              c.announce(MaplePacketCreator.enableActions());
          }
      }
  
      private static void remove(MapleClient c, short position, int itemid) {
          MapleInventory cashInv = c.getPlayer().getInventory(MapleInventoryType.CASH);
          cashInv.lockInventory();
          try {
              Item it = cashInv.getItem(position);
              if (it == null || it.getItemId() != itemid) {
                  it = cashInv.findById(itemid);
                  if (it != null) {
                      position = it.getPosition();
                  }
              }
              
              MapleInventoryManipulator.removeFromSlot(c, MapleInventoryType.CASH, position, (short) 1, true, false);
          } finally {
              cashInv.unlockInventory();
          }
      }
  
      private static boolean getIncubatedItem(MapleClient c, int id) {
          final int[] ids = {1012070, 1302049, 1302063, 1322027, 2000004, 2000005, 2020013, 2020015, 2040307, 2040509, 2040519, 2040521, 2040533, 2040715, 2040717, 2040810, 2040811, 2070005, 2070006, 4020009,};
          final int[] quantitys = {1, 1, 1, 1, 240, 200, 200, 200, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3};
          int amount = 0;
          for (int i = 0; i < ids.length; i++) {
              if (i == id) {
                  amount = quantitys[i];
              }
          }
          if (c.getPlayer().getInventory(MapleInventoryType.getByType((byte) (id / 1000000))).isFull()) {
              return false;
          }
          MapleInventoryManipulator.addById(c, id, (short) amount);
          return true;
      }
  }
  