Package com.l2jfrozen.gameserver.model.actor.instance

Examples of com.l2jfrozen.gameserver.model.actor.instance.L2PcInstance


  }

  @Override
  protected void runImpl()
  {
    L2PcInstance player = getClient().getActiveChar();
    if (player == null)
      return;
   
    L2PcInstance requestor = player.getActiveRequester();
     if (requestor == null)
         return;
      
     if (_response == 1)
    {
       boolean newCc = false;
        if (!requestor.getParty().isInCommandChannel())
        {
        new L2CommandChannel(requestor); // Create new CC
        newCc = true;
        }
                 
        requestor.getParty().getCommandChannel().addParty(player.getParty());
        if (!newCc)
        player.sendPacket(new SystemMessage(SystemMessageId.JOINED_COMMAND_CHANNEL));
        }
        else
        requestor.sendPacket(new SystemMessage(SystemMessageId.S1_DECLINED_CHANNEL_INVITATION).addString(player.getName()));
    
     player.setActiveRequester(null);
     requestor.onTransactionResponse();
  }
View Full Code Here


  }

  @Override
  protected void runImpl()
  {
    L2PcInstance player = getClient().getActiveChar();
    if(player == null)
      return;

    L2Object target = player.getTarget();

    if(!(target instanceof L2ManorManagerInstance))
    {
      target = player.getLastFolkNPC();
    }

    if(!player.isGM() && (target == null || !(target instanceof L2ManorManagerInstance) || !player.isInsideRadius(target, L2NpcInstance.INTERACTION_DISTANCE, false, false)))
      return;

    if(_size < 1)
    {
      sendPacket(ActionFailed.STATIC_PACKET);
      return;
    }

    L2ManorManagerInstance manorManager = (L2ManorManagerInstance) target;

    int currentManorId = manorManager.getCastle().getCastleId();

    // Calculate summary values
    int slots = 0;
    int weight = 0;

    for(int i = 0; i < _size; i++)
    {
      int itemId = _items[i * 4 + 1];
      int manorId = _items[i * 4 + 2];
      int count = _items[i * 4 + 3];

      if(itemId == 0 || manorId == 0 || count == 0)
      {
        continue;
      }

      if(count < 1)
      {
        continue;
      }

      if(count > Integer.MAX_VALUE)
      {
        Util.handleIllegalPlayerAction(player, "Warning!! Character " + player.getName() + " of account " + player.getAccountName() + " tried to purchase over " + Integer.MAX_VALUE + " items at the same time.", Config.DEFAULT_PUNISH);
        SystemMessage sm = new SystemMessage(SystemMessageId.YOU_HAVE_EXCEEDED_QUANTITY_THAT_CAN_BE_INPUTTED);
        sendPacket(sm);
        return;
      }

      try
      {
        CropProcure crop = CastleManager.getInstance().getCastleById(manorId).getCrop(itemId, CastleManorManager.PERIOD_CURRENT);
        int rewardItemId = L2Manor.getInstance().getRewardItem(itemId, crop.getReward());
        L2Item template = ItemTable.getInstance().getTemplate(rewardItemId);
        weight += count * template.getWeight();

        if(!template.isStackable())
        {
          slots += count;
        }
        else if(player.getInventory().getItemByItemId(itemId) == null)
        {
          slots++;
        }
      }
      catch(NullPointerException e)
      {
        if(Config.ENABLE_ALL_EXCEPTIONS)
          e.printStackTrace();
       
        continue;
      }
    }

    if(!player.getInventory().validateWeight(weight))
    {
      sendPacket(new SystemMessage(SystemMessageId.WEIGHT_LIMIT_EXCEEDED));
      return;
    }

    if(!player.getInventory().validateCapacity(slots))
    {
      sendPacket(new SystemMessage(SystemMessageId.SLOTS_FULL));
      return;
    }

    // Proceed the purchase
    InventoryUpdate playerIU = new InventoryUpdate();

    for(int i = 0; i < _size; i++)
    {
      int objId = _items[i * 4 + 0];
      int cropId = _items[i * 4 + 1];
      int manorId = _items[i * 4 + 2];
      int count = _items[i * 4 + 3];

      if(objId == 0 || cropId == 0 || manorId == 0 || count == 0)
      {
        continue;
      }

      if(count < 1)
      {
        continue;
      }

      CropProcure crop = null;

      try
      {
        crop = CastleManager.getInstance().getCastleById(manorId).getCrop(cropId, CastleManorManager.PERIOD_CURRENT);
      }
      catch(NullPointerException e)
      {
        if(Config.ENABLE_ALL_EXCEPTIONS)
          e.printStackTrace();
       
        continue;
      }
      if(crop == null || crop.getId() == 0 || crop.getPrice() == 0)
      {
        continue;
      }

      int fee = 0; // fee for selling to other manors

      int rewardItem = L2Manor.getInstance().getRewardItem(cropId, crop.getReward());

      if(count > crop.getAmount())
      {
        continue;
      }

      int sellPrice = count * L2Manor.getInstance().getCropBasicPrice(cropId);
      int rewardPrice = ItemTable.getInstance().getTemplate(rewardItem).getReferencePrice();

      if(rewardPrice == 0)
      {
        continue;
      }

      int rewardItemCount = sellPrice / rewardPrice;
      if(rewardItemCount < 1)
      {
        SystemMessage sm = new SystemMessage(SystemMessageId.FAILED_IN_TRADING_S2_OF_CROP_S1);
        sm.addItemName(cropId);
        sm.addNumber(count);
        player.sendPacket(sm);
        continue;
      }

      if(manorId != currentManorId)
      {
        fee = sellPrice * 5 / 100; // 5% fee for selling to other manor
      }

      if(player.getInventory().getAdena() < fee)
      {
        SystemMessage sm = new SystemMessage(SystemMessageId.FAILED_IN_TRADING_S2_OF_CROP_S1);
        sm.addItemName(cropId);
        sm.addNumber(count);
        player.sendPacket(sm);
        sm = new SystemMessage(SystemMessageId.YOU_NOT_ENOUGH_ADENA);
        player.sendPacket(sm);
        continue;
      }

      // Add item to Inventory and adjust update packet
      L2ItemInstance itemDel = null;
      L2ItemInstance itemAdd = null;
      if(player.getInventory().getItemByObjectId(objId) != null)
      {
        // check if player have correct items count
        L2ItemInstance item = player.getInventory().getItemByObjectId(objId);
        if(item.getCount() < count)
        {
          continue;
        }

        itemDel = player.getInventory().destroyItem("Manor", objId, count, player, manorManager);
        if(itemDel == null)
        {
          continue;
        }

        if(fee > 0)
        {
          player.getInventory().reduceAdena("Manor", fee, player, manorManager);
        }

        crop.setAmount(crop.getAmount() - count);

        if(Config.ALT_MANOR_SAVE_ALL_ACTIONS)
        {
          CastleManager.getInstance().getCastleById(manorId).updateCrop(crop.getId(), crop.getAmount(), CastleManorManager.PERIOD_CURRENT);
        }

        itemAdd = player.getInventory().addItem("Manor", rewardItem, rewardItemCount, player, manorManager);
      }
      else
      {
        continue;
      }

      if(itemAdd == null)
      {
        continue;
      }

      playerIU.addRemovedItem(itemDel);
      if(itemAdd.getCount() > rewardItemCount)
      {
        playerIU.addModifiedItem(itemAdd);
      }
      else
      {
        playerIU.addNewItem(itemAdd);
      }

      // Send System Messages
      SystemMessage sm = new SystemMessage(SystemMessageId.TRADED_S2_OF_CROP_S1);
      sm.addItemName(cropId);
      sm.addNumber(count);
      player.sendPacket(sm);

      if(fee > 0)
      {
        sm = new SystemMessage(SystemMessageId.S1_ADENA_HAS_BEEN_WITHDRAWN_TO_PAY_FOR_PURCHASING_FEES);
        sm.addNumber(fee);
        player.sendPacket(sm);
      }

      sm = new SystemMessage(SystemMessageId.DISSAPEARED_ITEM);
      sm.addItemName(cropId);
      sm.addNumber(count);
      player.sendPacket(sm);

      if(fee > 0)
      {
        sm = new SystemMessage(SystemMessageId.DISSAPEARED_ADENA);
        sm.addNumber(fee);
        player.sendPacket(sm);
      }

      sm = new SystemMessage(SystemMessageId.EARNED_S2_S1_S);
      sm.addItemName(rewardItem);
      sm.addNumber(rewardItemCount);
      player.sendPacket(sm);
    }

    // Send update packets
    player.sendPacket(playerIU);

    StatusUpdate su = new StatusUpdate(player.getObjectId());
    su.addAttribute(StatusUpdate.CUR_LOAD, player.getCurrentLoad());
    player.sendPacket(su);

  }
