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

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


   
    if(isAllSkillsDisabled() && !skill.isPotion())
      return true;

    if(this instanceof L2PcInstance){
      L2PcInstance activeChar = (L2PcInstance) this;
     
      if((skill.getSkillType()==SkillType.FISHING || skill.getSkillType()==SkillType.REELING || skill.getSkillType()==SkillType.PUMPING) && !activeChar.isFishing() && (activeChar.getActiveWeaponItem() != null && activeChar.getActiveWeaponItem().getItemType()!=L2WeaponType.ROD))
      {
        if(skill.getSkillType()==SkillType.PUMPING)
        {
          // Pumping skill is available only while fishing
          activeChar.sendPacket(new SystemMessage(SystemMessageId.CAN_USE_PUMPING_ONLY_WHILE_FISHING));
        }
        else if(skill.getSkillType()==SkillType.REELING)
        {
          // Reeling skill is available only while fishing
          activeChar.sendPacket(new SystemMessage(SystemMessageId.CAN_USE_REELING_ONLY_WHILE_FISHING));
        }
        else if(skill.getSkillType()==SkillType.FISHING)
        {
          // Player hasn't fishing pole equiped
          activeChar.sendPacket(new SystemMessage(SystemMessageId.FISHING_POLE_NOT_EQUIPPED));
        }
       
        SystemMessage sm = new SystemMessage(SystemMessageId.S1_CANNOT_BE_USED);
        sm.addString(skill.getName());
        activeChar.sendPacket(sm);
        return true;
      }
     
      if((skill.getSkillType()==SkillType.FISHING || skill.getSkillType()==SkillType.REELING || skill.getSkillType()==SkillType.PUMPING) && activeChar.getActiveWeaponItem() == null)
      {
        SystemMessage sm = new SystemMessage(SystemMessageId.S1_CANNOT_BE_USED);
        sm.addString(skill.getName());
        activeChar.sendPacket(sm);
        return true;
      }
     
      if((skill.getSkillType()==SkillType.REELING || skill.getSkillType()==SkillType.PUMPING) && !activeChar.isFishing() && (activeChar.getActiveWeaponItem() != null && activeChar.getActiveWeaponItem().getItemType()==L2WeaponType.ROD))
      {
        if(skill.getSkillType()==SkillType.PUMPING)
        {
          // Pumping skill is available only while fishing
          activeChar.sendPacket(new SystemMessage(SystemMessageId.CAN_USE_PUMPING_ONLY_WHILE_FISHING));
        }
        else if(skill.getSkillType()==SkillType.REELING)
        {
          // Reeling skill is available only while fishing
          activeChar.sendPacket(new SystemMessage(SystemMessageId.CAN_USE_REELING_ONLY_WHILE_FISHING));
        }
       
        SystemMessage sm = new SystemMessage(SystemMessageId.S1_CANNOT_BE_USED);
        sm.addString(skill.getName());
        activeChar.sendPacket(sm);
        return true;
      }
     
      if(activeChar.isHero() && HeroSkillTable.isHeroSkill(skillId) && activeChar.isInOlympiadMode() && activeChar.isOlympiadStart()){
        activeChar.sendMessage("You can't use Hero skills during Olympiad match.");
        return true;
      }
    }
   
    if(_disabledSkills == null)
