/**
  * @param activeChar
  * @param player
  */
 private void gatherCharacterInfo(L2PcInstance activeChar, L2PcInstance player, String filename) {
   String ip = "N/A";
   String account = "N/A";
   try {
     String clientInfo = player.getClient().toString();
     account =
         clientInfo.substring(clientInfo.indexOf("Account: ") + 9, clientInfo.indexOf(" - IP: "));
     ip = clientInfo.substring(clientInfo.indexOf(" - IP: ") + 7, clientInfo.lastIndexOf("]"));
   } catch (Exception e) {
   }
   NpcHtmlMessage adminReply = new NpcHtmlMessage(5);
   adminReply.setFile("data/html/admin/" + filename);
   adminReply.replace("%name%", player.getName());
   adminReply.replace("%level%", String.valueOf(player.getLevel()));
   adminReply.replace(
       "%clan%", String.valueOf(ClanTable.getInstance().getClan(player.getClanId())));
   adminReply.replace("%xp%", String.valueOf(player.getExp()));
   adminReply.replace("%sp%", String.valueOf(player.getSp()));
   adminReply.replace("%class%", player.getTemplate().className);
   adminReply.replace("%ordinal%", String.valueOf(player.getClassId().ordinal()));
   adminReply.replace("%classid%", String.valueOf(player.getClassId()));
   adminReply.replace("%x%", String.valueOf(player.getX()));
   adminReply.replace("%y%", String.valueOf(player.getY()));
   adminReply.replace("%z%", String.valueOf(player.getZ()));
   adminReply.replace("%currenthp%", String.valueOf((int) player.getCurrentHp()));
   adminReply.replace("%maxhp%", String.valueOf(player.getMaxHp()));
   adminReply.replace("%karma%", String.valueOf(player.getKarma()));
   adminReply.replace("%currentmp%", String.valueOf((int) player.getCurrentMp()));
   adminReply.replace("%maxmp%", String.valueOf(player.getMaxMp()));
   adminReply.replace("%pvpflag%", String.valueOf(player.getPvpFlag()));
   adminReply.replace("%currentcp%", String.valueOf((int) player.getCurrentCp()));
   adminReply.replace("%maxcp%", String.valueOf(player.getMaxCp()));
   adminReply.replace("%pvpkills%", String.valueOf(player.getPvpKills()));
   adminReply.replace("%pkkills%", String.valueOf(player.getPkKills()));
   adminReply.replace("%currentload%", String.valueOf(player.getCurrentLoad()));
   adminReply.replace("%maxload%", String.valueOf(player.getMaxLoad()));
   adminReply.replace(
       "%percent%",
       String.valueOf(
           Util.roundTo(
               ((float) player.getCurrentLoad() / (float) player.getMaxLoad()) * 100, 2)));
   adminReply.replace("%patk%", String.valueOf(player.getPAtk(null)));
   adminReply.replace("%matk%", String.valueOf(player.getMAtk(null, null)));
   adminReply.replace("%pdef%", String.valueOf(player.getPDef(null)));
   adminReply.replace("%mdef%", String.valueOf(player.getMDef(null, null)));
   adminReply.replace("%accuracy%", String.valueOf(player.getAccuracy()));
   adminReply.replace("%evasion%", String.valueOf(player.getEvasionRate(null)));
   adminReply.replace("%critical%", String.valueOf(player.getCriticalHit(null, null)));
   adminReply.replace("%runspeed%", String.valueOf(player.getRunSpeed()));
   adminReply.replace("%patkspd%", String.valueOf(player.getPAtkSpd()));
   adminReply.replace("%matkspd%", String.valueOf(player.getMAtkSpd()));
   adminReply.replace("%access%", String.valueOf(player.getAccessLevel().getLevel()));
   adminReply.replace("%account%", account);
   adminReply.replace("%ip%", ip);
   activeChar.sendPacket(adminReply);
 }