View Full Code Here

  }

  @Override
  protected void runImpl()
  {
    L2PcInstance player = getClient().getActiveChar();
    if(player == null)
      return;

    if (!getClient().getFloodProtectors().getTransaction().tryPerformAction("withdraw"))
    {
      player.sendMessage("You withdrawing items too fast.");
      return;
    }
   
    // Like L2OFF you can't confirm a withdraw when you are in trade.
    if(player.getActiveTradeList() != null)
    {
      player.sendMessage("You can't withdraw items when you are trading.");
      player.sendPacket(ActionFailed.STATIC_PACKET);
      return;
    }

    ItemContainer warehouse = player.getActiveWarehouse();
    if(warehouse == null)
      return;

    L2FolkInstance manager = player.getLastFolkNPC();
    if((manager == null || !player.isInsideRadius(manager, L2NpcInstance.INTERACTION_DISTANCE, false, false)) && !player.isGM())
      return;

    if(warehouse instanceof ClanWarehouse && !player.getAccessLevel().allowTransaction())
    {
      player.sendMessage("Unsufficient privileges.");
      player.sendPacket(ActionFailed.STATIC_PACKET);
      return;
    }


    // Alt game - Karma punishment
    if(!Config.ALT_GAME_KARMA_PLAYER_CAN_USE_WAREHOUSE && player.getKarma() > 0)
      return;

    if(Config.ALT_MEMBERS_CAN_WITHDRAW_FROM_CLANWH)
    {
      if(warehouse instanceof ClanWarehouse && (player.getClanPrivileges() & L2Clan.CP_CL_VIEW_WAREHOUSE) != L2Clan.CP_CL_VIEW_WAREHOUSE)
        return;
    }
    else
    {
      if(warehouse instanceof ClanWarehouse && !player.isClanLeader())
      {
        // this msg is for depositing but maybe good to send some msg?
        player.sendPacket(new SystemMessage(SystemMessageId.ONLY_CLAN_LEADER_CAN_RETRIEVE_ITEMS_FROM_CLAN_WAREHOUSE));
        return;
      }
    }

    int weight = 0;
    int slots = 0;

    for(int i = 0; i < _count; i++)
    {
      int objectId = _items[i * 2 + 0];
      int count = _items[i * 2 + 1];

      // Calculate needed slots
      L2ItemInstance item = warehouse.getItemByObjectId(objectId);
      if(item == null)
      {
        continue;
      }
      weight += count * item.getItem().getWeight();
      if(!item.isStackable())
      {
        slots += count;
      }
      else if(player.getInventory().getItemByItemId(item.getItemId()) == null)
      {
        slots++;
      }
    }

    // Item Max Limit Check
    if(!player.getInventory().validateCapacity(slots))
    {
      sendPacket(new SystemMessage(SystemMessageId.SLOTS_FULL));
      return;
    }

    // Like L2OFF enchant window must close
    if(player.getActiveEnchantItem() != null)
    {
      sendPacket(new SystemMessage(SystemMessageId.ENCHANT_SCROLL_CANCELLED));
      player.sendPacket(new EnchantResult(0));
      player.sendPacket(ActionFailed.STATIC_PACKET);
      return;
    }

    // Weight limit Check
    if(!player.getInventory().validateWeight(weight))
    {
      sendPacket(new SystemMessage(SystemMessageId.WEIGHT_LIMIT_EXCEEDED));
      return;
    }

    // Proceed to the transfer
    InventoryUpdate playerIU = Config.FORCE_INVENTORY_UPDATE ? null : new InventoryUpdate();
    for(int i = 0; i < _count; i++)
    {
      int objectId = _items[i * 2 + 0];
      int count = _items[i * 2 + 1];

      L2ItemInstance oldItem = warehouse.getItemByObjectId(objectId);
      if(oldItem == null || oldItem.getCount() < count)
      {
        player.sendMessage("Can't withdraw requested item" + (count > 1 ? "s" : ""));
      }
      L2ItemInstance newItem = warehouse.transferItem("Warehouse", objectId, count, player.getInventory(), player, player.getLastFolkNPC());
      if(newItem == null)
      {
        _log.warning("Error withdrawing a warehouse object for char " + player.getName());
        continue;
      }

      if(playerIU != null)
      {
        if(newItem.getCount() > count)
        {
          playerIU.addModifiedItem(newItem);
        }
        else
        {
          playerIU.addNewItem(newItem);
        }
      }
    }

    // Send updated item list to the player
    if(playerIU != null)
    {
      player.sendPacket(playerIU);
    }
    else
    {
      player.sendPacket(new ItemList(player, false));
    }

    // Update current load status on player
    StatusUpdate su = new StatusUpdate(player.getObjectId());
    su.addAttribute(StatusUpdate.CUR_LOAD, player.getCurrentLoad());
    player.sendPacket(su);
  }