View Full Code Here


              }
              return;
            }
          }
         
          L2PcInstance activeChar = null;
         
          if (this instanceof L2PcInstance)
          {
            activeChar = (L2PcInstance) this;
          }
          else if (this instanceof L2Summon)
          {
            activeChar = ((L2Summon) this).getOwner();
          }
         
          if (activeChar != null)
          {
            if (skill.isOffensive())
            {
              if (player instanceof L2PcInstance || player instanceof L2Summon)
              {
                // Signets are a special case, casted on target_self but don't harm self
                if (skill.getSkillType() != L2Skill.SkillType.SIGNET && skill.getSkillType() != L2Skill.SkillType.SIGNET_CASTTIME)
                {
                  player.getAI().notifyEvent(CtrlEvent.EVT_ATTACKED, activeChar);
                  activeChar.updatePvPStatus(player);
                }
              }
              else if (player instanceof L2Attackable)
              {
                switch (skill.getSkillType())
                {
                  case AGGREDUCE:
                  case AGGREDUCE_CHAR:
                  case AGGREMOVE:
                    break;
                  default:
                    ((L2Character) target).addAttackerToAttackByList(this);
                    // notify the AI that she is attacked
                    ((L2Character) target).getAI().notifyEvent(CtrlEvent.EVT_ATTACKED, this);
                    break;
                }
              }
            }
            else
            {
              if (player instanceof L2PcInstance)
              {
                // Casting non offensive skill on player with pvp flag set or with karma
                if (!player.equals(this) && (((L2PcInstance) player).getPvpFlag() > 0 || ((L2PcInstance) player).getKarma() > 0))
                {
                  activeChar.updatePvPStatus();
                }
              }
              else if (player instanceof L2Attackable && !(skill.getSkillType() == L2Skill.SkillType.SUMMON) && !(skill.getSkillType() == L2Skill.SkillType.BEAST_FEED) && !(skill.getSkillType() == L2Skill.SkillType.UNLOCK) && !(skill.getSkillType() == L2Skill.SkillType.DELUXE_KEY_UNLOCK))
              {
                activeChar.updatePvPStatus(this);
              }
            }
            player = null;
            // activeWeapon = null;
          }
          activeChar = null;
        }
        if (target instanceof L2MonsterInstance)
        {
          if (!skill.isOffensive() && skill.getSkillType() != SkillType.UNLOCK && skill.getSkillType() != SkillType.SUMMON && skill.getSkillType() != SkillType.DELUXE_KEY_UNLOCK && skill.getSkillType() != SkillType.BEAST_FEED)
          {
            L2PcInstance activeChar = null;
           
            if (this instanceof L2PcInstance)
            {
              activeChar = (L2PcInstance) this;
              activeChar.updatePvPStatus(activeChar);
            }
            else if (this instanceof L2Summon)
            {
              activeChar = ((L2Summon) this).getOwner();
            }
          }
        }
      }
     
      ISkillHandler handler = null;
     
      if (skill.isToggle())
      {
        // Check if the skill effects are already in progress on the L2Character
        if (getFirstEffect(skill.getId()) != null)
        {
          handler = SkillHandler.getInstance().getSkillHandler(skill.getSkillType());
         
          if (handler != null)
          {
            handler.useSkill(this, skill, targets);
          }
          else
          {
            skill.useSkill(this, targets);
          }
         
          return;
        }
      }/*
       * TODO else { if(this instanceof L2PcInstance || this instanceof L2Summon) { L2PcInstance caster = this instanceof L2PcInstance ? (L2PcInstance) this : ((L2Summon) this).getOwner(); for(L2Object target : targets) { if(target instanceof L2NpcInstance) { if (((L2NpcInstance)
       * target).getTemplate().getEventQuests(Quest.QuestEventType.ON_SKILL_USE) != null) { for(Quest quest : ((L2NpcInstance) target).getTemplate().getEventQuests(Quest.QuestEventType.ON_SKILL_USE)) { quest.notifySkillUse((L2NpcInstance) target, caster, skill); } } } } caster = null; } }
       */
     
      // Check if over-hit is possible
      if (skill.isOverhit())
      {
        // Set the "over-hit enabled" flag on each of the possible targets
        for (L2Object target : targets)
        {
          L2Character player = (L2Character) target;
          if (player instanceof L2Attackable)
          {
            ((L2Attackable) player).overhitEnabled(true);
          }
         
          player = null;
        }
      }
     
      // Get the skill handler corresponding to the skill type (PDAM, MDAM, SWEEP...) started in gameserver
      handler = SkillHandler.getInstance().getSkillHandler(skill.getSkillType());
     
      // Launch the magic skill and calculate its effects
      if (handler != null)
      {
        handler.useSkill(this, skill, targets);
      }
      else
      {
        skill.useSkill(this, targets);
      }
     
      // if the skill is a potion, must delete the potion item
      if (skill.isPotion() && this instanceof L2PlayableInstance)
      {
        Potions.delete_Potion_Item((L2PlayableInstance) this, skill.getId(), skill.getLevel());
      }
     
      if (this instanceof L2PcInstance || this instanceof L2Summon)
      {
        L2PcInstance caster = this instanceof L2PcInstance ? (L2PcInstance) this : ((L2Summon) this).getOwner();
        for (L2Object target : targets)
        {
          if (target instanceof L2NpcInstance)
          {
            L2NpcInstance npc = (L2NpcInstance) target;
           
            for (Quest quest : npc.getTemplate().getEventQuests(Quest.QuestEventType.ON_SKILL_USE))
            {
              quest.notifySkillUse(npc, caster, skill);
            }
           
            npc = null;
          }
        }
       
        if (skill.getAggroPoints() > 0)
        {
          for (L2Object spMob : caster.getKnownList().getKnownObjects().values())
            if (spMob instanceof L2NpcInstance)
            {
              L2NpcInstance npcMob = (L2NpcInstance) spMob;
             
              if (npcMob.isInsideRadius(caster, 1000, true, true) && npcMob.hasAI() && npcMob.getAI().getIntention() == AI_INTENTION_ATTACK)
View Full Code Here

  }
 
  @Override
  protected void runImpl()
  {
    L2PcInstance player = getClient().getActiveChar();
    if (player == null)
      return;
   
    if (!getClient().getFloodProtectors().getTransaction().tryPerformAction("privatestoresell"))
    {
      player.sendMessage("You selling items too fast");
      return;
    }
   
    L2Object object = L2World.getInstance().findObject(_storePlayerId);
    if (object == null || !(object instanceof L2PcInstance))
      return;
   
    L2PcInstance storePlayer = (L2PcInstance) object;
    if (storePlayer.getPrivateStoreType() != L2PcInstance.STORE_PRIVATE_BUY)
      return;
   
    TradeList storeList = storePlayer.getBuyList();
    if (storeList == null)
      return;
   
    // Check if player didn't choose any items
    if (_items == null || _items.length == 0)
    {
      player.sendPacket(ActionFailed.STATIC_PACKET);
      return;
    }
   
    if (storeList.getItemCount() == 0)
    {
      storePlayer.setPrivateStoreType(L2PcInstance.STORE_PRIVATE_NONE);
      storePlayer.broadcastUserInfo();
      return;
    }
   
    if (!player.getAccessLevel().allowTransaction())
    {
      player.sendMessage("Unsufficient privileges.");
      player.sendPacket(ActionFailed.STATIC_PACKET);
      return;
    }
   
    if (Config.SELL_BY_ITEM)
    {
      if (storePlayer.getItemCount(Config.SELL_ITEM, -1) < _price)
      {
        sendPacket(ActionFailed.STATIC_PACKET);
        sendPacket(SystemMessage.sendString("You have not enough items to buy, canceling PrivateBuy"));
        storePlayer.setPrivateStoreType(L2PcInstance.STORE_PRIVATE_NONE);
        storePlayer.broadcastUserInfo();
        return;
      }
     
    }
    else
    {
      if (storePlayer.getAdena() < _price)
      {
        sendPacket(ActionFailed.STATIC_PACKET);
        storePlayer.sendMessage("You have not enough adena, canceling PrivateBuy.");
        storePlayer.setPrivateStoreType(L2PcInstance.STORE_PRIVATE_NONE);
        storePlayer.broadcastUserInfo();
        return;
      }
    }
   
    if (!storeList.PrivateStoreSell(player, _items, _price))
    {
      sendPacket(ActionFailed.STATIC_PACKET);
      Util.handleIllegalPlayerAction(getClient().getActiveChar(), "Player " + getClient().getActiveChar().getName() + " provided invalid list or request! ", Config.DEFAULT_PUNISH);
      _log.warning("PrivateStore sell has failed due to invalid list or request. Player: " + player.getName() + ", Private store of: " + storePlayer.getName());
      return;
    }
   
    if (storeList.getItemCount() == 0)
    {
      storePlayer.setPrivateStoreType(L2PcInstance.STORE_PRIVATE_NONE);
      storePlayer.broadcastUserInfo();
    }
   
  }
View Full Code Here

  }
 
  @Override
  protected void runImpl()
  {
    L2PcInstance player = getClient().getActiveChar();
    if (player == null)
      return;
   
    player.setPrivateStoreType(L2PcInstance.STORE_PRIVATE_NONE);
    player.standUp();
    player.broadcastUserInfo();
  }
View Full Code Here

  }

  @Override
  protected void runImpl()
  {
    L2PcInstance activeChar = getClient().getActiveChar();
    L2ItemInstance targetItem = (L2ItemInstance) L2World.getInstance().findObject(_targetItemObjId);

    if(activeChar == null)
      return;

    if(targetItem == null)
    {
      activeChar.sendPacket(new ExVariationCancelResult(0));
      return;
    }

    // cannot remove augmentation from a not augmented item
    if(!targetItem.isAugmented())
    {
      activeChar.sendPacket(new SystemMessage(SystemMessageId.AUGMENTATION_REMOVAL_CAN_ONLY_BE_DONE_ON_AN_AUGMENTED_ITEM));
      activeChar.sendPacket(new ExVariationCancelResult(0));
      return;
    }

    // get the price
    int price = 0;
    switch(targetItem.getItem().getItemGrade())
    {
      case L2Item.CRYSTAL_C:
        if(targetItem.getCrystalCount() < 1720)
        {
          price = 95000;
        }
        else if(targetItem.getCrystalCount() < 2452)
        {
          price = 150000;
        }
        else
        {
          price = 210000;
        }
        break;
      case L2Item.CRYSTAL_B:
        if(targetItem.getCrystalCount() < 1746)
        {
          price = 240000;
        }
        else
        {
          price = 270000;
        }
        break;
      case L2Item.CRYSTAL_A:
        if(targetItem.getCrystalCount() < 2160)
        {
          price = 330000;
        }
        else if(targetItem.getCrystalCount() < 2824)
        {
          price = 390000;
        }
        else
        {
          price = 420000;
        }
        break;
      case L2Item.CRYSTAL_S:
        price = 480000;
        break;
      // any other item type is not augmentable
      default:
        activeChar.sendPacket(new ExVariationCancelResult(0));
        return;
    }

    // try to reduce the players adena
    if(!activeChar.reduceAdena("RequestRefineCancel", price, null, true))
      return;

    // unequip item
    if(targetItem.isEquipped())
    {
      activeChar.disarmWeapons();
    }

    // remove the augmentation
    targetItem.removeAugmentation();

    // send ExVariationCancelResult
    activeChar.sendPacket(new ExVariationCancelResult(1));

    // send inventory update
    InventoryUpdate iu = new InventoryUpdate();
    iu.addModifiedItem(targetItem);
    activeChar.sendPacket(iu);

    // send system message
    SystemMessage sm = new SystemMessage(SystemMessageId.AUGMENTATION_HAS_BEEN_SUCCESSFULLY_REMOVED_FROM_YOUR_S1);
    sm.addString(targetItem.getItemName());
    activeChar.sendPacket(sm);
  }
