private void useSkill(String skillName, L2Object target, boolean pet) {
    final L2PcInstance activeChar = getActiveChar();
    if (activeChar == null) {
      return;
    }

    final L2Summon summon = activeChar.getPet();
    if (!validateSummon(summon, pet)) {
      return;
    }

    if (!canControl(summon)) {
      return;
    }

    if (summon instanceof L2BabyPetInstance) {
      if (!((L2BabyPetInstance) summon).isInSupportMode()) {
        sendPacket(SystemMessageId.A_PET_ON_AUXILIARY_MODE_CANNOT_USE_SKILLS);
        return;
      }
    }
    final Skill skill = summon.getTemplate().getParameters().getSkillHolder(skillName).getSkill();

    if (skill != null) {
      summon.setTarget(target);
      summon.useMagic(skill, _ctrlPressed, _shiftPressed);

      if (skill.getId() == SWITCH_STANCE_ID) {
        summon.switchMode();
      }
    }
  }
  private boolean canControl(L2Summon summon) {
    if (summon instanceof L2BabyPetInstance) {
      if (!((L2BabyPetInstance) summon).isInSupportMode()) {
        sendPacket(SystemMessageId.A_PET_ON_AUXILIARY_MODE_CANNOT_USE_SKILLS);
        return false;
      }
    }

    if (summon.isPet()) {
      if ((summon.getLevel() - getActiveChar().getLevel()) > 20) {
        sendPacket(SystemMessageId.YOUR_PET_IS_TOO_HIGH_LEVEL_TO_CONTROL);
        return false;
      }
    }
    return true;
  }
 public List<Integer> getAvailableSkills(L2Summon cha) {
   List<Integer> skillIds = new ArrayList<>();
   if (!_skillTrees.containsKey(cha.getId())) {
     LOGGER.warning(
         getClass().getSimpleName()
             + ": Pet id "
             + cha.getId()
             + " does not have any skills assigned.");
     return skillIds;
   }
   Collection<L2PetSkillLearn> skills = _skillTrees.get(cha.getId()).values();
   for (L2PetSkillLearn temp : skills) {
     if (skillIds.contains(temp.getId())) {
       continue;
     }
     skillIds.add(temp.getId());
   }
   return skillIds;
 }
  /**
   * Validates the given summon and sends a system message to the master.
   *
   * @param summon the summon to validate
   * @param checkPet if {@code true} it'll validate a pet, if {@code false} it will validate a
   *     servitor
   * @return {@code true} if the summon is not null and whether is a pet or a servitor depending on
   *     {@code checkPet} value, {@code false} otherwise
   */
  private boolean validateSummon(L2Summon summon, boolean checkPet) {
    if ((summon != null) && ((checkPet && summon.isPet()) || summon.isServitor())) {
      if (summon.isPet() && ((L2PetInstance) summon).isUncontrollable()) {
        sendPacket(SystemMessageId.WHEN_YOUR_PET_S_HUNGER_GAUGE_IS_AT_0_YOU_CANNOT_USE_YOUR_PET);
        return false;
      }
      if (summon.isBetrayed()) {
        sendPacket(SystemMessageId.YOUR_PET_SERVITOR_IS_UNRESPONSIVE_AND_WILL_NOT_OBEY_ANY_ORDERS);
        return false;
      }
      return true;
    }

    if (checkPet) {
      sendPacket(SystemMessageId.YOU_DO_NOT_HAVE_A_PET);
    } else {
      sendPacket(SystemMessageId.YOU_DO_NOT_HAVE_A_SERVITOR);
    }
    return false;
  }
  /**
   * Cast a skill for active summon.<br>
   * Target is specified as a parameter but can be overwrited or ignored depending on skill type.
   *
   * @param skillId the skill Id to be casted by the summon
   * @param target the target to cast the skill on, overwritten or ignored depending on skill type
   * @param pet if {@code true} it'll validate a pet, if {@code false} it will validate a servitor
   */
  private void useSkill(int skillId, L2Object target, boolean pet) {
    final L2PcInstance activeChar = getActiveChar();
    if (activeChar == null) {
      return;
    }

    if (pet) {
      final L2Summon summon = activeChar.getPet();
      if (!validateSummon(summon, pet)) {
        return;
      }

      if (!canControl(summon)) {
        return;
      }

      final int lvl =
          PetDataTable.getInstance()
              .getPetData(summon.getId())
              .getAvailableLevel(skillId, summon.getLevel());

      if (lvl > 0) {
        summon.setTarget(target);
        summon.useMagic(
            SkillData.getInstance().getSkill(skillId, lvl), _ctrlPressed, _shiftPressed);
      }

      if (skillId == SWITCH_STANCE_ID) {
        summon.switchMode();
      }
    } else {
      final L2Summon servitor = activeChar.getAnyServitor();
      if (!validateSummon(servitor, pet)) {
        return;
      }

      final int lvl = SummonSkillsTable.getInstance().getAvailableLevel(servitor, skillId);

      if (lvl > 0) {
        servitor.setTarget(target);
        servitor.useMagic(
            SkillData.getInstance().getSkill(skillId, lvl), _ctrlPressed, _shiftPressed);
      }
    }
  }
  public int getAvailableLevel(L2Summon cha, int skillId) {
    int lvl = 0;
    if (!_skillTrees.containsKey(cha.getId())) {
      LOGGER.warning(
          getClass().getSimpleName()
              + ": Pet id "
              + cha.getId()
              + " does not have any skills assigned.");
      return lvl;
    }
    Collection<L2PetSkillLearn> skills = _skillTrees.get(cha.getId()).values();
    for (L2PetSkillLearn temp : skills) {
      if (temp.getId() != skillId) {
        continue;
      }
      if (temp.getLevel() == 0) {
        if (cha.getLevel() < 70) {
          lvl = (cha.getLevel() / 10);
          if (lvl <= 0) {
            lvl = 1;
          }
        } else {
          lvl = (7 + ((cha.getLevel() - 70) / 5));
        }

        // formula usable for skill that have 10 or more skill levels
        int maxLvl = SkillData.getInstance().getMaxLevel(temp.getId());
        if (lvl > maxLvl) {
          lvl = maxLvl;
        }
        break;
      } else if (temp.getMinLevel() <= cha.getLevel()) {
        if (temp.getLevel() > lvl) {
          lvl = temp.getLevel();
        }
      }
    }
    return lvl;
  }
 public PetStatusShow(L2Summon summon) {
   _summonType = summon.getSummonType();
 }