Beispiel #2
0
  public void reduceHp(
      double value, L2Character attacker, boolean awake, boolean isDOT, boolean isHPConsumption) {
    if (getActiveChar().isDead()) return;

    // invul handling
    if (getActiveChar().isInvul()) {
      // other chars can't damage
      if (attacker != getActiveChar()) return;

      // only DOT and HP consumption allowed for damage self
      if (!isDOT && !isHPConsumption) return;
    }

    if (attacker != null) {
      final L2PcInstance attackerPlayer = attacker.getActingPlayer();
      if (attackerPlayer != null
          && attackerPlayer.isGM()
          && !attackerPlayer.getAccessLevel().canGiveDamage()) return;
    }

    if (!isDOT && !isHPConsumption) {
      getActiveChar().stopEffectsOnDamage(awake);

      if (getActiveChar().isStunned() && Rnd.get(10) == 0) getActiveChar().stopStunning(true);

      if (getActiveChar().isImmobileUntilAttacked())
        getActiveChar().stopImmobileUntilAttacked(null);
    }

    if (value > 0) // Reduce Hp if any
    setCurrentHp(Math.max(getCurrentHp() - value, 0));

    // Die if character is mortal
    if (getActiveChar().getCurrentHp() < 0.5 && getActiveChar().isMortal()) {
      getActiveChar().abortAttack();
      getActiveChar().abortCast();

      getActiveChar().doDie(attacker);
    }
  }