View Full Code Here

  }
 
  @Override
  protected void runImpl()
  {
    L2PcInstance activeChar = getClient().getActiveChar();
   
    if (activeChar == null)
      return;
   
    if (activeChar.isInRaidEvent()) 
    { 
      activeChar.sendMessage("You will be revived any second.")
      return
    }
   
    if (activeChar.isFakeDeath())
    {
      activeChar.stopFakeDeath(null);
      activeChar.broadcastPacket(new Revive(activeChar));
      return;
    }
    else if (!activeChar.isAlikeDead())
    {
      _log.warning("Living player [" + activeChar.getName() + "] called RestartPointPacket! Ban this player!");
      return;
    }
   
    Castle castle = CastleManager.getInstance().getCastle(activeChar.getX(), activeChar.getY(), activeChar.getZ());
    if (castle != null && castle.getSiege().getIsInProgress())
    {
      if (activeChar.getClan() != null && castle.getSiege().checkIsAttacker(activeChar.getClan()))
      {
        // Schedule respawn delay for attacker
        ThreadPoolManager.getInstance().scheduleGeneral(new DeathTask(activeChar), castle.getSiege().getAttackerRespawnDelay());
        activeChar.sendMessage("You will be re-spawned in " + castle.getSiege().getAttackerRespawnDelay() / 1000 + " seconds");
        return;
      }
    }
    // run immediately (no need to schedule)
    new DeathTask(activeChar).run();
View Full Code Here

  }

  @Override
  protected void runImpl()
  {
    final L2PcInstance player = getClient().getActiveChar();
    if (player == null)
      return;
   
    final L2PcInstance requestor = player.getActiveRequester();
    if (requestor == null)
      return;
   
   
    if(player.isCursedWeaponEquiped() || requestor.isCursedWeaponEquiped())
    {
      requestor.sendPacket(new SystemMessage(SystemMessageId.INCORRECT_TARGET));
      return;
    }
   
    if (player.isInLMS() || requestor.isInLMS())
    {
      requestor.sendPacket(new SystemMessage(SystemMessageId.INCORRECT_TARGET));
      return;
    }
   
    requestor.sendPacket(new JoinParty(_response));

    if (_response == 1)
    {
      if (requestor.isInParty())
      {
        if (requestor.getParty().getMemberCount() >= 9)
        {
          SystemMessage sm = new SystemMessage(SystemMessageId.PARTY_FULL);
          player.sendPacket(sm);
          requestor.sendPacket(sm);
          return;
        }
      }
      player.joinParty(requestor.getParty());
     
      if (requestor.isInPartyMatchRoom() && player.isInPartyMatchRoom())
      {
        final PartyMatchRoomList list = PartyMatchRoomList.getInstance();
        if (list != null && (list.getPlayerRoomId(requestor) == list.getPlayerRoomId(player)))
        {
          final PartyMatchRoom room = list.getPlayerRoom(requestor);
          if (room != null)
          {
            final ExManagePartyRoomMember packet = new ExManagePartyRoomMember(player, room, 1);
            for (L2PcInstance member : room.getPartyMembers())
            {
              if (member != null)
                member.sendPacket(packet);
            }
          }
        }
      }
      else if (requestor.isInPartyMatchRoom() && !player.isInPartyMatchRoom())
      {
        final PartyMatchRoomList list = PartyMatchRoomList.getInstance();
        if (list != null)
        {
          final PartyMatchRoom room = list.getPlayerRoom(requestor);
          if (room != null)
          {
            room.addMember(player);
            ExManagePartyRoomMember packet = new ExManagePartyRoomMember(player, room, 1);
            for(L2PcInstance member : room.getPartyMembers())
            {
              if (member != null)
                member.sendPacket(packet);
            }
            player.setPartyRoom(room.getId());
            player.broadcastUserInfo();
          }
        }
      }
      }
    else
        {
      //activate garbage collection if there are no other members in party (happens when we were creating new one)
      if (requestor.isInParty() && requestor.getParty().getMemberCount() == 1)
        requestor.getParty().removePartyMember(requestor, false);
      }
     
    if (requestor.isInParty())
        requestor.getParty().setPendingInvitation(false);

      player.setActiveRequester(null);
      requestor.onTransactionResponse();
  }