Example #8
0
  private void handleRemoveBuffs(L2PcInstance player, InstanceWorld world) {
    final Instance inst = InstanceManager.getInstance().getInstance(world.getInstanceId());
    switch (inst.getRemoveBuffType()) {
      case ALL:
        {
          player.stopAllEffectsExceptThoseThatLastThroughDeath();

          final L2Summon pet = player.getPet();
          if (pet != null) {
            pet.stopAllEffectsExceptThoseThatLastThroughDeath();
          }

          player
              .getServitors()
              .values()
              .forEach(L2Summon::stopAllEffectsExceptThoseThatLastThroughDeath);
          break;
        }
      case WHITELIST:
        {
          for (BuffInfo info : player.getEffectList().getBuffs()) {
            if (!inst.getBuffExceptionList().contains(info.getSkill().getId())) {
              info.getEffected().getEffectList().stopSkillEffects(true, info.getSkill());
            }
          }

          for (L2Summon summon : player.getServitors().values()) {
            for (BuffInfo info : summon.getEffectList().getBuffs()) {
              if (!inst.getBuffExceptionList().contains(info.getSkill().getId())) {
                info.getEffected().getEffectList().stopSkillEffects(true, info.getSkill());
              }
            }
          }

          final L2Summon pet = player.getPet();
          if (pet != null) {
            for (BuffInfo info : pet.getEffectList().getBuffs()) {
              if (!inst.getBuffExceptionList().contains(info.getSkill().getId())) {
                info.getEffected().getEffectList().stopSkillEffects(true, info.getSkill());
              }
            }
          }
          break;
        }
      case BLACKLIST:
        {
          for (BuffInfo info : player.getEffectList().getBuffs()) {
            if (inst.getBuffExceptionList().contains(info.getSkill().getId())) {
              info.getEffected().getEffectList().stopSkillEffects(true, info.getSkill());
            }
          }

          for (L2Summon summon : player.getServitors().values()) {
            for (BuffInfo info : summon.getEffectList().getBuffs()) {
              if (inst.getBuffExceptionList().contains(info.getSkill().getId())) {
                info.getEffected().getEffectList().stopSkillEffects(true, info.getSkill());
              }
            }
          }

          final L2Summon pet = player.getPet();
          if (pet != null) {
            for (BuffInfo info : pet.getEffectList().getBuffs()) {
              if (inst.getBuffExceptionList().contains(info.getSkill().getId())) {
                info.getEffected().getEffectList().stopSkillEffects(true, info.getSkill());
              }
            }
          }
          break;
        }
    }
  }
  @Override
  protected void runImpl() {
    final L2PcInstance activeChar = getActiveChar();
    if (activeChar == null) {
      return;
    }

    if (Config.DEBUG) {
      _log.info(
          getType()
              + ": "
              + activeChar
              + " requested action use ID: "
              + _actionId
              + " Ctrl pressed:"
              + _ctrlPressed
              + " Shift pressed:"
              + _shiftPressed);
    }

    // Don't do anything if player is dead or confused
    if ((activeChar.isFakeDeath() && (_actionId != 0))
        || activeChar.isDead()
        || activeChar.isOutOfControl()) {
      sendPacket(ActionFailed.STATIC_PACKET);
      return;
    }

    final BuffInfo info =
        activeChar.getEffectList().getBuffInfoByAbnormalType(AbnormalType.BOT_PENALTY);
    if (info != null) {
      for (AbstractEffect effect : info.getEffects()) {
        if (!effect.checkCondition(_actionId)) {
          activeChar.sendPacket(
              SystemMessageId
                  .YOU_HAVE_BEEN_REPORTED_AS_AN_ILLEGAL_PROGRAM_USER_SO_YOUR_ACTIONS_HAVE_BEEN_RESTRICTED);
          activeChar.sendPacket(ActionFailed.STATIC_PACKET);
          return;
        }
      }
    }

    // Don't allow to do some action if player is transformed
    if (activeChar.isTransformed()) {
      int[] allowedActions =
          activeChar.isTransformed()
              ? ExBasicActionList.ACTIONS_ON_TRANSFORM
              : ExBasicActionList.DEFAULT_ACTION_LIST;
      if (!(Arrays.binarySearch(allowedActions, _actionId) >= 0)) {
        sendPacket(ActionFailed.STATIC_PACKET);
        _log.warning(
            "Player "
                + activeChar
                + " used action which he does not have! Id = "
                + _actionId
                + " transform: "
                + activeChar.getTransformation());
        return;
      }
    }

    final L2Summon pet = activeChar.getPet();
    final L2Summon servitor = activeChar.getAnyServitor();
    final L2Object target = activeChar.getTarget();
    switch (_actionId) {
      case 0: // Sit/Stand
        if (activeChar.isSitting() || !activeChar.isMoving() || activeChar.isFakeDeath()) {
          useSit(activeChar, target);
        } else {
          // Sit when arrive using next action.
          // Creating next action class.
          final NextAction nextAction =
              new NextAction(
                  CtrlEvent.EVT_ARRIVED,
                  CtrlIntention.AI_INTENTION_MOVE_TO,
                  () -> useSit(activeChar, target));

          // Binding next action to AI.
          activeChar.getAI().setNextAction(nextAction);
        }
        break;
      case 1: // Walk/Run
        if (activeChar.isRunning()) {
          activeChar.setWalking();
        } else {
          activeChar.setRunning();
        }
        break;
      case 10: // Private Store - Sell
        activeChar.tryOpenPrivateSellStore(false);
        break;
      case 15: // Change Movement Mode (Pets)
        if (validateSummon(pet, true)) {
          ((L2SummonAI) pet.getAI()).notifyFollowStatusChange();
        }
        break;
      case 16: // Attack (Pets)
        if (validateSummon(pet, true)) {
          if (pet.canAttack(_ctrlPressed)) {
            pet.doAttack();
          }
        }
        break;
      case 17: // Stop (Pets)
        if (validateSummon(pet, true)) {
          pet.cancelAction();
        }
        break;
      case 19: // Unsummon Pet
        if (!validateSummon(pet, true)) {
          break;
        }

        if (pet.isDead()) {
          sendPacket(SystemMessageId.DEAD_PETS_CANNOT_BE_RETURNED_TO_THEIR_SUMMONING_ITEM);
          break;
        }

        if (pet.isAttackingNow() || pet.isInCombat() || pet.isMovementDisabled()) {
          sendPacket(SystemMessageId.A_PET_CANNOT_BE_UNSUMMONED_DURING_BATTLE);
          break;
        }

        if (pet.isHungry()) {
          if (!((L2PetInstance) pet).getPetData().getFood().isEmpty()) {
            sendPacket(SystemMessageId.YOU_MAY_NOT_RESTORE_A_HUNGRY_PET);
          } else {
            sendPacket(
                SystemMessageId
                    .THE_MINION_PET_CANNOT_BE_RETURNED_BECAUSE_THERE_IS_NOT_MUCH_TIME_REMAINING_UNTIL_IT_LEAVES);
          }
          break;
        }

        pet.unSummon(activeChar);
        break;
      case 21: // Change Movement Mode (Servitors)
        if (validateSummon(servitor, false)) {
          ((L2SummonAI) servitor.getAI()).notifyFollowStatusChange();
        }
        break;
      case 22: // Attack (Servitors)
        if (validateSummon(servitor, false)) {
          if (servitor.canAttack(_ctrlPressed)) {
            servitor.doAttack();
          }
        }
        break;
      case 23: // Stop (Servitors)
        if (validateSummon(servitor, false)) {
          servitor.cancelAction();
        }
        break;
      case 28: // Private Store - Buy
        activeChar.tryOpenPrivateBuyStore();
        break;
      case 32: // Wild Hog Cannon - Wild Cannon
        useSkill("DDMagic", false);
        break;
      case 36: // Soulless - Toxic Smoke
        useSkill("RangeDebuff", false);
        break;
      case 37: // Dwarven Manufacture
        if (activeChar.isAlikeDead()) {
          sendPacket(ActionFailed.STATIC_PACKET);
          return;
        }
        if (activeChar.getPrivateStoreType() != PrivateStoreType.NONE) {
          activeChar.setPrivateStoreType(PrivateStoreType.NONE);
          activeChar.broadcastUserInfo();
        }
        if (activeChar.isSitting()) {
          activeChar.standUp();
        }

        sendPacket(new RecipeShopManageList(activeChar, true));
        break;
      case 38: // Mount/Dismount
        activeChar.mountPlayer(pet);
        break;
      case 39: // Soulless - Parasite Burst
        useSkill("RangeDD", false);
        break;
      case 41: // Wild Hog Cannon - Attack
        if (validateSummon(servitor, false)) {
          if ((target != null) && (target.isDoor() || (target instanceof L2SiegeFlagInstance))) {
            useSkill(4230, false);
          } else {
            sendPacket(SystemMessageId.INVALID_TARGET);
          }
        }
        break;
      case 42: // Kai the Cat - Self Damage Shield
        useSkill("HealMagic", false);
        break;
      case 43: // Merrow the Unicorn - Hydro Screw
        useSkill("DDMagic", false);
        break;
      case 44: // Big Boom - Boom Attack
        useSkill("DDMagic", false);
        break;
      case 45: // Boxer the Unicorn - Master Recharge
        useSkill("HealMagic", activeChar, false);
        break;
      case 46: // Mew the Cat - Mega Storm Strike
        useSkill("DDMagic", false);
        break;
      case 47: // Silhouette - Steal Blood
        useSkill("DDMagic", false);
        break;
      case 48: // Mechanic Golem - Mech. Cannon
        useSkill("DDMagic", false);
        break;
      case 51: // General Manufacture
        // Player shouldn't be able to set stores if he/she is alike dead (dead or fake death)
        if (activeChar.isAlikeDead()) {
          sendPacket(ActionFailed.STATIC_PACKET);
          return;
        }
        if (activeChar.getPrivateStoreType() != PrivateStoreType.NONE) {
          activeChar.setPrivateStoreType(PrivateStoreType.NONE);
          activeChar.broadcastUserInfo();
        }
        if (activeChar.isSitting()) {
          activeChar.standUp();
        }

        sendPacket(new RecipeShopManageList(activeChar, false));
        break;
      case 52: // Unsummon Servitor
        if (validateSummon(servitor, false)) {
          if (servitor.isAttackingNow() || servitor.isInCombat()) {
            sendPacket(SystemMessageId.A_SERVITOR_WHOM_IS_ENGAGED_IN_BATTLE_CANNOT_BE_DE_ACTIVATED);
            break;
          }
          servitor.unSummon(activeChar);
        }
        break;
      case 53: // Move to target (Servitors)
        if (validateSummon(servitor, false)) {
          if ((target != null) && (servitor != target) && !servitor.isMovementDisabled()) {
            servitor.setFollowStatus(false);
            servitor.getAI().setIntention(CtrlIntention.AI_INTENTION_MOVE_TO, target.getLocation());
          }
        }
        break;
      case 54: // Move to target (Pets)
        if (validateSummon(pet, true)) {
          if ((target != null) && (pet != target) && !pet.isMovementDisabled()) {
            pet.setFollowStatus(false);
            pet.getAI().setIntention(CtrlIntention.AI_INTENTION_MOVE_TO, target.getLocation());
          }
        }
        break;
      case 61: // Private Store Package Sell
        activeChar.tryOpenPrivateSellStore(true);
        break;
      case 65: // Bot Report Button
        if (Config.BOTREPORT_ENABLE) {
          BotReportTable.getInstance().reportBot(activeChar);
        } else {
          activeChar.sendMessage("This feature is disabled.");
        }
        break;
      case 67: // Steer
        if (activeChar.isInAirShip()) {
          if (activeChar.getAirShip().setCaptain(activeChar)) {
            activeChar.broadcastUserInfo();
          }
        }
        break;
      case 68: // Cancel Control
        if (activeChar.isInAirShip() && activeChar.getAirShip().isCaptain(activeChar)) {
          if (activeChar.getAirShip().setCaptain(null)) {
            activeChar.broadcastUserInfo();
          }
        }
        break;
      case 69: // Destination Map
        AirShipManager.getInstance().sendAirShipTeleportList(activeChar);
        break;
      case 70: // Exit Airship
        if (activeChar.isInAirShip()) {
          if (activeChar.getAirShip().isCaptain(activeChar)) {
            if (activeChar.getAirShip().setCaptain(null)) {
              activeChar.broadcastUserInfo();
            }
          } else if (activeChar.getAirShip().isInDock()) {
            activeChar.getAirShip().oustPlayer(activeChar);
          }
        }
        break;
      case 71:
      case 72:
      case 73:
        useCoupleSocial(_actionId - 55);
        break;
      case 78:
      case 79:
      case 80:
      case 81:
        if ((activeChar.getParty() != null)
            && (activeChar.getTarget() != null)
            && (activeChar.getTarget().isCharacter())) {
          activeChar
              .getParty()
              .addTacticalSign(_actionId - 77, (L2Character) activeChar.getTarget());
        } else {
          sendPacket(ActionFailed.STATIC_PACKET);
        }
        break;
      case 82:
      case 83:
      case 84:
      case 85:
        if (activeChar.getParty() != null) {
          activeChar.getParty().setTargetBasedOnTacticalSignId(activeChar, _actionId - 81);
        } else {
          sendPacket(ActionFailed.STATIC_PACKET);
        }
        break;
      case 90: // /instancedzone action since Lindvior
        activeChar.sendPacket(new ExInzoneWaiting(activeChar));
        break;
      case 1000: // Siege Golem - Siege Hammer
        if ((target != null) && target.isDoor()) {
          useSkill(4079, false);
        }
        break;
      case 1001: // Sin Eater - Ultimate Bombastic Buster
        if (validateSummon(pet, true) && (pet.getId() == SIN_EATER_ID)) {
          pet.broadcastPacket(
              new NpcSay(
                  pet.getObjectId(),
                  ChatType.NPC_GENERAL,
                  pet.getId(),
                  NPC_STRINGS[Rnd.get(NPC_STRINGS.length)]));
        }
        break;
      case 1003: // Wind Hatchling/Strider - Wild Stun
        useSkill("PhysicalSpecial", true);
        break;
      case 1004: // Wind Hatchling/Strider - Wild Defense
        useSkill("Buff", activeChar, true);
        break;
      case 1005: // Star Hatchling/Strider - Bright Burst
        useSkill("DDMagic", true);
        break;
      case 1006: // Star Hatchling/Strider - Bright Heal
        useSkill("Heal", activeChar, true);
        break;
      case 1007: // Feline Queen - Blessing of Queen
        useSkill("Buff1", activeChar, false);
        break;
      case 1008: // Feline Queen - Gift of Queen
        useSkill("Buff2", activeChar, false);
        break;
      case 1009: // Feline Queen - Cure of Queen
        useSkill("DDMagic", false);
        break;
      case 1010: // Unicorn Seraphim - Blessing of Seraphim
        useSkill("Buff1", activeChar, false);
        break;
      case 1011: // Unicorn Seraphim - Gift of Seraphim
        useSkill("Buff2", activeChar, false);
        break;
      case 1012: // Unicorn Seraphim - Cure of Seraphim
        useSkill("DDMagic", false);
        break;
      case 1013: // Nightshade - Curse of Shade
        useSkill("DeBuff1", false);
        break;
      case 1014: // Nightshade - Mass Curse of Shade
        useSkill("DeBuff2", false);
        break;
      case 1015: // Nightshade - Shade Sacrifice
        useSkill("Heal", false);
        break;
      case 1016: // Cursed Man - Cursed Blow
        useSkill("PhysicalSpecial1", false);
        break;
      case 1017: // Cursed Man - Cursed Strike
        useSkill("PhysicalSpecial2", false);
        break;
      case 1031: // Feline King - Slash
        useSkill("PhysicalSpecial1", false);
        break;
      case 1032: // Feline King - Spinning Slash
        useSkill("PhysicalSpecial2", false);
        break;
      case 1033: // Feline King - Hold of King
        useSkill("PhysicalSpecial3", false);
        break;
      case 1034: // Magnus the Unicorn - Whiplash
        useSkill("PhysicalSpecial1", false);
        break;
      case 1035: // Magnus the Unicorn - Tridal Wave
        useSkill("PhysicalSpecial2", false);
        break;
      case 1036: // Spectral Lord - Corpse Kaboom
        useSkill("PhysicalSpecial1", false);
        break;
      case 1037: // Spectral Lord - Dicing Death
        useSkill("PhysicalSpecial2", false);
        break;
      case 1038: // Spectral Lord - Dark Curse
        useSkill("PhysicalSpecial3", false);
        break;
      case 1039: // Swoop Cannon - Cannon Fodder
        useSkill(5110, false);
        break;
      case 1040: // Swoop Cannon - Big Bang
        useSkill(5111, false);
        break;
      case 1041: // Great Wolf - Bite Attack
        useSkill("Skill01", true);
        break;
      case 1042: // Great Wolf - Maul
        useSkill("Skill03", true);
        break;
      case 1043: // Great Wolf - Cry of the Wolf
        useSkill("Skill02", true);
        break;
      case 1044: // Great Wolf - Awakening
        useSkill("Skill04", true);
        break;
      case 1045: // Great Wolf - Howl
        useSkill(5584, true);
        break;
      case 1046: // Strider - Roar
        useSkill(5585, true);
        break;
      case 1047: // Divine Beast - Bite
        useSkill(5580, false);
        break;
      case 1048: // Divine Beast - Stun Attack
        useSkill(5581, false);
        break;
      case 1049: // Divine Beast - Fire Breath
        useSkill(5582, false);
        break;
      case 1050: // Divine Beast - Roar
        useSkill(5583, false);
        break;
      case 1051: // Feline Queen - Bless The Body
        useSkill("buff3", false);
        break;
      case 1052: // Feline Queen - Bless The Soul
        useSkill("buff4", false);
        break;
      case 1053: // Feline Queen - Haste
        useSkill("buff5", false);
        break;
      case 1054: // Unicorn Seraphim - Acumen
        useSkill("buff3", false);
        break;
      case 1055: // Unicorn Seraphim - Clarity
        useSkill("buff4", false);
        break;
      case 1056: // Unicorn Seraphim - Empower
        useSkill("buff5", false);
        break;
      case 1057: // Unicorn Seraphim - Wild Magic
        useSkill("buff6", false);
        break;
      case 1058: // Nightshade - Death Whisper
        useSkill("buff3", false);
        break;
      case 1059: // Nightshade - Focus
        useSkill("buff4", false);
        break;
      case 1060: // Nightshade - Guidance
        useSkill("buff5", false);
        break;
      case 1061: // Wild Beast Fighter, White Weasel - Death blow
        useSkill(5745, true);
        break;
      case 1062: // Wild Beast Fighter - Double attack
        useSkill(5746, true);
        break;
      case 1063: // Wild Beast Fighter - Spin attack
        useSkill(5747, true);
        break;
      case 1064: // Wild Beast Fighter - Meteor Shower
        useSkill(5748, true);
        break;
      case 1065: // Fox Shaman, Wild Beast Fighter, White Weasel, Fairy Princess - Awakening
        useSkill(5753, true);
        break;
      case 1066: // Fox Shaman, Spirit Shaman - Thunder Bolt
        useSkill(5749, true);
        break;
      case 1067: // Fox Shaman, Spirit Shaman - Flash
        useSkill(5750, true);
        break;
      case 1068: // Fox Shaman, Spirit Shaman - Lightning Wave
        useSkill(5751, true);
        break;
      case 1069: // Fox Shaman, Fairy Princess - Flare
        useSkill(5752, true);
        break;
      case 1070: // White Weasel, Fairy Princess, Improved Baby Buffalo, Improved Baby Kookaburra,
        // Improved Baby Cougar, Spirit Shaman, Toy Knight, Turtle Ascetic - Buff control
        useSkill(5771, true);
        break;
      case 1071: // Tigress - Power Strike
        useSkill("DDMagic", true);
        break;
      case 1072: // Toy Knight - Piercing attack
        useSkill(6046, true);
        break;
      case 1073: // Toy Knight - Whirlwind
        useSkill(6047, true);
        break;
      case 1074: // Toy Knight - Lance Smash
        useSkill(6048, true);
        break;
      case 1075: // Toy Knight - Battle Cry
        useSkill(6049, true);
        break;
      case 1076: // Turtle Ascetic - Power Smash
        useSkill(6050, true);
        break;
      case 1077: // Turtle Ascetic - Energy Burst
        useSkill(6051, true);
        break;
      case 1078: // Turtle Ascetic - Shockwave
        useSkill(6052, true);
        break;
      case 1079: // Turtle Ascetic - Howl
        useSkill(6053, true);
        break;
      case 1080: // Phoenix Rush
        useSkill(6041, false);
        break;
      case 1081: // Phoenix Cleanse
        useSkill(6042, false);
        break;
      case 1082: // Phoenix Flame Feather
        useSkill(6043, false);
        break;
      case 1083: // Phoenix Flame Beak
        useSkill(6044, false);
        break;
      case 1084: // Switch State
        if (pet instanceof L2BabyPetInstance) {
          useSkill(SWITCH_STANCE_ID, true);
        }
        break;
      case 1086: // Panther Cancel
        useSkill(6094, false);
        break;
      case 1087: // Panther Dark Claw
        useSkill(6095, false);
        break;
      case 1088: // Panther Fatal Claw
        useSkill(6096, false);
        break;
      case 1089: // Deinonychus - Tail Strike
        useSkill(6199, true);
        break;
      case 1090: // Guardian's Strider - Strider Bite
        useSkill(6205, true);
        break;
      case 1091: // Guardian's Strider - Strider Fear
        useSkill(6206, true);
        break;
      case 1092: // Guardian's Strider - Strider Dash
        useSkill(6207, true);
        break;
      case 1093: // Maguen - Maguen Strike
        useSkill(6618, true);
        break;
      case 1094: // Maguen - Maguen Wind Walk
        useSkill(6681, true);
        break;
      case 1095: // Elite Maguen - Maguen Power Strike
        useSkill(6619, true);
        break;
      case 1096: // Elite Maguen - Elite Maguen Wind Walk
        useSkill(6682, true);
        break;
      case 1097: // Maguen - Maguen Return
        useSkill(6683, true);
        break;
      case 1098: // Elite Maguen - Maguen Party Return
        useSkill(6684, true);
        break;
      case 1099: // All servitor attack
        activeChar
            .getServitors()
            .values()
            .forEach(
                s -> {
                  if (validateSummon(s, false)) {
                    if (s.canAttack(_ctrlPressed)) {
                      s.doAttack();
                    }
                  }
                });
        break;
      case 1100: // All servitor move to
        activeChar
            .getServitors()
            .values()
            .forEach(
                s -> {
                  if (validateSummon(s, false)) {
                    if ((target != null) && (s != target) && !s.isMovementDisabled()) {
                      s.setFollowStatus(false);
                      s.getAI()
                          .setIntention(CtrlIntention.AI_INTENTION_MOVE_TO, target.getLocation());
                    }
                  }
                });
        break;
      case 1101: // All servitor stop
        activeChar
            .getServitors()
            .values()
            .forEach(
                summon -> {
                  if (validateSummon(summon, false)) {
                    summon.cancelAction();
                  }
                });
        break;
      case 1102: // Unsummon all servitors
        boolean canUnsummon = true;
        OUT:
        for (L2Summon s : activeChar.getServitors().values()) {
          if (validateSummon(s, false)) {
            if (s.isAttackingNow() || s.isInCombat()) {
              sendPacket(
                  SystemMessageId.A_SERVITOR_WHOM_IS_ENGAGED_IN_BATTLE_CANNOT_BE_DE_ACTIVATED);
              canUnsummon = false;
              break OUT;
            }
            s.unSummon(activeChar);
          }
        }
        if (canUnsummon) {
          activeChar
              .getServitors()
              .values()
              .stream()
              .forEach(
                  s -> {
                    s.unSummon(activeChar);
                  });
        }
        break;
      case 1103: // seems to be passive mode
        break;
      case 1104: // seems to be defend mode
        break;
      case 1106: // Cute Bear - Bear Claw
        useServitorsSkill(11278);
        break;
      case 1107: // Cute Bear - Bear Tumbling
        useServitorsSkill(11279);
        break;
      case 1108: // Saber Tooth Cougar- Cougar Bite
        useServitorsSkill(11280);
        break;
      case 1109: // Saber Tooth Cougar - Cougar Pounce
        useServitorsSkill(11281);
        break;
      case 1110: // Grim Reaper - Reaper Touch
        useServitorsSkill(11282);
        break;
      case 1111: // Grim Reaper - Reaper Power
        useServitorsSkill(11283);
        break;
      case 1113: // Golden Lion - Lion Roar
        useSkill(10051, false);
        break;
      case 1114: // Golden Lion - Lion Claw
        useSkill(10052, false);
        break;
      case 1115: // Golden Lion - Lion Dash
        useSkill(10053, false);
        break;
      case 1116: // Golden Lion - Lion Flame
        useSkill(10054, false);
        break;
      case 1117: // Thunder Hawk - Thunder Flight
        useSkill(10794, false);
        break;
      case 1118: // Thunder Hawk - Thunder Purity
        useSkill(10795, false);
        break;
      case 1120: // Thunder Hawk - Thunder Feather Blast
        useSkill(10797, false);
        break;
      case 1121: // Thunder Hawk - Thunder Sharp Claw
        useSkill(10798, false);
        break;
      case 1122: // Tree of Life - Blessing of Tree
        useServitorsSkill(11806);
        break;
      case 1124: // Wynn Kai the Cat - Feline Aggression
        useServitorsSkill(11323);
        break;
      case 1125: // Wynn Kai the Cat - Feline Stun
        useServitorsSkill(11324);
        break;
      case 1126: // Wynn Feline King - Feline Bite
        useServitorsSkill(11325);
        break;
      case 1127: // Wynn Feline King - Feline Pounce
        useServitorsSkill(11326);
        break;
      case 1128: // Wynn Feline Queen - Feline Touch
        useServitorsSkill(11327);
        break;
      case 1129: // Wynn Feline Queen - Feline Power
        useServitorsSkill(11328);
        break;
      case 1130: // Wynn Merrow - Unicorn's Aggression
        useServitorsSkill(11332);
        break;
      case 1131: // Wynn Merrow - Unicorn's Stun
        useServitorsSkill(11333);
        break;
      case 1132: // Wynn Magnus - Unicorn's Bite
        useServitorsSkill(11334);
        break;
      case 1133: // Wynn Magnus - Unicorn's Pounce
        useServitorsSkill(11335);
        break;
      case 1134: // Wynn Seraphim - Unicorn's Touch
        useServitorsSkill(11336);
        break;
      case 1135: // Wynn Seraphim - Unicorn's Power
        useServitorsSkill(11337);
        break;
      case 1136: // Wynn Nightshade - Phantom Aggression
        useServitorsSkill(11341);
        break;
      case 1137: // Wynn Nightshade - Phantom Stun
        useServitorsSkill(11342);
        break;
      case 1138: // Wynn Spectral Lord - Phantom Bite
        useServitorsSkill(11343);
        break;
      case 1139: // Wynn Spectral Lord - Phantom Pounce
        useServitorsSkill(11344);
        break;
      case 1140: // Wynn Soulless - Phantom Touch
        useServitorsSkill(11345);
        break;
      case 1141: // Wynn Soulless - Phantom Power
        useServitorsSkill(11346);
        break;
      case 1142: // Blood Panther - Panther Roar
        useServitorsSkill(10087);
        break;
      case 1143: // Blood Panther - Panther Rush
        useServitorsSkill(10088);
        break;
      case 5000: // Baby Rudolph - Reindeer Scratch
        useSkill(23155, true);
        break;
      case 5001: // Deseloph, Hyum, Rekang, Lilias, Lapham, Mafum - Rosy Seduction
        useSkill(23167, true);
        break;
      case 5002: // Deseloph, Hyum, Rekang, Lilias, Lapham, Mafum - Critical Seduction
        useSkill(23168, true);
        break;
      case 5003: // Hyum, Lapham, Hyum, Lapham - Thunder Bolt
        useSkill(5749, true);
        break;
      case 5004: // Hyum, Lapham, Hyum, Lapham - Flash
        useSkill(5750, true);
        break;
      case 5005: // Hyum, Lapham, Hyum, Lapham - Lightning Wave
        useSkill(5751, true);
        break;
      case 5006: // Deseloph, Hyum, Rekang, Lilias, Lapham, Mafum, Deseloph, Hyum, Rekang, Lilias,
        // Lapham, Mafum - Buff Control
        useSkill(5771, true);
        break;
      case 5007: // Deseloph, Lilias, Deseloph, Lilias - Piercing Attack
        useSkill(6046, true);
        break;
      case 5008: // Deseloph, Lilias, Deseloph, Lilias - Spin Attack
        useSkill(6047, true);
        break;
      case 5009: // Deseloph, Lilias, Deseloph, Lilias - Smash
        useSkill(6048, true);
        break;
      case 5010: // Deseloph, Lilias, Deseloph, Lilias - Ignite
        useSkill(6049, true);
        break;
      case 5011: // Rekang, Mafum, Rekang, Mafum - Power Smash
        useSkill(6050, true);
        break;
      case 5012: // Rekang, Mafum, Rekang, Mafum - Energy Burst
        useSkill(6051, true);
        break;
      case 5013: // Rekang, Mafum, Rekang, Mafum - Shockwave
        useSkill(6052, true);
        break;
      case 5014: // Rekang, Mafum, Rekang, Mafum - Ignite
        useSkill(6053, true);
        break;
      case 5015: // Deseloph, Hyum, Rekang, Lilias, Lapham, Mafum, Deseloph, Hyum, Rekang, Lilias,
        // Lapham, Mafum - Switch Stance
        useSkill(6054, true);
        break;
        // Social Packets
      case 12: // Greeting
        tryBroadcastSocial(2);
        break;
      case 13: // Victory
        tryBroadcastSocial(3);
        break;
      case 14: // Advance
        tryBroadcastSocial(4);
        break;
      case 24: // Yes
        tryBroadcastSocial(6);
        break;
      case 25: // No
        tryBroadcastSocial(5);
        break;
      case 26: // Bow
        tryBroadcastSocial(7);
        break;
      case 29: // Unaware
        tryBroadcastSocial(8);
        break;
      case 30: // Social Waiting
        tryBroadcastSocial(9);
        break;
      case 31: // Laugh
        tryBroadcastSocial(10);
        break;
      case 33: // Applaud
        tryBroadcastSocial(11);
        break;
      case 34: // Dance
        tryBroadcastSocial(12);
        break;
      case 35: // Sorrow
        tryBroadcastSocial(13);
        break;
      case 62: // Charm
        tryBroadcastSocial(14);
        break;
      case 66: // Shyness
        tryBroadcastSocial(15);
        break;
      case 87: // Propose
        tryBroadcastSocial(28);
        break;
      case 88: // Provoke
        tryBroadcastSocial(29);
        break;
      case 89: // Beauty Shop
        tryBroadcastSocial(30);
        activeChar.broadcastInfo();
        break;
      default:
        _log.warning(activeChar.getName() + ": unhandled action type " + _actionId);
        break;
    }
  }