View Full Code Here

  }

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

    if(activeChar == null)
      return;

    L2Clan clan = activeChar.getClan();
    if(clan == null)
      return;

    if(_data == null)
    {
      CrestCache.getInstance().removePledgeCrestLarge(clan.getCrestId());

      clan.setHasCrestLarge(false);
      activeChar.sendMessage("The insignia has been removed.");

      for(L2PcInstance member : clan.getOnlineMembers(""))
      {
        member.broadcastUserInfo();
      }

      return;
    }

    if(_size > 2176)
    {
      activeChar.sendMessage("The insignia file size is greater than 2176 bytes.");
      return;
    }

    if((activeChar.getClanPrivileges() & L2Clan.CP_CL_REGISTER_CREST) == L2Clan.CP_CL_REGISTER_CREST)
    {
      if(clan.getHasCastle() == 0 && clan.getHasHideout() == 0)
      {
        activeChar.sendMessage("Only a clan that owns a clan hall or a castle can get their emblem displayed on clan related items"); //there is a system message for that but didnt found the id
        return;
      }

      CrestCache crestCache = CrestCache.getInstance();

      int newId = IdFactory.getInstance().getNextId();

      if(!crestCache.savePledgeCrestLarge(newId, _data))
      {
        _log.log(Level.INFO, "Error loading large crest of clan:" + clan.getName());
        return;
      }

      if(clan.hasCrestLarge())
      {
        crestCache.removePledgeCrestLarge(clan.getCrestLargeId());
      }

      Connection con = null;

      try
      {
        con = L2DatabaseFactory.getInstance().getConnection(false);
        PreparedStatement statement = con.prepareStatement("UPDATE clan_data SET crest_large_id = ? WHERE clan_id = ?");
        statement.setInt(1, newId);
        statement.setInt(2, clan.getClanId());
        statement.executeUpdate();
        statement.close();

        statement = null;
      }
      catch(SQLException e)
      {
        if(Config.ENABLE_ALL_EXCEPTIONS)
          e.printStackTrace();
       
        _log.warning("could not update the large crest id:" + e.getMessage());
      }
      finally
      {
        CloseUtil.close(con);
        con = null;
      }

      clan.setCrestLargeId(newId);
      clan.setHasCrestLarge(true);

      activeChar.sendPacket(new SystemMessage(SystemMessageId.CLAN_EMBLEM_WAS_SUCCESSFULLY_REGISTERED));

      for(L2PcInstance member : clan.getOnlineMembers(""))
      {
        member.broadcastUserInfo();
      }
View Full Code Here

  }
 
  @Override
  public void runImpl()
  {
    L2PcInstance pl = _client.getActiveChar();
    if (pl != null)
      pl.sendPacket(new SkillCoolTime(pl));
  }