View Full Code Here

  }

  @Override
  protected void runImpl()
  {
    L2PcInstance player = getClient().getActiveChar();
    if(player == null)
      return;

    if (!getClient().getFloodProtectors().getTransaction().tryPerformAction("buy"))
    {
      player.sendMessage("You buying too fast.");
      return;
    }
   
    // Alt game - Karma punishment
    if(!Config.ALT_GAME_KARMA_PLAYER_CAN_SHOP && player.getKarma() > 0)
      return;

    L2Object target = player.getTarget();
    if(!player.isGM() && (target == null // No target (ie GM Shop)
        || !(target instanceof L2MerchantInstance || target instanceof L2FishermanInstance || target instanceof L2MercManagerInstance || target instanceof L2ClanHallManagerInstance || target instanceof L2CastleChamberlainInstance) // Target not a merchant, fisherman or mercmanager
    || !player.isInsideRadius(target, L2NpcInstance.INTERACTION_DISTANCE, false, false) // Distance is too far
    ))
      return;

    boolean ok = true;
    String htmlFolder = "";

    if(target != null)
    {
      if(target instanceof L2MerchantInstance)
      {
        htmlFolder = "merchant";
      }
      else if(target instanceof L2FishermanInstance)
      {
        htmlFolder = "fisherman";
      }
      else if(target instanceof L2MercManagerInstance)
      {
        ok = true;
      }
      else if(target instanceof L2ClanHallManagerInstance)
      {
        ok = true;
      }
      else if(target instanceof L2CastleChamberlainInstance)
      {
        ok = true;
      }
      else
      {
        ok = false;
      }
    }
    else
    {
      ok = false;
    }

    L2NpcInstance merchant = null;

    if(ok)
    {
      merchant = (L2NpcInstance) target;
    }
    else if(!ok && !player.isGM())
    {
      player.sendMessage("Invalid Target: Seller must be targetted");
      return;
    }

    L2TradeList list = null;

    if(merchant != null)
    {
      List<L2TradeList> lists = TradeController.getInstance().getBuyListByNpcId(merchant.getNpcId());

      if(!player.isGM())
      {
        if(lists == null)
        {
          Util.handleIllegalPlayerAction(player, "Warning!! Character " + player.getName() + " of account " + player.getAccountName() + " sent a false BuyList list_id.", Config.DEFAULT_PUNISH);
          return;
        }
        for(L2TradeList tradeList : lists)
        {
          if(tradeList.getListId() == _listId)
          {
            list = tradeList;
          }
        }
      }
      else
      {
        list = TradeController.getInstance().getBuyList(_listId);
      }
    }
    else
    {
      list = TradeController.getInstance().getBuyList(_listId);
    }

    if(list == null)
    {
      Util.handleIllegalPlayerAction(player, "Warning!! Character " + player.getName() + " of account " + player.getAccountName() + " sent a false BuyList list_id.", Config.DEFAULT_PUNISH);
      return;
    }

    _listId = list.getListId();

    if(_listId > 1000000) // lease
    {
      if(merchant != null && merchant.getTemplate().npcId != _listId - 1000000)
      {
        sendPacket(ActionFailed.STATIC_PACKET);
        return;
      }
    }

    if(_count < 1)
    {
      sendPacket(ActionFailed.STATIC_PACKET);
      return;
    }

    double taxRate = 0;

    if(merchant != null && merchant.getIsInTown())
    {
      taxRate = merchant.getCastle().getTaxRate();
    }

    long subTotal = 0;
    int tax = 0;

    // Check for buylist validity and calculates summary values
    long slots = 0;
    long weight = 0;
    for(int i = 0; i < _count; i++)
    {
      int itemId = _items[i * 2 + 0];
      int count = _items[i * 2 + 1];
      int price = -1;

      if(!list.containsItemId(itemId))
      {
        Util.handleIllegalPlayerAction(player, "Warning!! Character " + player.getName() + " of account " + player.getAccountName() + " sent a false BuyList list_id.", Config.DEFAULT_PUNISH);
        return;
      }

      L2Item template = ItemTable.getInstance().getTemplate(itemId);

      if(template == null)
      {
        continue;
      }

      // Check count
      if(count > Integer.MAX_VALUE || !template.isStackable() && count > 1)
      {
        //Util.handleIllegalPlayerAction(player, "Warning!! Character " + player.getName() + " of account " + player.getAccountName() + " tried to purchase invalid quantity of items at the same time.", Config.DEFAULT_PUNISH);
        SystemMessage sm = new SystemMessage(SystemMessageId.YOU_HAVE_EXCEEDED_QUANTITY_THAT_CAN_BE_INPUTTED);
        sendPacket(sm);
        sm = null;
        return;
      }

      if(_listId < 1000000)
      {
        //list = TradeController.getInstance().getBuyList(_listId);
        price = list.getPriceForItemId(itemId);

        if(itemId >= 3960 && itemId <= 4026)
        {
          price *= Config.RATE_SIEGE_GUARDS_PRICE;
        }

      }
      /* TODO: Disabled until Leaseholders are rewritten ;-)
            }
            else
            {
              L2ItemInstance li = merchant.findLeaseItem(itemId, 0);
              if (li == null || li.getCount() < cnt)
              {
                cnt = li.getCount();
                if (cnt <= 0)
                {
                  items.remove(i);
                  continue;
                }
                items.get(i).setCount((int)cnt);
              }
              price = li.getPriceToSell(); // lease holder sells the item
              weight = li.getItem().getWeight();
            }

      */
      if(price < 0)
      {
        _log.warning("ERROR, no price found .. wrong buylist ??");
        sendPacket(ActionFailed.STATIC_PACKET);
        return;
      }

      if(price == 0 && !player.isGM() && Config.ONLY_GM_ITEMS_FREE)
      {
        player.sendMessage("Ohh Cheat dont work? You have a problem now!");
        Util.handleIllegalPlayerAction(player, "Warning!! Character " + player.getName() + " of account " + player.getAccountName() + " tried buy item for 0 adena.", Config.DEFAULT_PUNISH);
        return;
      }

      subTotal += (long) count * price; // Before tax
      tax = (int) (subTotal * taxRate);

      // Check subTotal + tax
      if(subTotal + tax > Integer.MAX_VALUE)
      {
        //Util.handleIllegalPlayerAction(player, "Warning!! Character " + player.getName() + " of account " + player.getAccountName() + " tried to purchase over " + Integer.MAX_VALUE + " adena worth of goods.", Config.DEFAULT_PUNISH);
        SystemMessage sm = new SystemMessage(SystemMessageId.YOU_HAVE_EXCEEDED_QUANTITY_THAT_CAN_BE_INPUTTED);
        sendPacket(sm);
        sm = null;
        return;
      }

      weight += (long) count * template.getWeight();
      if(!template.isStackable())
      {
        slots += count;
      }
      else if(player.getInventory().getItemByItemId(itemId) == null)
      {
        slots++;
      }
    }

    if(weight > Integer.MAX_VALUE || weight < 0 || !player.getInventory().validateWeight((int) weight))
    {
      sendPacket(new SystemMessage(SystemMessageId.WEIGHT_LIMIT_EXCEEDED));
      return;
    }

    if(slots > Integer.MAX_VALUE || slots < 0 || !player.getInventory().validateCapacity((int) slots))
    {
      sendPacket(new SystemMessage(SystemMessageId.SLOTS_FULL));
      return;
    }

    // Charge buyer and add tax to castle treasury if not owned by npc clan
    if(subTotal < 0 || !player.reduceAdena("Buy", (int) (subTotal + tax), player.getLastFolkNPC(), false))
    {
      sendPacket(new SystemMessage(SystemMessageId.YOU_NOT_ENOUGH_ADENA));
      return;
    }

    if(merchant != null && merchant.getIsInTown() && merchant.getCastle().getOwnerId() > 0)
    {
      merchant.getCastle().addToTreasury(tax);
    }

    // Proceed the purchase
    for(int i = 0; i < _count; i++)
    {
      int itemId = _items[i * 2 + 0];
      int count = _items[i * 2 + 1];

      if(count < 0)
      {
        count = 0;
      }

      if(!list.containsItemId(itemId))
      {
        Util.handleIllegalPlayerAction(player, "Warning!! Character " + player.getName() + " of account " + player.getAccountName() + " sent a false BuyList list_id.", Config.DEFAULT_PUNISH);
        return;
      }

      if(list.countDecrease(itemId))
      {
        if(!list.decreaseCount(itemId, count)) {
          SystemMessage sm = new SystemMessage(SystemMessageId.YOU_HAVE_EXCEEDED_QUANTITY_THAT_CAN_BE_INPUTTED);
          sendPacket(sm);
          sm = null;
          return;
        }
         
      }
      // Add item to Inventory and adjust update packet
      player.getInventory().addItem("Buy", itemId, count, player, merchant);
      /* TODO: Disabled until Leaseholders are rewritten ;-)
            // Update Leaseholder list
            if (_listId >= 1000000)
            {
              L2ItemInstance li = merchant.findLeaseItem(item.getItemId(), 0);
              if (li == null)
                continue;
              if (li.getCount() < item.getCount())
                item.setCount(li.getCount());
              li.setCount(li.getCount() - item.getCount());
              li.updateDatabase();
              price = item.getCount() + li.getPriceToSell();
              L2ItemInstance la = merchant.getLeaseAdena();
              la.setCount(la.getCount() + price);

              la.updateDatabase();
              player.getInventory().addItem(item);
              item.updateDatabase();
            }
      */
    }

    if(merchant != null)
    {
      String html = HtmCache.getInstance().getHtm("data/html/" + htmlFolder + "/" + merchant.getNpcId() + "-bought.htm");

      if(html != null)
      {
        NpcHtmlMessage boughtMsg = new NpcHtmlMessage(merchant.getObjectId());
        boughtMsg.setHtml(html.replaceAll("%objectId%", String.valueOf(merchant.getObjectId())));
        player.sendPacket(boughtMsg);
      }
    }

    StatusUpdate su = new StatusUpdate(player.getObjectId());
    su.addAttribute(StatusUpdate.CUR_LOAD, player.getCurrentLoad());
    player.sendPacket(su);
    player.sendPacket(new ItemList(player, true));
  }