Example #10
0
 public ConfirmDlg addNpcName(L2Summon npc) {
   return addNpcName(npc.getNpcId());
 }
Example #11
0
 /** Stops all players from attacking. Used for duel timeout / interrupt. */
 private void stopFighting() {
   ActionFailed af = ActionFailed.STATIC_PACKET;
   if (_partyDuel) {
     for (L2PcInstance temp : _playerA.getParty().getMembers()) {
       temp.abortCast();
       temp.getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE);
       temp.setTarget(null);
       temp.sendPacket(af);
       if (temp.hasSummon()) {
         for (L2Summon summon : temp.getServitors().values()) {
           if (!summon.isDead()) {
             summon.abortCast();
             summon.getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE);
             summon.setTarget(null);
             summon.sendPacket(af);
           }
         }
       }
     }
     for (L2PcInstance temp : _playerB.getParty().getMembers()) {
       temp.abortCast();
       temp.getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE);
       temp.setTarget(null);
       temp.sendPacket(af);
       if (temp.hasSummon()) {
         for (L2Summon summon : temp.getServitors().values()) {
           if (!summon.isDead()) {
             summon.abortCast();
             summon.getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE);
             summon.setTarget(null);
             summon.sendPacket(af);
           }
         }
       }
     }
   } else {
     _playerA.abortCast();
     _playerB.abortCast();
     _playerA.getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE);
     _playerA.setTarget(null);
     _playerB.getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE);
     _playerB.setTarget(null);
     _playerA.sendPacket(af);
     _playerB.sendPacket(af);
     if (_playerA.hasSummon()) {
       for (L2Summon summon : _playerA.getServitors().values()) {
         if (!summon.isDead()) {
           summon.abortCast();
           summon.getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE);
           summon.setTarget(null);
           summon.sendPacket(af);
         }
       }
     }
     if (_playerB.hasSummon()) {
       for (L2Summon summon : _playerB.getServitors().values()) {
         if (!summon.isDead()) {
           summon.abortCast();
           summon.getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE);
           summon.setTarget(null);
           summon.sendPacket(af);
         }
       }
     }
   }
 }
 @Override
 protected final void writeImpl() {
   writeC(0xB6);
   writeD(_summon.getSummonType());
   writeD(_summon.getObjectId());
   writeD(_summon.getX());
   writeD(_summon.getY());
   writeD(_summon.getZ());
   writeS(_summon.getTitle());
   writeD(_curFed);
   writeD(_maxFed);
   writeD((int) _summon.getCurrentHp());
   writeD(_summon.getMaxHp());
   writeD((int) _summon.getCurrentMp());
   writeD(_summon.getMaxMp());
   writeD(_summon.getLevel());
   writeQ(_summon.getStat().getExp());
   writeQ(_summon.getExpForThisLevel()); // 0% absolute value
   writeQ(_summon.getExpForNextLevel()); // 100% absolute value
 }
