Package net.sf.l2j.gameserver.model.actor.instance

Examples of net.sf.l2j.gameserver.model.actor.instance.L2PcInstance


    }

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

        L2HennaInstance[] henna = HennaTreeTable.getInstance().getAvailableHenna(activeChar.getClassId());
        HennaEquipList he = new HennaEquipList(activeChar, henna);
        activeChar.sendPacket(he);
    }
View Full Code Here


      sendPacket(ccf);
      return;
    }

    int objectId = IdFactory.getInstance().getNextId();
    L2PcInstance newChar = L2PcInstance.create(objectId, template, getClient().getAccountName(),
        _name, _hairStyle, _hairColor, _face, _sex!=0);
    newChar.setCurrentHp(template.baseHpMax);
    newChar.setCurrentCp(template.baseCpMax);
    newChar.setCurrentMp(template.baseMpMax);
    //newChar.setMaxLoad(template.baseLoad);

    // send acknowledgement
    CharCreateOk cco = new CharCreateOk();
    sendPacket(cco);
View Full Code Here

                  // 1st lethal effect activate (cp to 1 or if target is npc then hp to 50%)
                  if(skill.getLethalChance2() > 0 && chance >= skill.getLethalChance2())
                  {
                     if (target instanceof L2PcInstance)
                    {
                       L2PcInstance player = (L2PcInstance)target;
                    if (!player.isInvul())
                    {
                      player.setCurrentCp(1); // Set CP to 1
                               player.reduceCurrentHp(damage, activeChar);
                    }
                   }
                    else if (target instanceof L2MonsterInstance) // If is a monster remove first damage and after 50% of current hp
                    {
                     target.reduceCurrentHp(damage, activeChar);
                     target.reduceCurrentHp(target.getCurrentHp()/2, activeChar);
                    }
                  }
                  else //2nd lethal effect activate (cp,hp to 1 or if target is npc then hp to 1)
                  {
                         // If is a monster damage is (CurrentHp - 1) so HP = 1
                        if (target instanceof L2NpcInstance)
                            target.reduceCurrentHp(target.getCurrentHp()-1, activeChar);
                  else if (target instanceof L2PcInstance) // If is a active player set his HP and CP to 1
                  {
                    L2PcInstance player = (L2PcInstance)target;
                    if (!player.isInvul())
                    {
                      player.setCurrentHp(1);
                      player.setCurrentCp(1);
                    }
                  }
                  }
                    // Lethal Strike was succefful!
                    activeChar.sendPacket(new SystemMessage(SystemMessageId.LETHAL_STRIKE_SUCCESSFUL));
                }
                else
                {
                  // Make damage directly to HP
                  if(skill.getDmgDirectlyToHP())
                  {
                if(target instanceof L2PcInstance)
                {
                  L2PcInstance player = (L2PcInstance)target;
                      if (!player.isInvul())
                  {
                           if (damage >= player.getCurrentHp())
                           {
                             if (player.isInDuel())
                               player.setCurrentHp(1);
                           else
                           {
                             player.setCurrentHp(0);
                             if (player.isInOlympiadMode())
                             {
                               player.abortAttack();
                               player.abortCast();
                               player.getStatus().stopHpMpRegeneration();
                             }
                             else
                               player.doDie(activeChar);
                           }
                           }
                           else
                            player.setCurrentHp(player.getCurrentHp() - damage);
                  }

                      SystemMessage smsg = new SystemMessage(SystemMessageId.S1_GAVE_YOU_S2_DMG);
                      smsg.addString(activeChar.getName());
                      smsg.addNumber(damage);
                      player.sendPacket(smsg);

                }
                else
                  target.reduceCurrentHp(damage, activeChar);
                  }
View Full Code Here

   * @see net.sf.l2j.gameserver.clientpackets.ClientBasePacket#runImpl()
   */
  @Override
  protected void runImpl()
  {
    L2PcInstance target = L2World.getInstance().getPlayer(_name);
    L2PcInstance activeChar = getClient().getActiveChar();

    if (target != null && target.isInParty() && activeChar.isInParty() && activeChar.getParty().isInCommandChannel()
        && target.getParty().isInCommandChannel()
        && activeChar.getParty().getCommandChannel().getChannelLeader().equals(activeChar))
    {
      target.getParty().getCommandChannel().removeParty(target.getParty());

      SystemMessage sm = SystemMessage.sendString("Your party was dismissed from the CommandChannel.");
      target.getParty().broadcastToPartyMembers(sm);

      sm = SystemMessage.sendString(target.getParty().getPartyMembers().get(0).getName()
          + "'s party was dismissed from the CommandChannel.");
    }
    else
    {
        activeChar.sendMessage("Incorrect Target");
    }
  }
View Full Code Here

  }

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

        if (activeChar.getPrivateStoreType() != 0)
        {
            activeChar.sendMessage("Cannot make items while trading");
            return;
        }

        if (activeChar.isInCraftMode())
        {
            activeChar.sendMessage("Currently in Craft Mode");
            return;
        }

    RecipeController.getInstance().requestMakeItem(activeChar, _id);
  }
