Guest User

Untitled

a guest
Sep 3rd, 2021
110
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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.  
RAW Paste Data