Beispiel #3
0
  @Override
  protected void runImpl() {
    if (_items == null || _items.isEmpty() || !Config.ALLOW_FREIGHT) return;

    final L2PcInstance player = getClient().getActiveChar();
    if (player == null) return;

    // player attempts to send freight to the different account
    if (!player.getAccountChars().containsKey(_objectID)) return;

    final PcFreight freight = player.getDepositedFreight(_objectID);
    player.setActiveWarehouse(freight);

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

    final L2Npc manager = player.getCurrentFolkNPC();
    if ((manager == null
            || !player.isInsideRadius(manager, L2Npc.INTERACTION_DISTANCE, false, false))
        && !player.isGM()) return;

    if (warehouse instanceof PcFreight && !player.getAccessLevel().allowTransaction()) {
      player.sendMessage("Transactions are disabled for your Access Level.");
      return;
    }

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

    // Freight price from config or normal price per item slot (30)
    int fee = _items.size() * Config.ALT_GAME_FREIGHT_PRICE;
    int currentAdena = player.getAdena();
    int slots = 0;

    for (Item i : _items) {
      int objectId = i.id;
      int count = i.count;

      // Check validity of requested item
      ItemInstance item = player.checkItemManipulation(objectId, count);
      if (item == null) {
        _log.warning(
            "Error depositing a warehouse object for char "
                + player.getName()
                + " (validity check)");
        i.id = 0;
        i.count = 0;
        continue;
      }

      if (!item.isTradable() || item.isQuestItem()) return;

      // Calculate needed adena and slots
      if (item.getItemId() == 57) currentAdena -= count;

      if (!item.isStackable()) slots += count;
      else if (warehouse.getItemByItemId(item.getItemId()) == null) slots++;
    }

    // Item Max Limit Check
    if (!warehouse.validateCapacity(slots)) {
      sendPacket(
          SystemMessage.getSystemMessage(
              SystemMessageId.YOU_HAVE_EXCEEDED_QUANTITY_THAT_CAN_BE_INPUTTED));
      return;
    }

    // Check if enough adena and charge the fee
    if (currentAdena < fee
        || !player.reduceAdena("Warehouse", fee, player.getCurrentFolkNPC(), false)) {
      sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_NOT_ENOUGH_ADENA));
      return;
    }

    // Proceed to the transfer
    InventoryUpdate playerIU = new InventoryUpdate();
    for (Item i : _items) {
      int objectId = i.id;
      int count = i.count;

      // check for an invalid item
      if (objectId == 0 && count == 0) continue;

      ItemInstance oldItem = player.getInventory().getItemByObjectId(objectId);
      if (oldItem == null) {
        _log.warning(
            "Error depositing a warehouse object for char "
                + player.getName()
                + " (olditem == null)");
        continue;
      }

      if (oldItem.isHeroItem()) continue;

      ItemInstance newItem =
          player
              .getInventory()
              .transferItem(
                  "Warehouse", objectId, count, warehouse, player, player.getCurrentFolkNPC());
      if (newItem == null) {
        _log.warning(
            "Error depositing a warehouse object for char "
                + player.getName()
                + " (newitem == null)");
        continue;
      }

      if (oldItem.getCount() > 0 && oldItem != newItem) playerIU.addModifiedItem(oldItem);
      else playerIU.addRemovedItem(oldItem);
    }

    // Send updated item list to the player
    player.sendPacket(playerIU);

    // Update current load status on player
    StatusUpdate su = new StatusUpdate(player);
    su.addAttribute(StatusUpdate.CUR_LOAD, player.getCurrentLoad());
    player.sendPacket(su);
  }
  @Override
  protected void runImpl() {
    if (!FloodProtectors.performAction(getClient(), Action.SERVER_BYPASS)) return;

    final L2PcInstance activeChar = getClient().getActiveChar();
    if (activeChar == null) return;

    if (_command.isEmpty()) {
      _log.info(activeChar.getName() + " sent an empty requestBypass packet.");
      activeChar.logout();
      return;
    }

    try {
      if (_command.startsWith("admin_")) {
        String command = _command.split(" ")[0];

        IAdminCommandHandler ach =
            AdminCommandHandler.getInstance().getAdminCommandHandler(command);
        if (ach == null) {
          if (activeChar.isGM())
            activeChar.sendMessage("The command " + command.substring(6) + " doesn't exist.");

          _log.warning("No handler registered for admin command '" + command + "'");
          return;
        }

        if (!AdminCommandAccessRights.getInstance()
            .hasAccess(command, activeChar.getAccessLevel())) {
          activeChar.sendMessage("You don't have the access rights to use this command.");
          _log.warning(
              activeChar.getName()
                  + " tried to use admin command "
                  + command
                  + " without proper Access Level.");
          return;
        }

        if (Config.GMAUDIT)
          GMAudit.auditGMAction(
              activeChar.getName() + " [" + activeChar.getObjectId() + "]",
              _command,
              (activeChar.getTarget() != null ? activeChar.getTarget().getName() : "no-target"));

        ach.useAdminCommand(_command, activeChar);
      } else if (_command.startsWith("player_help ")) {
        playerHelp(activeChar, _command.substring(12));
      } else if (_command.startsWith("npc_")) {
        if (!activeChar.validateBypass(_command)) return;

        int endOfId = _command.indexOf('_', 5);
        String id;
        if (endOfId > 0) id = _command.substring(4, endOfId);
        else id = _command.substring(4);

        try {
          final L2Object object = L2World.getInstance().getObject(Integer.parseInt(id));

          if (object != null
              && object instanceof L2Npc
              && endOfId > 0
              && ((L2Npc) object).canInteract(activeChar))
            ((L2Npc) object).onBypassFeedback(activeChar, _command.substring(endOfId + 1));

          activeChar.sendPacket(ActionFailed.STATIC_PACKET);
        } catch (NumberFormatException nfe) {
        }
      }
      // Navigate throught Manor windows
      else if (_command.startsWith("manor_menu_select?")) {
        L2Object object = activeChar.getTarget();
        if (object instanceof L2Npc) ((L2Npc) object).onBypassFeedback(activeChar, _command);
      } else if (_command.startsWith("bbs_")
          || _command.startsWith("_bbs")
          || _command.startsWith("_friend")
          || _command.startsWith("_mail")
          || _command.startsWith("_block")) {
        CommunityBoard.getInstance().handleCommands(getClient(), _command);
      } else if (_command.startsWith("Quest ")) {
        if (!activeChar.validateBypass(_command)) return;

        String[] str = _command.substring(6).trim().split(" ", 2);
        if (str.length == 1) activeChar.processQuestEvent(str[0], "");
        else activeChar.processQuestEvent(str[0], str[1]);
      } else if (_command.startsWith("_match")) {
        String params = _command.substring(_command.indexOf("?") + 1);
        StringTokenizer st = new StringTokenizer(params, "&");
        int heroclass = Integer.parseInt(st.nextToken().split("=")[1]);
        int heropage = Integer.parseInt(st.nextToken().split("=")[1]);
        int heroid = Hero.getInstance().getHeroByClass(heroclass);
        if (heroid > 0) Hero.getInstance().showHeroFights(activeChar, heroclass, heroid, heropage);
      } else if (_command.startsWith("_diary")) {
        String params = _command.substring(_command.indexOf("?") + 1);
        StringTokenizer st = new StringTokenizer(params, "&");
        int heroclass = Integer.parseInt(st.nextToken().split("=")[1]);
        int heropage = Integer.parseInt(st.nextToken().split("=")[1]);
        int heroid = Hero.getInstance().getHeroByClass(heroclass);
        if (heroid > 0) Hero.getInstance().showHeroDiary(activeChar, heroclass, heroid, heropage);
      } else if (_command.startsWith("arenachange")) // change
      {
        final boolean isManager =
            activeChar.getCurrentFolkNPC() instanceof L2OlympiadManagerInstance;
        if (!isManager) {
          // Without npc, command can be used only in observer mode on arena
          if (!activeChar.inObserverMode()
              || activeChar.isInOlympiadMode()
              || activeChar.getOlympiadGameId() < 0) return;
        }

        if (OlympiadManager.getInstance().isRegisteredInComp(activeChar)) {
          activeChar.sendPacket(
              SystemMessageId
                  .WHILE_YOU_ARE_ON_THE_WAITING_LIST_YOU_ARE_NOT_ALLOWED_TO_WATCH_THE_GAME);
          return;
        }

        final int arenaId = Integer.parseInt(_command.substring(12).trim());
        activeChar.enterOlympiadObserverMode(arenaId);
      }
    } catch (Exception e) {
      _log.log(Level.WARNING, "Bad RequestBypassToServer: ", e);
    }
  }