View Full Code Here

  protected void runImpl()
  {
    if (_skillId <= 0 || _skillLvl <= 0) // minimal sanity check
      return;
   
    L2PcInstance activeChar = getClient().getActiveChar();
    if(activeChar == null)
      return;

    if(activeChar.getLevel() < 76)
      return;

    L2FolkInstance trainer = activeChar.getLastFolkNPC();
    if(trainer == null)
    {
      return;
    }
   
    if (!activeChar.isInsideRadius(trainer, L2NpcInstance.INTERACTION_DISTANCE, false, false) && !activeChar.isGM())
    {
      return;
    }
   
    boolean canteach = false;
   
    L2Skill skill = SkillTable.getInstance().getInfo(_skillId, _skillLvl);
    if(skill == null || skill.getId() != _skillId)
      return;

    if(!trainer.getTemplate().canTeach(activeChar.getClassId()))
      return; // cheater

    L2EnchantSkillLearn[] skills = SkillTreeTable.getInstance().getAvailableEnchantSkills(activeChar);

    for(L2EnchantSkillLearn s : skills)
View Full Code Here

  }

  @Override
  protected void runImpl()
  {
    L2PcInstance _activeChar = getClient().getActiveChar();
    if (_activeChar == null)
      return;
   
    PartyMatchWaitingList.getInstance().removePlayer(_activeChar);
  }
