Rev l2worldzone skill "Fatal Counter" com problema, ajuda!

[Emanuel De Almeida Silva]

Boa noite,

Preciso de uma ajuda para decifrar o problema dela. Como não mexo com HTML nem programação, pouco conheço sobre as configurações.

Mas pelo que deu para perceber ela é igual a "Curse Death Link" do Necromancer, sendo Fighter (P.damage). Quanto menos HP maior o dano.

O que acontece é que nessa rev, ela não aciona o SoulShot para causar um dano maior e causa um dano insignificante, não soma o P.atk+dano da skill. E nem faz a função dela.

Na configuração de skills esta assim         <set name="skillType" val="FATAL" />  

Vou colocar em sequencia os handlers da "Fatal Counter" e "Curse Death Link" coloquei em vermelho a palavra.

Spoiler

ackage handlers.skillhandlers;

import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;

import com.l2jserver.Config;
import com.l2jserver.gameserver.datatables.SkillTable;
import com.l2jserver.gameserver.handler.ISkillHandler;
import com.l2jserver.gameserver.model.L2Object;
import com.l2jserver.gameserver.model.ShotType;
import com.l2jserver.gameserver.model.actor.L2Character;
import com.l2jserver.gameserver.model.effects.L2Effect;
import com.l2jserver.gameserver.model.skills.L2Skill;
import com.l2jserver.gameserver.model.skills.L2SkillType;
import com.l2jserver.gameserver.model.stats.BaseStats;
import com.l2jserver.gameserver.model.stats.Env;
import com.l2jserver.gameserver.model.stats.Formulas;
import com.l2jserver.gameserver.network.SystemMessageId;
import com.l2jserver.gameserver.network.serverpackets.SystemMessage;

public class Pdam implements ISkillHandler
{
    private static final Logger _logDamage = Logger.getLogger("damage");
    
    private static final L2SkillType[] SKILL_IDS =
    {
        L2SkillType.PDAM,
        L2SkillType.FATAL    
    };
    
    @Override
    public void useSkill(L2Character activeChar, L2Skill skill, L2Object[] targets)
    {
        if (activeChar.isAlikeDead())
        {
            return;
        }
        
        if (((skill.getFlyRadius() > 0) || (skill.getFlyType() != null)) && activeChar.isMovementDisabled())
        {
            SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.S1_CANNOT_BE_USED);
            sm.addSkillName(skill);
            activeChar.sendPacket(sm);
            return;
        }
        
        int damage = 0;
        
        boolean ss = skill.useSoulShot() && activeChar.isChargedShot(ShotType.SOULSHOTS);
        
