コード例 #1
0
  @Override
  public String onExitZone(L2Character character, L2ZoneType zone) {
    if (character instanceof L2ControllableAirShipInstance) {
      if (character.equals(_dockedShip)) {
        if (_departSchedule != null) {
          _departSchedule.cancel(false);
          _departSchedule = null;
        }

        _dockedShip.setInDock(0);
        _dockedShip = null;
        _isBusy = false;
      }
    }
    return null;
  }
コード例 #2
0
ファイル: AdminKill.java プロジェクト: Kyosume/L2WT-Ertheia
  @Override
  public boolean useAdminCommand(String command, L2PcInstance activeChar) {
    if (activeChar == null || !activeChar.getPcAdmin().canUseAdminCommand()) {
      return false;
    }

    if (command.startsWith("admin_kill")) {
      StringTokenizer st = new StringTokenizer(command, " ");
      st.nextToken(); // skip command

      if (st.hasMoreTokens()) {
        String firstParam = st.nextToken();
        L2PcInstance plyr = WorldManager.getInstance().getPlayer(firstParam);
        if (plyr != null) {
          if (st.hasMoreTokens()) {
            try {
              int radius = Integer.parseInt(st.nextToken());
              for (L2Character knownChar : plyr.getKnownList().getKnownCharactersInRadius(radius)) {
                if (knownChar instanceof L2ControllableMobInstance
                    || knownChar.equals(activeChar)) {
                  continue;
                }

                kill(activeChar, knownChar);
              }

              activeChar.sendMessage("Killed all characters within a " + radius + " unit radius.");
              return true;
            } catch (NumberFormatException e) {
              activeChar.sendMessage("Invalid radius.");
              return false;
            }
          } else {
            kill(activeChar, plyr);
          }
        } else {
          try {
            int radius = Integer.parseInt(firstParam);

            for (L2Character knownChar :
                activeChar.getKnownList().getKnownCharactersInRadius(radius)) {
              if (knownChar instanceof L2ControllableMobInstance || knownChar.equals(activeChar)) {
                continue;
              }
              kill(activeChar, knownChar);
            }

            activeChar.sendMessage("Killed all characters within a " + radius + " unit radius.");
            return true;
          } catch (NumberFormatException e) {
            activeChar.sendMessage("Usage: //kill <player_name | radius>");
            return false;
          }
        }
      } else {
        L2Object obj = activeChar.getTarget();
        if (obj instanceof L2ControllableMobInstance || !(obj instanceof L2Character)) {
          activeChar.sendPacket(SystemMessageId.INCORRECT_TARGET);
        } else {
          kill(activeChar, (L2Character) obj);
        }
      }
    }
    return true;
  }
コード例 #3
0
ファイル: Continuous.java プロジェクト: Kyosume/L2WT-Ertheia
  @Override
  public void useSkill(L2Character activeChar, L2Skill skill, L2Object[] targets) {
    boolean acted = true;

    L2PcInstance player = null;
    if (activeChar instanceof L2PcInstance) {
      player = (L2PcInstance) activeChar;
    }

    if (skill.getEffectId() != 0) {
      L2Skill sk =
          SkillTable.getInstance()
              .getInfo(skill.getEffectId(), skill.getEffectLvl() == 0 ? 1 : skill.getEffectLvl());

      if (sk != null) {
        skill = sk;
      }
    }

    boolean ss = activeChar.isSoulshotCharged(skill);
    boolean sps = activeChar.isSpiritshotCharged(skill);
    boolean bss = activeChar.isBlessedSpiritshotCharged(skill);

    L2Character target;
    for (L2Object obj : targets) {
      if (obj instanceof L2Character) {
        target = (L2Character) obj;
      } else {
        continue;
      }

      byte shld = 0;

      if (Reflect.calcSkillReflect(target, skill) == Variables.SKILL_REFLECT_SUCCEED) {
        target = activeChar;
      }

      // Персонаж, владеющий ПО, не может быть бафнутым и не сам не может никого бафать
      if (skill.getSkillType() == L2SkillType.BUFF
          && activeChar.isNpc()
          && ((L2Npc) activeChar).getClanHall() != null) {
        if (!target.equals(activeChar)) {
          if (target instanceof L2PcInstance) {
            L2PcInstance trg = (L2PcInstance) target;
            if (trg.isCursedWeaponEquipped()) {
              continue;
            }
            // Avoiding block checker players get buffed from outside
            else if (trg.getEventController().isInHandysBlockCheckerEventArena()) {
              continue;
            }
          } else if (player != null && player.isCursedWeaponEquipped()) {
            continue;
          }
        }
      }

      switch (skill.getSkillType()) {
        case HOT:
        case CPHOT:
        case MPHOT:
          if (activeChar.isInvul()) {
            continue;
          }
          break;
      }

      if (skill.isOffensive() || skill.isDebuff()) {
        shld = Shield.calcShldUse(activeChar, target, skill);
        acted = Skills.calcSkillSuccess(activeChar, target, skill, shld, ss, sps, bss);
      }

      if (acted) {
        if (skill.isToggle()) {
          for (L2Effect e : target.getAllEffects()) {
            if (e != null && e.getSkill().getId() == skill.getId()) {
              e.exit();
              return;
            }
          }
        }

        // if this is a debuff let the duel manager know about it
        // so the debuff can be removed after the duel
        // (player & target must be in the same duel)
        if (target instanceof L2PcInstance
            && ((L2PcInstance) target).isInDuel()
            && (skill.getSkillType() == L2SkillType.DEBUFF
                || skill.getSkillType() == L2SkillType.BUFF)
            && player != null
            && player.getDuelId() == ((L2PcInstance) target).getDuelId()) {
          DuelManager dm = DuelManager.getInstance();
          for (L2Effect buff : skill.getEffects(activeChar, target, new Env(shld, ss, sps, bss))) {
            if (buff != null) {
              dm.onBuff((L2PcInstance) target, buff);
            }
          }
        } else {
          L2Effect[] effects = skill.getEffects(activeChar, target, new Env(shld, ss, sps, bss));

          if (target instanceof L2PcInstance && !target.getPets().isEmpty()) {
            for (L2Summon pet : target.getPets()) {
              if (!pet.equals(activeChar)
                  && pet instanceof L2SummonInstance
                  && effects.length > 0) {
                if (effects[0].canBeStolen() || skill.isHeroSkill() || skill.isStatic()) {
                  skill.getEffects(activeChar, pet, new Env(shld, ss, sps, bss));
                }
              }
            }
          }
        }

        if (skill.getSkillType() == L2SkillType.AGGDEBUFF) {
          if (target instanceof L2Attackable) {
            target
                .getAI()
                .notifyEvent(CtrlEvent.EVT_AGGRESSION, activeChar, (int) skill.getPower());
          } else if (target instanceof L2Playable) {
            if (target.getTarget().equals(activeChar)) {
              target.getAI().setIntention(CtrlIntention.AI_INTENTION_ATTACK, activeChar);
            } else {
              target.setTarget(activeChar);
            }
          }
        }
      } else {
        activeChar.sendPacket(SystemMessageId.ATTACK_FAILED);
      }

      // Possibility of a lethal strike
      BlowDamage.calcLethalHit(activeChar, target, skill);
    }

    // self Effect :]
    if (skill.hasSelfEffects()) {
      L2Effect effect = activeChar.getFirstEffect(skill.getId());
      if (effect != null && effect.isSelfEffect()) {
        // Replace old effect with new one.
        effect.exit();
      }
      skill.getEffectsSelf(activeChar);
    }

    activeChar.spsUncharge(skill);
  }