View Full Code Here

  }

  @Override
  protected void runImpl()
  {
    L2PcInstance activeChar = getClient().getActiveChar();

    if(activeChar == null)
      return;
   
    if (!getClient().getFloodProtectors().getUseItem().tryPerformAction("pet use item"))
      return;


    L2PetInstance pet = (L2PetInstance) activeChar.getPet();

    if(pet == null)
      return;

    L2ItemInstance item = pet.getInventory().getItemByObjectId(_objectId);

    if(item == null)
      return;

    if(item.isWear())
      return;

    int itemId = item.getItemId();

    if(activeChar.isAlikeDead() || pet.isDead())
    {
      SystemMessage sm = new SystemMessage(SystemMessageId.S1_CANNOT_BE_USED);
      sm.addItemName(item.getItemId());
      activeChar.sendPacket(sm);
      sm = null;
      return;
    }

    if(Config.DEBUG)
    {
      _log.finest(activeChar.getObjectId() + ": pet use item " + _objectId);
    }

    //check if the item matches the pet
    if(item.isEquipable())
    {
      if(L2PetDataTable.isWolf(pet.getNpcId()) && // wolf
      item.getItem().isForWolf())
      {
        useItem(pet, item, activeChar);
        return;
      }
      else if(L2PetDataTable.isHatchling(pet.getNpcId()) && // hatchlings
      item.getItem().isForHatchling())
      {
        useItem(pet, item, activeChar);
        return;
      }
      else if(L2PetDataTable.isStrider(pet.getNpcId()) && // striders
      item.getItem().isForStrider())
      {
        useItem(pet, item, activeChar);
        return;
      }
      else if(L2PetDataTable.isBaby(pet.getNpcId()) && // baby pets (buffalo, cougar, kookaboora)
      item.getItem().isForBabyPet())
      {
        useItem(pet, item, activeChar);
        return;
      }
      else
      {
        activeChar.sendPacket(new SystemMessage(SystemMessageId.ITEM_NOT_FOR_PETS));
        return;
      }
    }
    else if(L2PetDataTable.isPetFood(itemId))
    {
      if(L2PetDataTable.isWolf(pet.getNpcId()) && L2PetDataTable.isWolfFood(itemId))
      {
        feed(activeChar, pet, item);
        return;
      }

      if(L2PetDataTable.isSinEater(pet.getNpcId()) && L2PetDataTable.isSinEaterFood(itemId))
      {
        feed(activeChar, pet, item);
        return;
      }
      else if(L2PetDataTable.isHatchling(pet.getNpcId()) && L2PetDataTable.isHatchlingFood(itemId))
      {
        feed(activeChar, pet, item);
        return;
      }
      else if(L2PetDataTable.isStrider(pet.getNpcId()) && L2PetDataTable.isStriderFood(itemId))
      {
        feed(activeChar, pet, item);
        return;
      }
      else if(L2PetDataTable.isWyvern(pet.getNpcId()) && L2PetDataTable.isWyvernFood(itemId))
      {
        feed(activeChar, pet, item);
        return;
      }
      else if(L2PetDataTable.isBaby(pet.getNpcId()) && L2PetDataTable.isBabyFood(itemId))
      {
        feed(activeChar, pet, item);
      }
    }

    IItemHandler handler = ItemHandler.getInstance().getItemHandler(item.getItemId());

    if(handler != null)
    {
      useItem(pet, item, activeChar);
    }
    else
    {
      SystemMessage sm = new SystemMessage(SystemMessageId.ITEM_NOT_FOR_PETS);
      activeChar.sendPacket(sm);
    }

    return;
  }