        for (L2Character target : (L2Character[]) targets)
        {
            
            if (activeChar.isPlayer() && target.isPlayer() && target.getActingPlayer().isFakeDeath())
            {
                target.stopFakeDeath(true);
            }
            else if (target.isDead())
            {
                continue;
            }
            
            final boolean dual = activeChar.isUsingDualWeapon();
            final byte shld = Formulas.calcShldUse(activeChar, target, skill);
            // PDAM critical chance not affected by buffs, only by STR. Only some skills are meant to crit.
            boolean crit = false;
            if (!skill.isStaticDamage() && (skill.getBaseCritRate() > 0))
            {
                crit = Formulas.calcCrit(skill.getBaseCritRate() * 10 * BaseStats.STR.calcBonus(activeChar), true, target);
            }
            
            if (!crit && ((skill.getCondition() & L2Skill.COND_CRIT) != 0))
            {
                damage = 0;
            }
            else
            {
                damage = skill.isStaticDamage() ? (int) skill.getPower() : (int) Formulas.calcPhysDam(activeChar, target, skill, shld, false, dual, ss);
            }
            if (!skill.isStaticDamage() && (skill.getMaxSoulConsumeCount() > 0) && activeChar.isPlayer())
            {
                // Souls Formula (each soul increase +4%)
                int chargedSouls = (activeChar.getActingPlayer().getChargedSouls() <= skill.getMaxSoulConsumeCount()) ? activeChar.getActingPlayer().getChargedSouls() : skill.getMaxSoulConsumeCount();
                damage *= 1 + (chargedSouls * 0.04);
            }
            if (crit)
            {
                damage *= 2; // PDAM Critical damage always 2x and not affected by buffs
            }
            
            final boolean skillIsEvaded = Formulas.calcPhysicalSkillEvasion(target, skill);
            final byte reflect = Formulas.calcSkillReflect(target, skill);
            
            if (!skillIsEvaded)
            {
                if (skill.hasEffects())
                {
                    L2Effect[] effects;
                    if ((reflect & Formulas.SKILL_REFLECT_SUCCEED) != 0)
                    {
                        activeChar.stopSkillEffects(skill.getId());
                        effects = skill.getEffects(target, activeChar);
                        if ((effects != null) && (effects.length > 0))
                        {
                            SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.YOU_FEEL_S1_EFFECT);
                            sm.addSkillName(skill);
                            activeChar.sendPacket(sm);
                        }
                    }
                    else
                    {
                        // activate attacked effects, if any
                        target.stopSkillEffects(skill.getId());
                        effects = skill.getEffects(activeChar, target, new Env(shld, false, false, false));
                        if ((effects != null) && (effects.length > 0))
                        {
                            SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.YOU_FEEL_S1_EFFECT);
                            sm.addSkillName(skill);
                            target.sendPacket(sm);
                        }
                    }
                }
                
                if (damage > 0)
                {
                    activeChar.sendDamageMessage(target, damage, false, crit, false);
                    
                    if (Config.LOG_GAME_DAMAGE && activeChar.isPlayable() && (damage > Config.LOG_GAME_DAMAGE_THRESHOLD))
                    {
                        LogRecord record = new LogRecord(Level.INFO, "");
                        record.setParameters(new Object[]
                        {
                            activeChar,
                            " did damage ",
                            damage,
                            skill,
                            " to ",
                            target
                        });
                        record.setLoggerName("pdam");
                        _logDamage.log(record);
                    }
                    
                    // Possibility of a lethal strike
                    Formulas.calcLethalHit(activeChar, target, skill);
                    
                    target.reduceCurrentHp(damage, activeChar, skill);
                    
                    // vengeance reflected damage
                    if ((reflect & Formulas.SKILL_REFLECT_VENGEANCE) != 0)
                    {
                        if (target.isPlayer())
                        {
                            SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.COUNTERED_C1_ATTACK);
                            sm.addCharName(activeChar);
                            target.sendPacket(sm);
                        }
                        if (activeChar.isPlayer())
                        {
                            SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.C1_PERFORMING_COUNTERATTACK);
                            sm.addCharName(target);
                            activeChar.sendPacket(sm);
                        }
                        // Formula from Diego Vargas post:

O conteúdo está oculto, favor efetuar login ou se cadastrar!

• Entre
• ou
• Cadastre-se