Example #13
0
  public final void reduceHp(
      double value,
      L2Character attacker,
      boolean awake,
      boolean isDOT,
      boolean isHPConsumption,
      boolean ignoreCP) {
    if (getActiveChar().isDead()) {
      return;
    }

    // If OFFLINE_MODE_NO_DAMAGE is enabled and player is offline and he is in store/craft mode, no
    // damage is taken.
    if (Config.OFFLINE_MODE_NO_DAMAGE
        && (getActiveChar().getClient() != null)
        && getActiveChar().getClient().isDetached()
        && ((Config.OFFLINE_TRADE_ENABLE
                && ((getActiveChar().getPrivateStoreType() == L2PcInstance.STORE_PRIVATE_SELL)
                    || (getActiveChar().getPrivateStoreType() == L2PcInstance.STORE_PRIVATE_BUY)))
            || (Config.OFFLINE_CRAFT_ENABLE
                && (getActiveChar().isInCraftMode()
                    || (getActiveChar().getPrivateStoreType()
                        == L2PcInstance.STORE_PRIVATE_MANUFACTURE))))) {
      return;
    }

    if (getActiveChar().isInvul() && !(isDOT || isHPConsumption)) {
      return;
    }

    if (!isHPConsumption) {
      getActiveChar().stopEffectsOnDamage(awake);
      // Attacked players in craft/shops stand up.
      if (getActiveChar().isInCraftMode() || getActiveChar().isInStoreMode()) {
        getActiveChar().setPrivateStoreType(L2PcInstance.STORE_PRIVATE_NONE);
        getActiveChar().standUp();
        getActiveChar().broadcastUserInfo();
      } else if (getActiveChar().isSitting()) {
        getActiveChar().standUp();
      }

      if (!isDOT) {
        if (getActiveChar().isStunned() && (Rnd.get(10) == 0)) {
          getActiveChar().stopStunning(true);
        }
      }
    }

    int fullValue = (int) value;
    int tDmg = 0;
    int mpDam = 0;

    if ((attacker != null) && (attacker != getActiveChar())) {
      final L2PcInstance attackerPlayer = attacker.getActingPlayer();

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

        if (getActiveChar().isInDuel()) {
          if (getActiveChar().getDuelState() == Duel.DUELSTATE_DEAD) {
            return;
          } else if (getActiveChar().getDuelState() == Duel.DUELSTATE_WINNER) {
            return;
          }

          // cancel duel if player got hit by another player, that is not part of the duel
          if (attackerPlayer.getDuelId() != getActiveChar().getDuelId()) {
            getActiveChar().setDuelState(Duel.DUELSTATE_INTERRUPTED);
          }
        }
      }

      // Check and calculate transfered damage
      final L2Summon summon = getActiveChar().getSummon();
      if (getActiveChar().hasSummon()
          && summon.isServitor()
          && Util.checkIfInRange(1000, getActiveChar(), summon, true)) {
        tDmg =
            ((int) value
                    * (int)
                        getActiveChar()
                            .getStat()
                            .calcStat(Stats.TRANSFER_DAMAGE_PERCENT, 0, null, null))
                / 100;

        // Only transfer dmg up to current HP, it should not be killed
        tDmg = Math.min((int) summon.getCurrentHp() - 1, tDmg);
        if (tDmg > 0) {
          summon.reduceCurrentHp(tDmg, attacker, null);
          value -= tDmg;
          fullValue =
              (int)
                  value; // reduce the announced value here as player will get a message about
                         // summon damage
        }
      }

      mpDam =
          ((int) value
                  * (int)
                      getActiveChar().getStat().calcStat(Stats.MANA_SHIELD_PERCENT, 0, null, null))
              / 100;

      if (mpDam > 0) {
        mpDam = (int) (value - mpDam);
        if (mpDam > getActiveChar().getCurrentMp()) {
          getActiveChar().sendPacket(SystemMessageId.MP_BECAME_0_ARCANE_SHIELD_DISAPPEARING);
          getActiveChar().getFirstEffect(1556).stopEffectTask();
          value = mpDam - getActiveChar().getCurrentMp();
          getActiveChar().setCurrentMp(0);
        } else {
          getActiveChar().reduceCurrentMp(mpDam);
          SystemMessage smsg =
              SystemMessage.getSystemMessage(
                  SystemMessageId.ARCANE_SHIELD_DECREASED_YOUR_MP_BY_S1_INSTEAD_OF_HP);
          smsg.addNumber(mpDam);
          getActiveChar().sendPacket(smsg);
          return;
        }
      }

      final L2PcInstance caster = getActiveChar().getTransferingDamageTo();
      if ((caster != null)
          && (getActiveChar().getParty() != null)
          && Util.checkIfInRange(1000, getActiveChar(), caster, true)
          && !caster.isDead()
          && (getActiveChar() != caster)
          && getActiveChar().getParty().getMembers().contains(caster)) {
        int transferDmg = 0;

        transferDmg =
            ((int) value
                    * (int)
                        getActiveChar()
                            .getStat()
                            .calcStat(Stats.TRANSFER_DAMAGE_TO_PLAYER, 0, null, null))
                / 100;
        transferDmg = Math.min((int) caster.getCurrentHp() - 1, transferDmg);
        if ((transferDmg > 0) && (attacker instanceof L2Playable)) {
          int membersInRange = 0;
          for (L2PcInstance member : caster.getParty().getMembers()) {
            if (Util.checkIfInRange(1000, member, caster, false) && (member != caster)) {
              membersInRange++;
            }
          }

          if (caster.getCurrentCp() > 0) {
            if (caster.getCurrentCp() > transferDmg) {
              reduceCp(transferDmg);
            } else {
              transferDmg = (int) (transferDmg - caster.getCurrentCp());
              reduceCp((int) caster.getCurrentCp());
            }
          }

          caster.reduceCurrentHp(transferDmg / membersInRange, attacker, null);
          value -= transferDmg;
          fullValue = (int) value;
        }
      }

      if (!ignoreCP && (attacker instanceof L2Playable)) {
        if (getCurrentCp() >= value) {
          setCurrentCp(getCurrentCp() - value); // Set Cp to diff of Cp vs value
          value = 0; // No need to subtract anything from Hp
        } else {
          value -= getCurrentCp(); // Get diff from value vs Cp; will apply diff to Hp
          setCurrentCp(0, false); // Set Cp to 0
        }
      }

      if ((fullValue > 0) && !isDOT) {
        SystemMessage smsg;
        // Send a System Message to the L2PcInstance
        smsg = SystemMessage.getSystemMessage(SystemMessageId.C1_RECEIVED_DAMAGE_OF_S3_FROM_C2);
        smsg.addString(getActiveChar().getName());
        smsg.addCharName(attacker);
        smsg.addNumber(fullValue);
        getActiveChar().sendPacket(smsg);

        if (tDmg > 0) {
          smsg = SystemMessage.getSystemMessage(SystemMessageId.C1_RECEIVED_DAMAGE_OF_S3_FROM_C2);
          smsg.addString(getActiveChar().getSummon().getName());
          smsg.addCharName(attacker);
          smsg.addNumber(tDmg);
          getActiveChar().sendPacket(smsg);

          if (attackerPlayer != null) {
            smsg =
                SystemMessage.getSystemMessage(
                    SystemMessageId.GIVEN_S1_DAMAGE_TO_YOUR_TARGET_AND_S2_DAMAGE_TO_SERVITOR);
            smsg.addNumber(fullValue);
            smsg.addNumber(tDmg);
            attackerPlayer.sendPacket(smsg);
          }
        }
      }
    }

    if (value > 0) {
      value = getCurrentHp() - value;
      if (value <= 0) {
        if (getActiveChar().isInDuel()) {
          getActiveChar().disableAllSkills();
          stopHpMpRegeneration();
          if (attacker != null) {
            attacker.getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE);
            attacker.sendPacket(ActionFailed.STATIC_PACKET);
          }
          // let the DuelManager know of his defeat
          DuelManager.getInstance().onPlayerDefeat(getActiveChar());
          value = 1;
        } else {
          value = 0;
        }
      }
      setCurrentHp(value);
    }

    if (getActiveChar().getCurrentHp() < 0.5) {
      getActiveChar().abortAttack();
      getActiveChar().abortCast();

      if (getActiveChar().isInOlympiadMode()) {
        stopHpMpRegeneration();
        getActiveChar().setIsDead(true);
        getActiveChar().setIsPendingRevive(true);
        if (getActiveChar().hasSummon()) {
          getActiveChar().getSummon().getAI().setIntention(CtrlIntention.AI_INTENTION_IDLE, null);
        }
        return;
      }

      getActiveChar().doDie(attacker);
      if (!Config.DISABLE_TUTORIAL) {
        QuestState qs = getActiveChar().getQuestState("255_Tutorial");
        if (qs != null) {
          qs.getQuest().notifyEvent("CE30", null, getActiveChar());
        }
      }
    }
  }
  @Override
  public boolean testImpl(L2Character effector, L2Character effected, Skill skill, L2Item item) {
    // Need skill rework for fix that properly
    if (skill.getAffectRange() > 0) {
      return true;
    }
    if (effected == null) {
      return false;
    }
    boolean canResurrect = true;

    if (effected.isPlayer()) {
      final L2PcInstance player = effected.getActingPlayer();
      if (!player.isDead()) {
        canResurrect = false;
        if (effector.isPlayer()) {
          final SystemMessage msg =
              SystemMessage.getSystemMessage(
                  SystemMessageId.S1_CANNOT_BE_USED_DUE_TO_UNSUITABLE_TERMS);
          msg.addSkillName(skill);
          effector.sendPacket(msg);
        }
      } else if (player.isResurrectionBlocked()) {
        canResurrect = false;
        if (effector.isPlayer()) {
          effector.sendPacket(SystemMessageId.REJECT_RESURRECTION);
        }
      } else if (player.isReviveRequested()) {
        canResurrect = false;
        if (effector.isPlayer()) {
          effector.sendPacket(SystemMessageId.RESURRECTION_HAS_ALREADY_BEEN_PROPOSED);
        }
      }
    } else if (effected.isSummon()) {
      final L2Summon summon = (L2Summon) effected;
      final L2PcInstance player = summon.getOwner();
      if (!summon.isDead()) {
        canResurrect = false;
        if (effector.isPlayer()) {
          final SystemMessage msg =
              SystemMessage.getSystemMessage(
                  SystemMessageId.S1_CANNOT_BE_USED_DUE_TO_UNSUITABLE_TERMS);
          msg.addSkillName(skill);
          effector.sendPacket(msg);
        }
      } else if (summon.isResurrectionBlocked()) {
        canResurrect = false;
        if (effector.isPlayer()) {
          effector.sendPacket(SystemMessageId.REJECT_RESURRECTION);
        }
      } else if ((player != null) && player.isRevivingPet()) {
        canResurrect = false;
        if (effector.isPlayer()) {
          effector.sendPacket(
              SystemMessageId
                  .RESURRECTION_HAS_ALREADY_BEEN_PROPOSED); // Resurrection is already been
                                                            // proposed.
        }
      }
    }
    return (_val == canResurrect);
  }