View Full Code Here

  }
 
  @Override
  protected void runImpl()
  {
    L2PcInstance player = (L2PcInstance) L2World.getInstance().findObject(_snoopID);
    if (player == null)
      return;
   
    L2PcInstance activeChar = getClient().getActiveChar();
    if (activeChar == null)
      return;
   
    player.removeSnooper(activeChar);
    activeChar.removeSnooped(player);
  }
View Full Code Here

  }
 
  @Override
  protected void runImpl()
  {
    L2PcInstance activeChar = getClient().getActiveChar();
    L2ItemInstance item = (L2ItemInstance) L2World.getInstance().findObject(_itemId);

    if(activeChar == null || item == null)
      return;

    if(!item.isAugmented())
    {
      activeChar.sendPacket(new SystemMessage(SystemMessageId.AUGMENTATION_REMOVAL_CAN_ONLY_BE_DONE_ON_AN_AUGMENTED_ITEM));
      return;
    }

    int price = 0;
    switch(item.getItem().getItemGrade())
    {
      case L2Item.CRYSTAL_C:
        if(item.getCrystalCount() < 1720)
        {
          price = 95000;
        }
        else if(item.getCrystalCount() < 2452)
        {
          price = 150000;
        }
        else
        {
          price = 210000;
        }
        break;
      case L2Item.CRYSTAL_B:
        if(item.getCrystalCount() < 1746)
        {
          price = 240000;
        }
        else
        {
          price = 270000;
        }
        break;
      case L2Item.CRYSTAL_A:
        if(item.getCrystalCount() < 2160)
        {
          price = 330000;
        }
        else if(item.getCrystalCount() < 2824)
        {
          price = 390000;
        }
        else
        {
          price = 420000;
        }
        break;
      case L2Item.CRYSTAL_S:
        price = 480000;
        break;
      // any other item type is not augmentable
      default:
        return;
    }

    activeChar.sendPacket(new ExConfirmCancelItem(_itemId, price));
  }