コード例 #4
0
  @Override
  public void useSkill(L2Character activeChar, L2Skill skill, L2Object[] targets) {
    if (!(activeChar instanceof L2PcInstance)) {
      return;
    }

    boolean isMastersCall = skill.getId() == 23249;

    L2PcInstance activePlayer = activeChar.getActingPlayer();

    if (!isMastersCall && !activePlayer.getSummonFriendController().checkSummonerStatus()) {
      return;
    }

    try {
      for (L2Character target : (L2Character[]) targets) {
        if (target == null || activeChar.equals(target) || !target.isPlayer()) {
          continue;
        }

        if (isMastersCall) // Master's Call
        {
          L2Party party = target.getParty();
          if (party != null) {
            party
                .getMembers()
                .stream()
                .filter(partyMember -> !target.equals(partyMember))
                .forEach(
                    partyMember ->
                        partyMember.teleToLocation(
                            target.getX(), target.getY(), target.getZ(), true));
          } else {
            activePlayer.sendPacket(
                SystemMessage.getSystemMessage(SystemMessageId.S1_CANNOT_BE_USED)
                    .addSkillName(skill));
          }
        } else {
          if (skill.isClanSkill()) // Призыв Клана
          {
            if (!target.getActingPlayer().isInSameClan(activePlayer)) {
              activePlayer.sendPacket(
                  SystemMessage.getSystemMessage(SystemMessageId.S1_CANNOT_BE_USED)
                      .addSkillName(skill));
              continue;
            } else if (!target.getActingPlayer().isInSameParty(activePlayer)) {
              activePlayer.sendPacket(
                  SystemMessage.getSystemMessage(SystemMessageId.S1_CANNOT_BE_USED)
                      .addSkillName(skill));
              continue;
            }
          }

          L2PcInstance targetPlayer = target.getActingPlayer();

          if (!Util.checkIfInRange(500, activeChar, target, false)) {
            if (!targetPlayer.getSummonFriendController().setSummoner(activePlayer, skill)) {
              SystemMessage sm =
                  SystemMessage.getSystemMessage(SystemMessageId.C1_ALREADY_SUMMONED);
              sm.addString(target.getName());
              activePlayer.sendPacket(sm);
            }

            ConfirmDlg confirm =
                new ConfirmDlg(
                    SystemMessageId.C1_WISHES_TO_SUMMON_YOU_FROM_S2_DO_YOU_ACCEPT.getId());
            confirm.addCharName(activeChar);
            confirm.addZoneName(activeChar.getX(), activeChar.getY(), activeChar.getZ());
            confirm.addTime(30000);
            confirm.addRequesterId(activePlayer.getObjectId());
            target.sendPacket(confirm);
            // targetPlayer.getSummonFriendController().teleport();
          }
        }
      }
    } catch (Exception e) {
      _log.log(Level.ERROR, "", e);
    }
  }