API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Sep 3rd, 2021
229
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 7.81 KB | None | 0 0
raw download clone embed print report
  1. package net.sf.l2j.gameserver.handler.skillhandlers;
  2.  
  3. import net.sf.l2j.gameserver.handler.ISkillHandler;
  4. import net.sf.l2j.gameserver.handler.SkillHandler;
  5. import net.sf.l2j.gameserver.model.L2Effect;
  6. import net.sf.l2j.gameserver.model.L2Object;
  7. import net.sf.l2j.gameserver.model.L2Skill;
  8. import net.sf.l2j.gameserver.model.actor.L2Character;
  9. import net.sf.l2j.gameserver.model.actor.instance.L2DoorInstance;
  10. import net.sf.l2j.gameserver.model.actor.instance.L2PcInstance;
  11. import net.sf.l2j.gameserver.model.actor.instance.L2SiegeFlagInstance;
  12. import net.sf.l2j.gameserver.network.SystemMessageId;
  13. import net.sf.l2j.gameserver.network.serverpackets.StatusUpdate;
  14. import net.sf.l2j.gameserver.network.serverpackets.SystemMessage;
  15. import net.sf.l2j.gameserver.skills.Formulas;
  16. import net.sf.l2j.gameserver.skills.Stats;
  17. import net.sf.l2j.gameserver.templates.skills.L2SkillType;
  18. import net.sf.l2j.util.Rnd;
  19.  
  20. public class Heal implements ISkillHandler {
  21.     private static final L2SkillType[] SKILL_IDS = { L2SkillType.HEAL,
  22.             L2SkillType.HEAL_PERCENT, L2SkillType.HEAL_STATIC,
  23.             L2SkillType.SUPER_HEAL };
  24.  
  25.     public void useSkill(L2Character activeChar, L2Skill skill,
  26.             L2Object[] targets) {
  27.         int healers = 0;
  28.         int minus = 3;
  29.  
  30.         if (activeChar.getParty() != null) {
  31.             for (L2PcInstance player : activeChar.getParty().getPartyMembers()) {
  32.                 if (player != null && player.isHealerClass()
  33.                         && !player.isInStance()) {
  34.                     healers++;
  35.  
  36.                     if (minus != 2
  37.                             && (player.getPvpFlag() != 0 || player.getKarma() > 0
  38.                         minus = 2;
  39.                 }
  40.             }
  41.         }
  42.  
  43.         // check for other effects
  44.         try {
  45.             ISkillHandler handler = SkillHandler.getInstance().getSkillHandler(
  46.                     L2SkillType.BUFF);
  47.  
  48.             if (handler != null)
  49.                 handler.useSkill(activeChar, skill, targets);
  50.         } catch (Exception e) {
  51.         }
  52.  
  53.         L2PcInstance player = null;
  54.         if (activeChar instanceof L2PcInstance)
  55.             player = (L2PcInstance) activeChar;
  56.  
  57.         for (L2Character target : (L2Character[]) targets) {
  58.             // We should not heal if char is dead
  59.             if (target == null || target.isDead())
  60.                 continue;
  61.  
  62.             // Player holding a cursed weapon can't be healed and can't heal
  63.             if (target != activeChar) {
  64.                 if (target instanceof L2PcInstance
  65.                         && ((L2PcInstance) target).isCursedWeaponEquipped())
  66.                     continue;
  67.                 else if (player != null && player.isCursedWeaponEquipped())
  68.                     continue;
  69.             }
  70.  
  71.             double hp = skill.getPower(activeChar);
  72.  
  73.             if (skill.getSkillType() == L2SkillType.HEAL_PERCENT
  74.                     || skill.getSkillType() == L2SkillType.SUPER_HEAL) {
  75.                 hp = target.getMaxHp() * hp / 100.0;
  76.             } else {
  77.                 hp *= 1.2;
  78.             }
  79.  
  80.             if (healers >= 2) // 2 or more healers in party
  81.             {
  82.                 int nerfValue = (2 + (healers - minus));
  83.                 hp /= nerfValue;
  84.             }
  85.  
  86.             final double healEffectiveness = target.calcStat(
  87.                     Stats.HEAL_EFFECTIVNESS, 1, null, skill);
  88.  
  89.             if (target instanceof L2DoorInstance
  90.                     || target instanceof L2SiegeFlagInstance) {
  91.                 hp = 0;
  92.             } else {
  93.                 if (skill.getSkillType() == L2SkillType.HEAL_STATIC) {
  94.                     hp = skill.getPower(activeChar);
  95.                 } else if (skill.getSkillType() != L2SkillType.HEAL_PERCENT
  96.                         && skill.getSkillType() != L2SkillType.SUPER_HEAL) {
  97.                     hp *= healEffectiveness;
  98.                     // Healer proficiency (since CT1)
  99.                     hp *= activeChar.calcStat(Stats.HEAL_PROFICIENCY, 1, null,
  100.                             skill);
  101.                     // Extra bonus (since CT1.5)
  102.  
  103.                     if (!skill.isPotion()) {
  104.                         hp += target.calcStat(Stats.HEAL_STATIC_BONUS, 0, null,
  105.                                 skill);
  106.  
  107.                         // Heal critic, since CT2.3 Gracia Final
  108.                         if (skill.getSkillType() == L2SkillType.HEAL
  109.                                 && Formulas.calcMCritHeal(activeChar
  110.                                         .getMCriticalHit(target, skill))) {
  111.                             activeChar.sendPacket(new SystemMessage(
  112.                                     SystemMessageId.CRITICAL_HIT_MAGIC));
  113.                             hp *= activeChar.calcStat(
  114.                                     Stats.MAGIC_CRITICAL_DAMAGE, 1.7, null,
  115.                                     skill);
  116.                         }
  117.                     }
  118.                 } else // must be heal_percent or super_heal
  119.                 {
  120.                     if (healEffectiveness < 1)
  121.                         hp *= healEffectiveness;
  122.                 }
  123.             }
  124.  
  125.             final int targetHp = (int) target.getCurrentHp();
  126.  
  127.             if (targetHp + hp > target.getMaxHp()) {
  128.                 hp = target.getMaxHp() - targetHp;
  129.             }
  130.  
  131.             if (hp > 0) {
  132.                 target.setCurrentHp(hp + targetHp);
  133.                 target.setLastHealAmount((int) hp);
  134.                 StatusUpdate su = new StatusUpdate(target.getObjectId());
  135.                 su.addAttribute(StatusUpdate.CUR_HP,
  136.                         (int) target.getCurrentHp());
  137.                 target.sendPacket(su);
  138.  
  139.                 if (target instanceof L2PcInstance) {
  140.                     if (skill.getId() == 4051) {
  141.                         SystemMessage sm = new SystemMessage(
  142.                                 SystemMessageId.REJUVENATING_HP);
  143.                         target.sendPacket(sm);
  144.                     } else {
  145.                         if (activeChar instanceof L2PcInstance
  146.                                 && activeChar != target) {
  147.                             SystemMessage sm = new SystemMessage(
  148.                                     SystemMessageId.S2_HP_RESTORED_BY_C1);
  149.                             sm.addCharName(activeChar);
  150.                             sm.addNumber((int) hp);
  151.                             target.sendPacket(sm);
  152.                             activeChar.sendMessage("You healed "
  153.                                     + target.getDisplayName() + " for "
  154.                                     + (int) hp + " HP");
  155.                         } else {
  156.                             SystemMessage sm = new SystemMessage(
  157.                                     SystemMessageId.S1_HP_RESTORED);
  158.                             sm.addNumber((int) hp);
  159.                             target.sendPacket(sm);
  160.                         }
  161.                     }
  162.                 }
  163.             }
  164.  
  165.             if (skill.getSkillType() == L2SkillType.SUPER_HEAL) {
  166.                 if (target instanceof L2PcInstance) {
  167.                     int cp = (int) (target.getMaxCp()
  168.                             * skill.getPower(activeChar) / 100.0);
  169.  
  170.                     if ((target.getStatus().getCurrentCp() + cp) >= target
  171.                             .getMaxCp())
  172.                         cp = (int) (target.getMaxCp() - target.getStatus()
  173.                                 .getCurrentCp());
  174.  
  175.                     if (cp > 0) {
  176.                         target.getStatus().setCurrentCp(
  177.                                 cp + target.getStatus().getCurrentCp());
  178.                         StatusUpdate sump = new StatusUpdate(
  179.                                 target.getObjectId());
  180.                         sump.addAttribute(StatusUpdate.CUR_CP, (int) target
  181.                                 .getStatus().getCurrentCp());
  182.                         target.sendPacket(sump);
  183.  
  184.                         if (activeChar instanceof L2PcInstance
  185.                                 && activeChar != target) {
  186.                             SystemMessage sm = new SystemMessage(
  187.                                     SystemMessageId.S1_CP_WILL_BE_RESTORED);
  188.                             sm.addNumber(cp);
  189.                             target.sendPacket(sm);
  190.                             activeChar.sendMessage("You CP-healed "
  191.                                     + target.getDisplayName() + " for " + cp
  192.                                     + " CP");
  193.                         } else {
  194.                             SystemMessage sm = new SystemMessage(
  195.                                     SystemMessageId.S1_CP_WILL_BE_RESTORED);
  196.                             sm.addNumber(cp);
  197.                             target.sendPacket(sm);
  198.                         }
  199.                     }
  200.                 }
  201.  
  202.                 int mp = (int) (target.getMaxMp() * skill.getPower(activeChar) / 100.0);
  203.  
  204.                 if ((target.getStatus().getCurrentMp() + mp) >= target
  205.                         .getMaxMp())
  206.                     mp = (int) (target.getMaxMp() - target.getStatus()
  207.                             .getCurrentMp());
  208.  
  209.                 if (mp > 0) {
  210.                     target.getStatus().setCurrentMp(
  211.                             mp + target.getStatus().getCurrentMp());
  212.                     StatusUpdate sump = new StatusUpdate(target.getObjectId());
  213.                     sump.addAttribute(StatusUpdate.CUR_MP, (int) target
  214.                             .getStatus().getCurrentMp());
  215.                     target.sendPacket(sump);
  216.  
  217.                     if (activeChar instanceof L2PcInstance
  218.                             && activeChar != target) {
  219.                         SystemMessage sm = new SystemMessage(
  220.                                 SystemMessageId.S2_MP_RESTORED_BY_C1);
  221.                         sm.addCharName(activeChar);
  222.                         sm.addNumber(mp);
  223.                         target.sendPacket(sm);
  224.                         activeChar.sendMessage("You recharged "
  225.                                 + target.getDisplayName() + " for " + mp
  226.                                 + " MP");
  227.                     } else {
  228.                         SystemMessage sm = new SystemMessage(
  229.                                 SystemMessageId.S1_MP_RESTORED);
  230.                         sm.addNumber(mp);
  231.                         target.sendPacket(sm);
  232.                     }
  233.                 }
  234.  
  235.                 for (L2Effect e : target.getAllEffects()) {
  236.                     if (e != null && e.getSkill().isDebuff()) {
  237.                         e.exit();
  238.  
  239.                         if (Rnd.get(100) > 40)
  240.                             break;
  241.                     }
  242.                 }
  243.             }
  244.         }
  245.     }
  246.  
  247.     /**
  248.      *
  249.      * @see net.sf.l2j.gameserver.handler.ISkillHandler#getSkillIds()
  250.      */
  251.     public L2SkillType[] getSkillIds() {
  252.         return SKILL_IDS;
  253.     }
  254. }
  255.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!