                        // 1189 x Your PATK / PDEF of target
                        double vegdamage = ((1189 * target.getPAtk(activeChar)) / activeChar.getPDef(target));
                        activeChar.reduceCurrentHp(vegdamage, target, skill);
                    }
                }
                else
                {
                    // No damage
                    activeChar.sendPacket(SystemMessageId.ATTACK_FAILED);
                }
            }
            else
            {
                if (activeChar.isPlayer())
                {
                    SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.C1_DODGES_ATTACK);
                    sm.addString(target.getName());
                    activeChar.getActingPlayer().sendPacket(sm);
                }
                if (target.isPlayer())
                {
                    SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.AVOIDED_C1_ATTACK);
                    sm.addString(activeChar.getName());
                    target.getActingPlayer().sendPacket(sm);
                }
                
                // Possibility of a lethal strike despite skill is evaded
                Formulas.calcLethalHit(activeChar, target, skill);
            }
            
            if (activeChar.isPlayer())
            {
                int soulMasteryLevel = activeChar.getSkillLevel(467);
                if (soulMasteryLevel > 0)
                {
                    L2Skill soulmastery = SkillTable.getInstance().getInfo(467, soulMasteryLevel);
                    if (soulmastery != null)
                    {
                        if (activeChar.getActingPlayer().getChargedSouls() < soulmastery.getNumSouls())
                        {
                            int count = 0;
                            
                            if ((activeChar.getActingPlayer().getChargedSouls() + skill.getNumSouls()) <= soulmastery.getNumSouls())
                            {
                                count = skill.getNumSouls();
                            }
                            else
                            {
                                count = soulmastery.getNumSouls() - activeChar.getActingPlayer().getChargedSouls();
                            }
                            activeChar.getActingPlayer().increaseSouls(count);
                        }
                        else
                        {
                            SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.SOUL_CANNOT_BE_INCREASED_ANYMORE);
                            activeChar.getActingPlayer().sendPacket(sm);
                        }
                    }
                }
            }
        }
        
        // self Effect :]
        if (skill.hasSelfEffects())
        {
            final L2Effect effect = activeChar.getFirstEffect(skill.getId());
            if ((effect != null) && effect.isSelfEffect())
            {
                // Replace old effect with new one.
                effect.exit();
            }
            skill.getEffectsSelf(activeChar);
        }
        
        activeChar.setChargedShot(ShotType.SOULSHOTS, false);
        
        if (skill.isSuicideAttack())
        {
            activeChar.doDie(activeChar);
        }
    }
    
    @Override
    public L2SkillType[] getSkillIds()
    {
        return SKILL_IDS;
    }
}
 

Spoiler

package handlers.skillhandlers;

import java.util.logging.Level;
import java.util.logging.LogRecord;
import java.util.logging.Logger;

import com.l2jserver.Config;
import com.l2jserver.gameserver.handler.ISkillHandler;
import com.l2jserver.gameserver.model.L2Object;
import com.l2jserver.gameserver.model.ShotType;
import com.l2jserver.gameserver.model.actor.L2Character;
import com.l2jserver.gameserver.model.effects.L2Effect;
import com.l2jserver.gameserver.model.skills.L2Skill;
import com.l2jserver.gameserver.model.skills.L2SkillType;
import com.l2jserver.gameserver.model.stats.Env;
import com.l2jserver.gameserver.model.stats.Formulas;
import com.l2jserver.gameserver.network.SystemMessageId;
import com.l2jserver.gameserver.network.serverpackets.SystemMessage;

public class Mdam implements ISkillHandler
{
    protected static final Logger _log = Logger.getLogger(Mdam.class.getName());
    private static final Logger _logDamage = Logger.getLogger("damage");
    
    private static final L2SkillType[] SKILL_IDS =
    {
        L2SkillType.MDAM,
        L2SkillType.DEATHLINK
    };
    