View Full Code Here

  }

  @Override
  protected void runImpl()
  {
    L2PcInstance activeChar = getClient().getActiveChar();
    L2PcInstance targetChar = L2World.getInstance().getPlayer(_player);
    if(activeChar == null)
      return;

    if(targetChar == null)
    {
      activeChar.sendPacket(new SystemMessage(SystemMessageId.THERE_IS_NO_OPPONENT_TO_RECEIVE_YOUR_CHALLENGE_FOR_A_DUEL));
      return;
    }

    if(activeChar == targetChar)
    {
      activeChar.sendPacket(new SystemMessage(SystemMessageId.THERE_IS_NO_OPPONENT_TO_RECEIVE_YOUR_CHALLENGE_FOR_A_DUEL));
      return;
    }

    // Check if duel is possible
    if(!activeChar.canDuel())
    {
      activeChar.sendPacket(new SystemMessage(SystemMessageId.YOU_ARE_UNABLE_TO_REQUEST_A_DUEL_AT_THIS_TIME));
      return;
    }
    else if(!targetChar.canDuel())
    {
      activeChar.sendPacket(targetChar.getNoDuelReason());
      return;
    }
    // Players may not be too far apart
    else if(!activeChar.isInsideRadius(targetChar, 250, false, false))
    {
      SystemMessage msg = new SystemMessage(SystemMessageId.S1_CANNOT_RECEIVE_A_DUEL_CHALLENGE_BECAUSE_S1_IS_TOO_FAR_AWAY);
      msg.addString(targetChar.getName());
      activeChar.sendPacket(msg);
      return;
    }

    // Duel is a party duel
    if(_partyDuel == 1)
    {
      // Player must be in a party & the party leader
      if(!activeChar.isInParty() || !(activeChar.isInParty() && activeChar.getParty().isLeader(activeChar)))
      {
        activeChar.sendMessage("You have to be the leader of a party in order to request a party duel.");
        return;
      }
      // Target must be in a party
      else if(!targetChar.isInParty())
      {
        activeChar.sendPacket(new SystemMessage(SystemMessageId.SINCE_THE_PERSON_YOU_CHALLENGED_IS_NOT_CURRENTLY_IN_A_PARTY_THEY_CANNOT_DUEL_AGAINST_YOUR_PARTY));
        return;
      }
      // Target may not be of the same party
      else if(activeChar.getParty().getPartyMembers().contains(targetChar))
      {
        activeChar.sendMessage("This player is a member of your own party.");
        return;
      }

      // Check if every player is ready for a duel
      for(L2PcInstance temp : activeChar.getParty().getPartyMembers())
      {
        if(!temp.canDuel())
        {
          activeChar.sendMessage("Not all the members of your party are ready for a duel.");
          return;
        }
      }
     
      L2PcInstance partyLeader = null; // snatch party leader of targetChar's party
      for(L2PcInstance temp : targetChar.getParty().getPartyMembers())
      {
        if(partyLeader == null)
        {
          partyLeader = temp;
        }
        if(!temp.canDuel())
        {
          activeChar.sendPacket(new SystemMessage(SystemMessageId.THE_OPPOSING_PARTY_IS_CURRENTLY_UNABLE_TO_ACCEPT_A_CHALLENGE_TO_A_DUEL));
          return;
        }
      }
     
      if (partyLeader != null)
      {
        // Send request to targetChar's party leader
        if(!partyLeader.isProcessingRequest())
        {
          activeChar.onTransactionRequest(partyLeader);
          partyLeader.sendPacket(new ExDuelAskStart(activeChar.getName(), _partyDuel));
 
          if(Config.DEBUG)
          {
            _log.fine(activeChar.getName() + " requested a duel with " + partyLeader.getName());
          }
 
          SystemMessage msg = new SystemMessage(SystemMessageId.S1S_PARTY_HAS_BEEN_CHALLENGED_TO_A_DUEL);
          msg.addString(partyLeader.getName());
          activeChar.sendPacket(msg);
 
          msg = new SystemMessage(SystemMessageId.S1S_PARTY_HAS_CHALLENGED_YOUR_PARTY_TO_A_DUEL);
          msg.addString(activeChar.getName());
          targetChar.sendPacket(msg);
        }
        else
        {
          SystemMessage msg = new SystemMessage(SystemMessageId.S1_IS_BUSY_TRY_LATER);
          msg.addString(partyLeader.getName());
          activeChar.sendPacket(msg);
        }
      }
    }
    else
View Full Code Here

TOP

Related Classes of com.l2jfrozen.gameserver.model.actor.instance.L2PcInstance

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.