View Full Code Here

  }

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

    if(activeChar == null)
    {
      _log.fine("RequestCrystalizeItem: activeChar was null");
      return;
    }
   
    if (!getClient().getFloodProtectors().getTransaction().tryPerformAction("crystallize"))
    {
      activeChar.sendMessage("You crystallizing too fast.");
      return;
    }
   

    if(_count <= 0)
    {
      Util.handleIllegalPlayerAction(activeChar, "[RequestCrystallizeItem] count <= 0! ban! oid: " + _objectId + " owner: " + activeChar.getName(), IllegalPlayerAction.PUNISH_KICK);
      return;
    }

    if(activeChar.getPrivateStoreType() != 0 || activeChar.isInCrystallize())
    {
      activeChar.sendPacket(new SystemMessage(SystemMessageId.CANNOT_TRADE_DISCARD_DROP_ITEM_WHILE_IN_SHOPMODE));
      return;
    }

    int skillLevel = activeChar.getSkillLevel(L2Skill.SKILL_CRYSTALLIZE);
    if(skillLevel <= 0)
    {
      SystemMessage sm = new SystemMessage(SystemMessageId.CRYSTALLIZE_LEVEL_TOO_LOW);
      activeChar.sendPacket(sm);
      sm = null;
      ActionFailed af = ActionFailed.STATIC_PACKET;
      activeChar.sendPacket(af);
      return;
    }

    PcInventory inventory = activeChar.getInventory();
    if(inventory != null)
    {
      L2ItemInstance item = inventory.getItemByObjectId(_objectId);
      if(item == null || item.isWear())
      {
        ActionFailed af = ActionFailed.STATIC_PACKET;
        activeChar.sendPacket(af);
        return;
      }

      int itemId = item.getItemId();

      if(itemId >= 6611 && itemId <= 6621 || itemId == 6842)
        return;

      if(_count > item.getCount())
      {
        _count = activeChar.getInventory().getItemByObjectId(_objectId).getCount();
      }
    }

    L2ItemInstance itemToRemove = activeChar.getInventory().getItemByObjectId(_objectId);

    if(itemToRemove == null || itemToRemove.isWear())
      return;
    if(itemToRemove.fireEvent("CRYSTALLIZE", (Object[]) null) != null)
    {
      activeChar.sendPacket(new SystemMessage(SystemMessageId.CANNOT_DISCARD_THIS_ITEM));
      return;
    }

    if(!itemToRemove.getItem().isCrystallizable() || itemToRemove.getItem().getCrystalCount() <= 0 || itemToRemove.getItem().getCrystalType() == L2Item.CRYSTAL_NONE)
    {
      _log.warning("" + activeChar.getObjectId() + " tried to crystallize " + itemToRemove.getItem().getItemId());
      return;
    }

    // Check if the char can crystallize C items and return if false;
    if(itemToRemove.getItem().getCrystalType() == L2Item.CRYSTAL_C && skillLevel <= 1)
    {
      SystemMessage sm = new SystemMessage(SystemMessageId.CRYSTALLIZE_LEVEL_TOO_LOW);
      activeChar.sendPacket(sm);
      sm = null;
      ActionFailed af = ActionFailed.STATIC_PACKET;
      activeChar.sendPacket(af);
      return;
    }

    // Check if the user can crystallize B items and return if false;
    if(itemToRemove.getItem().getCrystalType() == L2Item.CRYSTAL_B && skillLevel <= 2)
    {
      SystemMessage sm = new SystemMessage(SystemMessageId.CRYSTALLIZE_LEVEL_TOO_LOW);
      activeChar.sendPacket(sm);
      sm = null;
      ActionFailed af = ActionFailed.STATIC_PACKET;
      activeChar.sendPacket(af);
      return;
    }

    // Check if the user can crystallize A items and return if false;
    if(itemToRemove.getItem().getCrystalType() == L2Item.CRYSTAL_A && skillLevel <= 3)
    {
      SystemMessage sm = new SystemMessage(SystemMessageId.CRYSTALLIZE_LEVEL_TOO_LOW);
      activeChar.sendPacket(sm);
      sm = null;
      ActionFailed af = ActionFailed.STATIC_PACKET;
      activeChar.sendPacket(af);
      return;
    }

    // Check if the user can crystallize S items and return if false;
    if(itemToRemove.getItem().getCrystalType() == L2Item.CRYSTAL_S && skillLevel <= 4)
    {
      SystemMessage sm = new SystemMessage(SystemMessageId.CRYSTALLIZE_LEVEL_TOO_LOW);
      activeChar.sendPacket(sm);
      sm = null;
      ActionFailed af = ActionFailed.STATIC_PACKET;
      activeChar.sendPacket(af);
      return;
    }

    activeChar.setInCrystallize(true);

    // unequip if needed
    if(itemToRemove.isEquipped())
    {
      if(itemToRemove.isAugmented())
      {
        itemToRemove.getAugmentation().removeBoni(activeChar);
      }

      L2ItemInstance[] unequiped = activeChar.getInventory().unEquipItemInSlotAndRecord(itemToRemove.getEquipSlot());
      InventoryUpdate iu = new InventoryUpdate();

      for(L2ItemInstance element : unequiped)
      {
        iu.addModifiedItem(element);
      }
      activeChar.sendPacket(iu);
      // activeChar.updatePDef();
      // activeChar.updatePAtk();
      // activeChar.updateMDef();
      // activeChar.updateMAtk();
      // activeChar.updateAccuracy();
      // activeChar.updateCriticalChance();
    }

    // remove from inventory
    L2ItemInstance removedItem = activeChar.getInventory().destroyItem("Crystalize", _objectId, _count, activeChar, null);

    // add crystals
    int crystalId = itemToRemove.getItem().getCrystalItemId();
    int crystalAmount = itemToRemove.getCrystalCount();
    L2ItemInstance createditem = activeChar.getInventory().addItem("Crystalize", crystalId, crystalAmount, activeChar, itemToRemove);

    SystemMessage sm = new SystemMessage(SystemMessageId.EARNED_S2_S1_S);
    sm.addItemName(crystalId);
    sm.addNumber(crystalAmount);
    activeChar.sendPacket(sm);
    sm = null;

    // send inventory update
    if(!Config.FORCE_INVENTORY_UPDATE)
    {
      InventoryUpdate iu = new InventoryUpdate();
      if(removedItem.getCount() == 0)
      {
        iu.addRemovedItem(removedItem);
      }
      else
      {
        iu.addModifiedItem(removedItem);
      }

      if(createditem.getCount() != crystalAmount)
      {
        iu.addModifiedItem(createditem);
      }
      else
      {
        iu.addNewItem(createditem);
      }

      activeChar.sendPacket(iu);
    }
    else
    {
      activeChar.sendPacket(new ItemList(activeChar, false));
    }

    // status & user info
    StatusUpdate su = new StatusUpdate(activeChar.getObjectId());
    su.addAttribute(StatusUpdate.CUR_LOAD, activeChar.getCurrentLoad());
    activeChar.sendPacket(su);

    activeChar.broadcastUserInfo();

    L2World world = L2World.getInstance();
    world.removeObject(removedItem);

    activeChar.setInCrystallize(false);
  }
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.