View Full Code Here

        // Notify the Quest Engine of the L2Attackable death if necessary
        try {
            if (killer instanceof L2PcInstance || killer instanceof L2Summon)
            {
                L2PcInstance player = killer instanceof L2PcInstance?(L2PcInstance)killer:((L2Summon)killer).getOwner();

              if (getTemplate().getEventQuests(Quest.QuestEventType.MOBKILLED) != null)
                for (Quest quest: getTemplate().getEventQuests(Quest.QuestEventType.MOBKILLED))
                  quest.notifyKill(this, player, killer instanceof L2Summon);
            }
View Full Code Here

                  }

                  // Check for an over-hit enabled strike
                  if (attacker instanceof L2PcInstance)
                  {
                    L2PcInstance player = (L2PcInstance)attacker;
                    if (isOverhit() && attacker == getOverhitAttacker())
                    {
                      player.sendPacket(new SystemMessage(SystemMessageId.OVER_HIT));
                      exp += calculateOverhitExp(exp);
                    }
                  }

                  // Distribute the Exp and SP between the L2PcInstance and its L2Summon
                  if (!attacker.isDead())
                    attacker.addExpAndSp(Math.round(attacker.calcStat(Stats.EXPSP_RATE, exp, null, null)),
                        (int)attacker.calcStat(Stats.EXPSP_RATE, sp, null, null));
                }
              }
              else
              {
                //share with party members
                partyDmg = 0;
                partyMul = 1.f;
                partyLvl = 0;

                // Get all L2Character that can be rewarded in the party
                List<L2PlayableInstance> rewardedMembers = new FastList<L2PlayableInstance>();

                // Go through all L2PcInstance in the party
                List<L2PcInstance> groupMembers;
                if (attackerParty.isInCommandChannel())
                  groupMembers = attackerParty.getCommandChannel().getMembers();
                else
                  groupMembers = attackerParty.getPartyMembers();

                for (L2PcInstance pl : groupMembers)
                {
                  if (pl == null || pl.isDead()) continue;

                  // Get the RewardInfo of this L2PcInstance from L2Attackable rewards
                  reward2 = rewards.get(pl);

                  // If the L2PcInstance is in the L2Attackable rewards add its damages to party damages
                  if (reward2 != null)
                  {
                    if (Util.checkIfInRange(Config.ALT_PARTY_RANGE, this, pl, true))
                    {
                      partyDmg += reward2._dmg; // Add L2PcInstance damages to party damages
                      rewardedMembers.add(pl);
                      if (pl.getLevel() > partyLvl)
                      {
                        if(attackerParty.isInCommandChannel())
                          partyLvl = attackerParty.getCommandChannel().getLevel();
                        else
                          partyLvl = pl.getLevel();
                      }
                    }
                    rewards.remove(pl); // Remove the L2PcInstance from the L2Attackable rewards
                  }
                  else
                  {
                    // Add L2PcInstance of the party (that have attacked or not) to members that can be rewarded
                    // and in range of the monster.
                    if (Util.checkIfInRange(Config.ALT_PARTY_RANGE, this, pl, true))
                    {
                      rewardedMembers.add(pl);
                      if (pl.getLevel() > partyLvl)
                      {
                        if(attackerParty.isInCommandChannel())
                          partyLvl = attackerParty.getCommandChannel().getLevel();
                        else
                          partyLvl = pl.getLevel();
                      }
                    }
                  }
                  L2PlayableInstance summon = pl.getPet();
                  if (summon != null && summon instanceof L2PetInstance)
                  {
                    reward2 = rewards.get(summon);
                    if (reward2 != null) // Pets are only added if they have done damage
                    {
                      if (Util.checkIfInRange(Config.ALT_PARTY_RANGE, this, summon, true))
                      {
                        partyDmg += reward2._dmg; // Add summon damages to party damages
                        rewardedMembers.add(summon);
                        if (summon.getLevel() > partyLvl)
                          partyLvl = summon.getLevel();
                      }
                      rewards.remove(summon); // Remove the summon from the L2Attackable rewards
                    }
                  }
                }

                // If the party didn't killed this L2Attackable alone
                if (partyDmg < getMaxHp()) partyMul = ((float)partyDmg / (float)getMaxHp());

                // Avoid "over damage"
                if (partyDmg > getMaxHp()) partyDmg = getMaxHp();

                // Calculate the level difference between Party and L2Attackable
                levelDiff = partyLvl - getLevel();

                // Calculate Exp and SP rewards
                tmp = calculateExpAndSp(levelDiff, partyDmg);
                exp = tmp[0];
                sp = tmp[1];

                if (Config.L2JMOD_CHAMPION_ENABLE && isChampion())
                {
                  exp *= Config.L2JMOD_CHAMPION_REWARDS;
                  sp *= Config.L2JMOD_CHAMPION_REWARDS;
                }

                exp *= partyMul;
                sp *= partyMul;

                // Check for an over-hit enabled strike
                // (When in party, the over-hit exp bonus is given to the whole party and splitted proportionally through the party members)
                if (attacker instanceof L2PcInstance)
                {
                  L2PcInstance player = (L2PcInstance)attacker;
                  if (isOverhit() && attacker == getOverhitAttacker())
                  {
                    player.sendPacket(new SystemMessage(SystemMessageId.OVER_HIT));
                    exp += calculateOverhitExp(exp);
                  }
                }

                // Distribute Experience and SP rewards to L2PcInstance Party members in the known area of the last attacker
View Full Code Here

          getAI().notifyEvent(CtrlEvent.EVT_ATTACKED, attacker);

            try {
                if (attacker instanceof L2PcInstance || attacker instanceof L2Summon)
                {
                    L2PcInstance player = attacker instanceof L2PcInstance ? (L2PcInstance)attacker : ((L2Summon)attacker).getOwner();

                    if (getTemplate().getEventQuests(Quest.QuestEventType.MOBGOTATTACKED) !=null)
                      for (Quest quest: getTemplate().getEventQuests(Quest.QuestEventType.MOBGOTATTACKED))
                        quest.notifyAttack(this, player, damage, attacker instanceof L2Summon);
                }
View Full Code Here

      *
      * @param lastAttacker The L2Character that has killed the L2Attackable
      */
     public void doItemDrop(L2NpcTemplate npcTemplate, L2Character lastAttacker)
     {
         L2PcInstance player = null;
         if (lastAttacker instanceof L2PcInstance) player = (L2PcInstance)lastAttacker;
         else if (lastAttacker instanceof L2Summon) player = ((L2Summon)lastAttacker).getOwner();

         if (player == null) return; // Don't drop anything if the last attacker or ownere isn't L2PcInstance

         int levelModifier = calculateLevelModifierForDrop(player);          // level modifier in %'s (will be subtracted from drop chance)

         // Check the drop of a cursed weapon
         if (levelModifier == 0 && player.getLevel() > 20) // Not deep blue mob
           CursedWeaponsManager.getInstance().checkDrop(this, player);

         // now throw all categorized drops and handle spoil.
       for(L2DropCategory cat:npcTemplate.getDropData())
       {
         RewardItem item = null;
             if (cat.isSweep())
         {
               // according to sh1ny, seeded mobs CAN be spoiled and swept.
               if ( isSpoil()/* && !isSeeded() */)
               {
             FastList<RewardItem> sweepList = new FastList<RewardItem>();

                 for(L2DropData drop: cat.getAllDrops() )
                 {
                   item = calculateRewardItem(player, drop, levelModifier, true);
                   if (item == null) continue;

                   if (Config.DEBUG) _log.fine("Item id to spoil: " + item.getItemId() + " amount: " + item.getCount());
                   sweepList.add(item);
                 }

                 // Set the table _sweepItems of this L2Attackable
                 if (!sweepList.isEmpty())
                   _sweepItems = sweepList.toArray(new RewardItem[sweepList.size()]);
           }
         }
         else
         {
                 if (isSeeded())
                 {
                   L2DropData drop = cat.dropSeedAllowedDropsOnly();
                   if(drop == null)
                     continue;

                   item = calculateRewardItem(player, drop, levelModifier, false);
                 }
                 else
                 {
             item = calculateCategorizedRewardItem(player, cat, levelModifier);
                 }

           if (item != null)
           {
             if (Config.DEBUG) _log.fine("Item id to drop: " + item.getItemId() + " amount: " + item.getCount());

           // Check if the autoLoot mode is active
           if (Config.AUTO_LOOT) player.doAutoLoot(this, item); // Give this or these Item(s) to the L2PcInstance that has killed the L2Attackable
           else DropItem(player, item); // drop the item on the ground

           // Broadcast message if RaidBoss was defeated
                 if(this instanceof L2RaidBossInstance)
                 {
                     SystemMessage sm;
                     sm = new SystemMessage(SystemMessageId.S1_DIED_DROPPED_S3_S2);
                     sm.addString(getName());
                     sm.addItemName(item.getItemId());
                     sm.addNumber(item.getCount());
                     broadcastPacket(sm);
                 }
           }
         }
       }

       // Apply Special Item drop with rnd qty for champions
       if (Config.L2JMOD_CHAMPION_ENABLE && isChampion() && (player.getLevel() <= getLevel()) && Config.L2JMOD_CHAMPION_REWARD > 0 && (Rnd.get(100) < Config.L2JMOD_CHAMPION_REWARD))
     {
         int champqty = Rnd.get(Config.L2JMOD_CHAMPION_REWARD_QTY);
          champqty++; //quantity should actually vary between 1 and whatever admin specified as max, inclusive.

         RewardItem item = new RewardItem(Config.L2JMOD_CHAMPION_REWARD_ID,champqty);
         if (Config.AUTO_LOOT) player.addItem("ChampionLoot", item.getItemId(), item.getCount(), this, true); // Give this or these Item(s) to the L2PcInstance that has killed the L2Attackable
             else DropItem(player, item);
       }

         //Instant Item Drop :>
       double rateHp = getStat().calcStat(Stats.MAX_HP , 1, this, null);
         if (rateHp <= 1 && String.valueOf(npcTemplate.type).contentEquals("L2Monster")) //only L2Monster with <= 1x HP can drop herbs
         {
           boolean _hp = false;
           boolean _mp = false;
           boolean _spec = false;

           //ptk - patk type enhance
           int random = Rnd.get(1000); // note *10
             if ((random < Config.RATE_DROP_SPECIAL_HERBS) && !_spec) // && !_spec useless yet
             {
                 RewardItem item = new RewardItem(8612, 1); // Herb of Warrior
                 if (Config.AUTO_LOOT && Config.AUTO_LOOT_HERBS) player.addItem("Loot", item.getItemId(), item.getCount(), this, true);
                 else DropItem(player, item);
                 _spec = true;
             }
             else for (int i = 0; i < 3; i++)
             {
               random = Rnd.get(100);
               if (random < Config.RATE_DROP_COMMON_HERBS)
               {
                 RewardItem item = null;
                 if (i == 0) item = new RewardItem(8606, 1); // Herb of Power
                 if (i == 1) item = new RewardItem(8608, 1); // Herb of Atk. Spd.
                 if (i == 2) item = new RewardItem(8610, 1); // Herb of Critical Attack

                 if (Config.AUTO_LOOT && Config.AUTO_LOOT_HERBS) player.addItem("Loot", item.getItemId(), item.getCount(), this, true);
                 else DropItem(player, item);
                 break;
               }
             }

             //mtk - matk type enhance
             random = Rnd.get(1000); // note *10
             if ((random < Config.RATE_DROP_SPECIAL_HERBS) && !_spec)
             {
                 RewardItem item = new RewardItem(8613, 1); // Herb of Mystic
                 if (Config.AUTO_LOOT && Config.AUTO_LOOT_HERBS) player.addItem("Loot", item.getItemId(), item.getCount(), this, true);
                 else DropItem(player, item);
                 _spec = true;
             }
             else for (int i = 0; i < 2; i++)
             {
               random = Rnd.get(100);
               if (random < Config.RATE_DROP_COMMON_HERBS)
               {
                 RewardItem item = null;
                 if (i == 0) item = new RewardItem(8607, 1); // Herb of Magic
                 if (i == 1) item = new RewardItem(8609, 1); // Herb of Casting Speed

                 if (Config.AUTO_LOOT && Config.AUTO_LOOT_HERBS) player.addItem("Loot", item.getItemId(), item.getCount(), this, true);
                 else DropItem(player, item);
                 break;
               }
             }

             //hp+mp type
             random = Rnd.get(1000); // note *10
             if ((random < Config.RATE_DROP_SPECIAL_HERBS) && !_spec)
             {
                 RewardItem item = new RewardItem(8614, 1); // Herb of Recovery
                 if (Config.AUTO_LOOT && Config.AUTO_LOOT_HERBS) player.addItem("Loot", item.getItemId(), item.getCount(), this, true);
                 else DropItem(player, item);
                 _mp = true;
                 _hp = true;
                 _spec = true;
             }
             //hp - restore hp type
             if (!_hp)
             {
               random = Rnd.get(100);
               if (random < Config.RATE_DROP_MP_HP_HERBS)
               {
                 RewardItem item = new RewardItem(8600, 1); // Herb of Life
                 if (Config.AUTO_LOOT && Config.AUTO_LOOT_HERBS) player.addItem("Loot", item.getItemId(), item.getCount(), this, true);
                 else DropItem(player, item);
                 _hp = true;
               }
             }
             if (!_hp)
             {
               random = Rnd.get(100);
               if (random < Config.RATE_DROP_GREATER_HERBS)
               {
                 RewardItem item = new RewardItem(8601, 1); // Greater Herb of Life
                 if (Config.AUTO_LOOT && Config.AUTO_LOOT_HERBS) player.addItem("Loot", item.getItemId(), item.getCount(), this, true);
                 else DropItem(player, item);
                 _hp = true;
               }
             }
             if (!_hp)
             {
               random = Rnd.get(1000); // note *10
               if (random < Config.RATE_DROP_SUPERIOR_HERBS)
               {
                 RewardItem item = new RewardItem(8602, 1); // Superior Herb of Life
                 if (Config.AUTO_LOOT && Config.AUTO_LOOT_HERBS) player.addItem("Loot", item.getItemId(), item.getCount(), this, true);
                 else DropItem(player, item);
               }
             }
             //mp - restore mp type
             if (!_mp)
             {
               random = Rnd.get(100);
               if (random < Config.RATE_DROP_MP_HP_HERBS)
               {
                 RewardItem item = new RewardItem(8603, 1); // Herb of Manna
                 if (Config.AUTO_LOOT && Config.AUTO_LOOT_HERBS) player.addItem("Loot", item.getItemId(), item.getCount(), this, true);
                 else DropItem(player, item);
                 _mp = true;
               }
             }
             if (!_mp)
             {
               random = Rnd.get(100);
               if (random < Config.RATE_DROP_GREATER_HERBS)
               {
                 RewardItem item = new RewardItem(8604, 1); // Greater Herb of Mana
                 if (Config.AUTO_LOOT && Config.AUTO_LOOT_HERBS) player.addItem("Loot", item.getItemId(), item.getCount(), this, true);
                 else DropItem(player, item);
                 _mp = true;
               }
             }
             if (!_mp)
             {
               random = Rnd.get(1000); // note *10
               if (random < Config.RATE_DROP_SUPERIOR_HERBS)
               {
                 RewardItem item = new RewardItem(8605, 1); // Superior Herb of Mana
                 if (Config.AUTO_LOOT && Config.AUTO_LOOT_HERBS) player.addItem("Loot", item.getItemId(), item.getCount(), this, true);
                 else DropItem(player, item);
               }
             }
             // speed enhance type
             random = Rnd.get(100);
             if (random < Config.RATE_DROP_COMMON_HERBS)
             {
                 RewardItem item = new RewardItem(8611, 1)// Herb of Speed
                 if (Config.AUTO_LOOT && Config.AUTO_LOOT_HERBS) player.addItem("Loot", item.getItemId(), item.getCount(), this, true);
                 else DropItem(player, item);
             }
         }
     }
View Full Code Here

  @Override
  protected void runImpl()
  {
    if (Config.DEBUG) _log.fine("deleting slot:" + _charSlot);

    L2PcInstance character = null;
    try
    {
        if (Config.DELETE_DAYS == 0)
          character = getClient().deleteChar(_charSlot);
        else
          character = getClient().markToDeleteChar(_charSlot);
    }
    catch (Exception e)
    {
      _log.log(Level.SEVERE, "Error:", e);
    }

    if (character == null)
    {
      sendPacket(new CharDeleteOk());
    }
    else
    {
      if (character.isClanLeader())
      {
        sendPacket(new CharDeleteFail(CharDeleteFail.REASON_CLAN_LEADERS_MAY_NOT_BE_DELETED));
      }
      else
      {
View Full Code Here

TOP

Related Classes of net.sf.l2j.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.