Example #15
0
  @Override
  protected final void writeImpl() {
    writeC(0xb2);
    writeD(_summon.getSummonType());
    writeD(_summon.getObjectId());
    writeD(_summon.getTemplate().idTemplate + 1000000);
    writeD(0); // 1=attackable

    writeD(_x);
    writeD(_y);
    writeD(_z);
    writeD(_heading);
    writeD(0);
    writeD(_mAtkSpd);
    writeD(_pAtkSpd);
    writeD(_runSpd);
    writeD(_walkSpd);
    writeD(_swimRunSpd);
    writeD(_swimWalkSpd);
    writeD(_flRunSpd);
    writeD(_flWalkSpd);
    writeD(_flyRunSpd);
    writeD(_flyWalkSpd);

    writeF(_multiplier); // movement multiplier
    writeF(1); // attack speed multiplier
    writeF(_summon.getTemplate().fCollisionRadius);
    writeF(_summon.getTemplate().fCollisionHeight);
    writeD(_summon.getWeapon()); // right hand weapon
    writeD(_summon.getArmor()); // body armor
    writeD(0); // left hand weapon
    writeC(
        _summon.getOwner() != null
            ? 1
            : 0); // when pet is dead and player exit game, pet doesn't show master name
    writeC(1); // running=1 (it is always 1, walking mode is calculated from multiplier)
    writeC(_summon.isInCombat() ? 1 : 0); // attacking 1=true
    writeC(_summon.isAlikeDead() ? 1 : 0); // dead 1=true
    writeC(_isSummoned ? 2 : _val); //  0=teleported  1=default   2=summoned
    writeD(-1); // High Five NPCString ID
    writeS(_summon.getName()); // summon name
    writeD(-1); // High Five NPCString ID
    writeS(_summon.getTitle()); // owner name
    writeD(1);
    writeD(
        _summon.getOwner() != null
            ? _summon.getOwner().getPvpFlag()
            : 0); // 0 = white,2= purpleblink, if its greater then karma = purple
    writeD(_summon.getOwner() != null ? _summon.getOwner().getKarma() : 0); // karma
    writeD(_curFed); // how fed it is
    writeD(_maxFed); // max fed it can be
    writeD((int) _summon.getCurrentHp()); // current hp
    writeD(_maxHp); // max hp
    writeD((int) _summon.getCurrentMp()); // current mp
    writeD(_maxMp); // max mp
    writeD(_summon.getStat().getSp()); // sp
    writeD(_summon.getLevel()); // lvl
    writeQ(_summon.getStat().getExp());

    if (_summon.getExpForThisLevel() > _summon.getStat().getExp())
      writeQ(_summon.getStat().getExp()); // 0%  absolute value
    else writeQ(_summon.getExpForThisLevel()); // 0%  absolute value

    writeQ(_summon.getExpForNextLevel()); // 100% absoulte value
    writeD(
        _summon instanceof L2PetInstance ? _summon.getInventory().getTotalWeight() : 0); // weight
    writeD(_summon.getMaxLoad()); // max weight it can carry
    writeD(_summon.getPAtk(null)); // patk
    writeD(_summon.getPDef(null)); // pdef
    writeD(_summon.getMAtk(null, null)); // matk
    writeD(_summon.getMDef(null, null)); // mdef
    writeD(_summon.getAccuracy()); // accuracy
    writeD(_summon.getEvasionRate(null)); // evasion
    writeD(_summon.getCriticalHit(null, null)); // critical
    writeD((int) _summon.getStat().getMoveSpeed()); // speed
    writeD(_summon.getPAtkSpd()); // atkspeed
    writeD(_summon.getMAtkSpd()); // casting speed

    writeD(
        _summon.getAbnormalEffect()); // c2  abnormal visual effect... bleed=1; poison=2; poison &
    // bleed=3; flame=4;
    int npcId = _summon.getTemplate().npcId;
    writeH(_summon.isMountable() ? 1 : 0); // c2    ride button

    writeC(0); // c2

    // Following all added in C4.
    writeH(0); // ??
    writeC(
        _summon.getOwner() != null
            ? _summon.getOwner().getTeam()
            : 0); // team aura (1 = blue, 2 = red)
    writeD(_summon.getSoulShotsPerHit()); // How many soulshots this servitor uses per hit
    writeD(_summon.getSpiritShotsPerHit()); // How many spiritshots this servitor uses per hit

    int form = 0;
    if (npcId == 16041 || npcId == 16042) {
      if (_summon.getLevel() > 84) form = 3;
      else if (_summon.getLevel() > 79) form = 2;
      else if (_summon.getLevel() > 74) form = 1;
    } else if (npcId == 16025 || npcId == 16037) {
      if (_summon.getLevel() > 69) form = 3;
      else if (_summon.getLevel() > 64) form = 2;
      else if (_summon.getLevel() > 59) form = 1;
    }
    writeD(form); // CT1.5 Pet form and skills
    writeD(_summon.getSpecialEffect());
  }