    @Override
    public void useSkill(L2Character activeChar, L2Skill skill, L2Object[] targets)
    {
        if (activeChar.isAlikeDead())
        {
            return;
        }
        
        boolean ss = skill.useSoulShot() && activeChar.isChargedShot(ShotType.SOULSHOTS);
        boolean sps = skill.useSpiritShot() && activeChar.isChargedShot(ShotType.SPIRITSHOTS);
        boolean bss = skill.useSpiritShot() && activeChar.isChargedShot(ShotType.BLESSED_SPIRITSHOTS);
        
        for (L2Character target : (L2Character[]) targets)
        {
            if (activeChar.isPlayer() && target.isPlayer() && target.getActingPlayer().isFakeDeath())
            {
                target.stopFakeDeath(true);
            }
            else if (target.isDead())
            {
                continue;
            }
            
            final boolean mcrit = Formulas.calcMCrit(activeChar.getMCriticalHit(target, skill));
            final byte shld = Formulas.calcShldUse(activeChar, target, skill);
            final byte reflect = Formulas.calcSkillReflect(target, skill);
            
            int damage = skill.isStaticDamage() ? (int) skill.getPower() : (int) Formulas.calcMagicDam(activeChar, target, skill, shld, sps, bss, mcrit);
            
            // Curse of Divinity Formula (each buff increase +30%)
            if (!skill.isStaticDamage() && skill.getDependOnTargetBuff())
            {
                damage *= (((target.getBuffCount() * 0.3) + 1.3) / 4);
            }
            
            if (!skill.isStaticDamage() && (skill.getMaxSoulConsumeCount() > 0) && activeChar.isPlayer())
            {
                // Souls Formula (each soul increase +4%)
                int chargedSouls = (activeChar.getActingPlayer().getChargedSouls() <= skill.getMaxSoulConsumeCount()) ? activeChar.getActingPlayer().getChargedSouls() : skill.getMaxSoulConsumeCount();
                damage *= 1 + (chargedSouls * 0.04);
            }
            
            // Possibility of a lethal strike
            Formulas.calcLethalHit(activeChar, target, skill);
            
            if (damage > 0)
            {
                // Manage attack or cast break of the target (calculating rate, sending message...)
                if (!target.isRaid() && Formulas.calcAtkBreak(target, damage))
                {
                    target.breakAttack();
                    target.breakCast();
                }
                
                // vengeance reflected damage
                // DS: because only skill using vengeanceMdam is Shield Deflect Magic
                // and for this skill no damage should pass to target, just hardcode it for now
                if ((reflect & Formulas.SKILL_REFLECT_VENGEANCE) != 0)
                {
                    activeChar.reduceCurrentHp(damage, target, skill);
                }
                else
                {
                    activeChar.sendDamageMessage(target, damage, mcrit, false, false);
                    target.reduceCurrentHp(damage, activeChar, skill);
                }
                
                if (skill.hasEffects())
                {
                    if ((reflect & Formulas.SKILL_REFLECT_SUCCEED) != 0) // reflect skill effects
                    {
                        activeChar.stopSkillEffects(skill.getId());
                        skill.getEffects(target, activeChar);
                        SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.YOU_FEEL_S1_EFFECT);
                        sm.addSkillName(skill);
                        activeChar.sendPacket(sm);
                    }
                    else
                    {
                        // activate attacked effects, if any
                        target.stopSkillEffects(skill.getId());
                        if (Formulas.calcSkillSuccess(activeChar, target, skill, shld, ss, sps, bss))
                        {
                            skill.getEffects(activeChar, target, new Env(shld, ss, sps, bss));
                        }
                        else
                        {
                            SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.C1_RESISTED_YOUR_S2);
                            sm.addCharName(target);
                            sm.addSkillName(skill);
                            activeChar.sendPacket(sm);
                        }
                    }
                }
                
                // Logging damage
                if (Config.LOG_GAME_DAMAGE && activeChar.isPlayable() && (damage > Config.LOG_GAME_DAMAGE_THRESHOLD))
                {
                    LogRecord record = new LogRecord(Level.INFO, "");
                    record.setParameters(new Object[]
                    {
                        activeChar,
                        " did damage ",
                        damage,
                        skill,
                        " to ",
                        target
                    });
                    record.setLoggerName("mdam");
                    _logDamage.log(record);
                }
            }
        }
        
        // self Effect :]
        if (skill.hasSelfEffects())
        {
            final L2Effect effect = activeChar.getFirstEffect(skill.getId());
            if ((effect != null) && effect.isSelfEffect())
            {
                // Replace old effect with new one.
                effect.exit();
            }
            skill.getEffectsSelf(activeChar);
        }
        
        activeChar.setChargedShot(bss ? ShotType.BLESSED_SPIRITSHOTS : ShotType.SPIRITSHOTS, false);
        
        if (skill.isSuicideAttack())
        {
            activeChar.doDie(activeChar);
        }
    }
    
    @Override
    public L2SkillType[] getSkillIds()
    {
        return SKILL_IDS;
    }
}
 

 

Por que a skill não está funcionando como a "Curse Death Link" ?