Beispiel #5
0
  @Override
  protected void runImpl() {
    if (_items == null) return;

    final L2PcInstance player = getClient().getActiveChar();
    if (player == null) return;

    if (player.isProcessingTransaction()) {
      player.sendPacket(SystemMessageId.ALREADY_TRADING);
      return;
    }

    if (player.getActiveEnchantItem() != null) {
      player.setActiveEnchantItem(null);
      player.sendPacket(EnchantResult.CANCELLED);
      player.sendPacket(SystemMessageId.ENCHANT_SCROLL_CANCELLED);
    }

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

    final boolean isPrivate = warehouse instanceof PcWarehouse;

    final L2Npc manager = player.getCurrentFolkNPC();
    if ((manager == null || !manager.isWarehouse() || !manager.canInteract(player))
        && !player.isGM()) return;

    if (!isPrivate && !player.getAccessLevel().allowTransaction()) {
      player.sendMessage("Transactions are disabled for your Access Level.");
      return;
    }

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

    // Freight price from config or normal price per item slot (30)
    final int fee = _items.length * 30;
    int currentAdena = player.getAdena();
    int slots = 0;

    for (WarehouseItem i : _items) {
      ItemInstance item = player.checkItemManipulation(i.getObjectId(), i.getCount());
      if (item == null) {
        _log.warning(
            "Error depositing a warehouse object for char "
                + player.getName()
                + " (validity check)");
        return;
      }

      // Calculate needed adena and slots
      if (item.getItemId() == ADENA_ID) currentAdena -= i.getCount();
      if (!item.isStackable()) slots += i.getCount();
      else if (warehouse.getItemByItemId(item.getItemId()) == null) slots++;
    }

    // Item Max Limit Check
    if (!warehouse.validateCapacity(slots)) {
      sendPacket(
          SystemMessage.getSystemMessage(
              SystemMessageId.YOU_HAVE_EXCEEDED_QUANTITY_THAT_CAN_BE_INPUTTED));
      return;
    }

    // Check if enough adena and charge the fee
    if (currentAdena < fee || !player.reduceAdena(warehouse.getName(), fee, manager, false)) {
      sendPacket(SystemMessage.getSystemMessage(SystemMessageId.YOU_NOT_ENOUGH_ADENA));
      return;
    }

    // get current tradelist if any
    if (player.getActiveTradeList() != null) return;

    // Proceed to the transfer
    InventoryUpdate playerIU = new InventoryUpdate();
    for (WarehouseItem i : _items) {
      // Check validity of requested item
      ItemInstance oldItem = player.checkItemManipulation(i.getObjectId(), i.getCount());
      if (oldItem == null) {
        _log.warning(
            "Error depositing a warehouse object for char "
                + player.getName()
                + " (olditem == null)");
        return;
      }

      if (!oldItem.isDepositable(isPrivate) || !oldItem.isAvailable(player, true, isPrivate))
        continue;

      final ItemInstance newItem =
          player
              .getInventory()
              .transferItem(
                  warehouse.getName(), i.getObjectId(), i.getCount(), warehouse, player, manager);
      if (newItem == null) {
        _log.warning(
            "Error depositing a warehouse object for char "
                + player.getName()
                + " (newitem == null)");
        continue;
      }

      if (oldItem.getCount() > 0 && oldItem != newItem) playerIU.addModifiedItem(oldItem);
      else playerIU.addRemovedItem(oldItem);
    }

    // Send updated item list to the player
    player.sendPacket(playerIU);

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