Example #16
0
 /**
  * rev 478 dddddddddddddddddddffffdddcccccSSdddddddddddddddddddddddddddhc
  *
  * @param _characters
  */
 public PetInfo(L2Summon summon, int val) {
   _summon = summon;
   _isSummoned = _summon.isShowSummonAnimation();
   _x = _summon.getX();
   _y = _summon.getY();
   _z = _summon.getZ();
   _heading = _summon.getHeading();
   _mAtkSpd = _summon.getMAtkSpd();
   _pAtkSpd = _summon.getPAtkSpd();
   _multiplier = _summon.getMovementSpeedMultiplier();
   _runSpd = _summon.getTemplate().baseRunSpd;
   _walkSpd = _summon.getTemplate().baseWalkSpd;
   _swimRunSpd = _flRunSpd = _flyRunSpd = _runSpd;
   _swimWalkSpd = _flWalkSpd = _flyWalkSpd = _walkSpd;
   _maxHp = _summon.getMaxVisibleHp();
   _maxMp = _summon.getMaxMp();
   _val = val;
   if (_summon instanceof L2PetInstance) {
     L2PetInstance pet = (L2PetInstance) _summon;
     _curFed = pet.getCurrentFed(); // how fed it is
     _maxFed = pet.getMaxFed(); // max fed it can be
   } else if (_summon instanceof L2SummonInstance) {
     L2SummonInstance sum = (L2SummonInstance) _summon;
     _curFed = sum.getTimeRemaining();
     _maxFed = sum.getTotalLifeTime();
   }
 }