надпись о получении Exp, SP

[doDie]

Если она вам так мешает сделайте

а смысл? если мне нужно так только для l2guard.

Добавлено через 11 минут

if(!(npc instanceof L2Guard))
{

плз подскажите а как сделать эту проверку, что бы не инициализировать npc в параметрах метода?
или хотелось бы вообще сделать чтото вроде
L2character target;
if(!(target instanceof L2Guard))
{...}

как правильно инициализировать target, что бы компиль не ругался?

[rage]

а смысл? если мне нужно так только для l2guard.

Добавлено через 11 минут

плз подскажите а как сделать эту проверку, что бы не инициализировать npc в параметрах метода?
или хотелось бы вообще сделать чтото вроде
L2character target;
if(!(target instanceof L2Guard))
{...}

как правильно инициализировать target, что бы компиль не ругался?

Про это вам и говорили, что в этом методе не известно за что дают опыт.

[doDie]

блин, а как тогда найти именно то?
просто есть только это сообщение о получении экспы и все.

Где можно проверить выше?
подскажите плз

Добавлено через 17 часов 11 минут
может быть так?

Код:

    @Override
    public boolean addExpAndSp(long addToExp, int addToSp)
    {
        float ratioTakenByPet = 0;

        //Player is Gm and acces level is below or equal to GM_DONT_TAKE_EXPSP and is in party, don't give Xp/Sp
        L2PcInstance activeChar = getActiveChar();
        if(!activeChar.getAccessLevel().canGainExp() && activeChar.isInParty())
            return false;
        
        if(activeChar.getTarget() instanceof L2GuardInstance)
        {
            return false;
        }

[Visor]

Если у вас ненужно чтобы и экспа шла на гвардах, то нужно делать в классе из которого это вызывается public boolean addExpAndSp(long addToExp, int addToSp)
А для пати тоже в том классе - где идет вызов дистрибьюции экспы на пати.

Вы что не понимаете что в этой процедуре public boolean addExpAndSp(long addToExp, int addToSp) нет нпц или гварда? не нужно лепить там проверку цели или какие-то еще велосипеды.

[rage]

В этом топике уже написали все, что нужно для решения вашей "проблемы".

[doDie]

делать в классе из которого это вызывается public boolean addExpAndSp(long addToExp, int addToSp)

Я вам уже 3 раз пишу вопрос о том, откуда же оно вызывается? Алгоритм я понял еще с первых ответов.
Я искал-переискал, и не могу понять где это вообще может быть? Если знаете, подскажите пожалуйста. Ведь в отдельных инстанцах за убийство - такого нет, а где еще искать, я даже не предполагаю..(

[Visor]

Алгоритм я понял еще с первых ответов.
Я искал-переискал, и не могу понять где это вообще может быть?

Я не знаю как вы смотрите код, в блокноте, в фаре или еще как-то. В редакторах типа эклипсы поиск по выделенному методу работает хорошо.
Если же вы делаете что-то не понимаете и хотите найти - нужно взять и тем же поиском в виндовсе или в фаре поискать на "содержит слова" addExpAndSp

Хотя навеное на этом форуме подразумевается по дефолту, что человек может найти в файлах строки методов самостоятельно.

[doDie]

Я не знаю как вы смотрите код, в блокноте, в фаре или еще как-то. В редакторах типа эклипсы поиск по выделенному методу работает хорошо.
Если же вы делаете что-то не понимаете и хотите найти - нужно взять и тем же поиском в виндовсе или в фаре поискать на "содержит слова" addExpAndSp

Нет.. вы не поняли. Я же написал:

Я искал-переискал, и не могу понять где это вообще может быть?

сам метод addExpAndSp, используется только в том файле, о котором шла речь в самом первом посте. В ЭТОм то и дело.. Никаких проверок свыше вообще нет.
По поиску этого метода в IDE, находит разве что L2Party.java, в котором сами знаете что происходит.
А так, есть только PlayebleStat.java:

Код:

/* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
* 02111-1307, USA.
*
* http://www.gnu.org/copyleft/gpl.html
*/
package com.l2jfrozen.gameserver.model.actor.stat;

import com.l2jfrozen.gameserver.model.actor.instance.L2PlayableInstance;
import com.l2jfrozen.gameserver.model.base.Experience;

public class PlayableStat extends CharStat
{
    // =========================================================
    // Data Field

    // =========================================================
    // Constructor
    public PlayableStat(L2PlayableInstance activeChar)
    {
        super(activeChar);
    }

    // =========================================================
    // Method - Public
    public boolean addExp(long value)
    {
        if(getExp() + value < 0 || getExp() == getExpForLevel(Experience.MAX_LEVEL) - 1)
            return true;

        if(getExp() + value >= getExpForLevel(Experience.MAX_LEVEL))
        {
            value = getExpForLevel(Experience.MAX_LEVEL) - 1 - getExp();
        }

        setExp(getExp() + value);

        byte level = 1;

        for(level = 1; level <= Experience.MAX_LEVEL; level++)
        {
            if(getExp() >= getExpForLevel(level))
            {
                continue;
            }
            --level;
            break;
        }

        if(level != getLevel())
        {
            addLevel((byte) (level - getLevel()));
        }

        return true;
    }

    public boolean removeExp(long value)
    {
        if(getExp() - value < 0)
        {
            value = getExp() - 1;
        }

        setExp(getExp() - value);

        byte level = 0;

        for(level = 1; level <= Experience.MAX_LEVEL; level++)
        {
            if(getExp() >= getExpForLevel(level))
            {
                continue;
            }

            level--;
            break;
        }

        if(level != getLevel())
        {
            addLevel((byte) (level - getLevel()));
        }

        return true;
    }

    public boolean addExpAndSp(long addToExp, int addToSp)
    {
        boolean expAdded = false;
        boolean spAdded = false;

        if(addToExp >= 0)
        {
            expAdded = addExp(addToExp);
        }

        if(addToSp >= 0)
        {
            spAdded = addSp(addToSp);
        }

        return expAdded || spAdded;
    }

    public boolean removeExpAndSp(long removeExp, int removeSp)
    {
        boolean expRemoved = false;
        boolean spRemoved = false;

        if(removeExp > 0)
        {
            expRemoved = removeExp(removeExp);
        }

        if(removeSp > 0)
        {
            spRemoved = removeSp(removeSp);
        }

        return expRemoved || spRemoved;
    }

    public boolean addLevel(byte value)
    {
        if(getLevel() + value > Experience.MAX_LEVEL - 1)
        {
            if(getLevel() < Experience.MAX_LEVEL - 1)
            {
                value = (byte) (Experience.MAX_LEVEL - 1 - getLevel());
            }
            else
                return false;
        }

        boolean levelIncreased = getLevel() + value > getLevel();
        value += getLevel();
        setLevel(value);

        // Sync up exp with current level
        if(getExp() >= getExpForLevel(getLevel() + 1) || getExpForLevel(getLevel()) > getExp())
        {
            setExp(getExpForLevel(getLevel()));
        }

        if(!levelIncreased)
            return false;

        getActiveChar().getStatus().setCurrentHp(getActiveChar().getStat().getMaxHp());
        getActiveChar().getStatus().setCurrentMp(getActiveChar().getStat().getMaxMp());

        return true;
    }

    public boolean addSp(int value)
    {
        if(value < 0)
        {
            System.out.println("wrong usage");
            return false;
        }

        int currentSp = getSp();

        if(currentSp == Integer.MAX_VALUE)
            return false;

        if(currentSp > Integer.MAX_VALUE - value)
        {
            value = Integer.MAX_VALUE - currentSp;
        }

        setSp(currentSp + value);

        return true;
    }

    public boolean removeSp(int value)
    {
        int currentSp = getSp();

        if(currentSp < value)
        {
            value = currentSp;
        }

        setSp(getSp() - value);

        return true;
    }

    public long getExpForLevel(int level)
    {
        return level;
    }

    // =========================================================
    // Method - Private

    // =========================================================
    // Property - Public
    @Override
    public L2PlayableInstance getActiveChar()
    {
        return (L2PlayableInstance) super.getActiveChar();
    }
}

Собсна и все..(

[Visor]

Тут эти методы объявлены и реализованы - но их выдывают обычно после кила моба в другом методе.
К примеру в л2ж это в L2Attackable

[doDie]

Тут эти методы объявлены и реализованы - но их выдывают обычно после кила моба в другом методе.
К примеру в л2ж это в L2Attackable

Спасибо вам большое! Именно там и было. Очень странно что эклипс не находил ничего.

собственно это Calculate Rewards:

Код:

    @Override
    protected void calculateRewards(L2Character lastAttacker)
    {
        // Creates an empty list of rewards
        FastMap<L2Character, RewardInfo> rewards = new FastMap<L2Character, RewardInfo>().shared();

        try
        {
            if(getAggroListRP().isEmpty())
                return;

            L2PcInstance maxDealer = null;
            int maxDamage = 0;

            int damage;

            L2Character attacker, ddealer;
            RewardInfo reward;

            // While Interacting over This Map Removing Object is Not Allowed
            synchronized (getAggroList())
            {
                // Go through the _aggroList of the L2Attackable
                for(AggroInfo info : getAggroListRP().values())
                {
                    if(info == null)
                    {
                        continue;
                    }

                    // Get the L2Character corresponding to this attacker
                    attacker = info._attacker;

                    // Get damages done by this attacker
                    damage = info._damage;

                    // Prevent unwanted behavior
                    if(damage > 1)
                    {
                        if(attacker instanceof L2SummonInstance || attacker instanceof L2PetInstance && ((L2PetInstance) attacker).getPetData().getOwnerExpTaken() > 0)
                        {
                            ddealer = ((L2Summon) attacker).getOwner();
                        }
                        else
                        {
                            ddealer = info._attacker;
                        }

                        // Check if ddealer isn't too far from this (killed monster)
                        if(!Util.checkIfInRange(Config.ALT_PARTY_RANGE, this, ddealer, true))
                        {
                            continue;
                        }

                        // Calculate real damages (Summoners should get own damage plus summon's damage)
                        reward = rewards.get(ddealer);

                        if(reward == null)
                        {
                            reward = new RewardInfo(ddealer, damage);
                        }
                        else
                        {
                            reward.addDamage(damage);
                        }

                        rewards.put(ddealer, reward);
                        
                        if (ddealer instanceof L2PlayableInstance && ((L2PlayableInstance)ddealer).getActingPlayer() != null && reward._dmg > maxDamage)
                        {
                            maxDealer = ((L2PlayableInstance)ddealer).getActingPlayer();
                            maxDamage = reward._dmg;
                        }
                        
                    }
                }
            }

            // Manage Base, Quests and Sweep drops of the L2Attackable
            doItemDrop(maxDealer != null && maxDealer.isOnline() == 1 ? maxDealer : lastAttacker);
            
            // Manage drop of Special Events created by GM for a defined period
            doEventDrop(maxDealer != null && maxDealer.isOnline() == 1 ? maxDealer : lastAttacker);

            if(!getMustRewardExpSP())
                return;
            
            if(!rewards.isEmpty())
            {
                L2Party attackerParty;
                long exp;
                int levelDiff, partyDmg, partyLvl, sp;
                float partyMul, penalty;
                RewardInfo reward2;
                int[] tmp;

                for(FastMap.Entry<L2Character, RewardInfo> entry = rewards.head(), end = rewards.tail(); (entry = entry.getNext()) != end;)
                {
                    if(entry == null)
                    {
                        continue;
                    }

                    reward = entry.getValue();

                    if(reward == null)
                    {
                        continue;
                    }

                    // Penalty applied to the attacker's XP
                    penalty = 0;

                    // Attacker to be rewarded
                    attacker = reward._attacker;

                    // Total amount of damage done
                    damage = reward._dmg;

                    // If the attacker is a Pet, get the party of the owner
                    if(attacker instanceof L2PetInstance)
                    {
                        attackerParty = ((L2PetInstance) attacker).getParty();
                    }
                    else if(attacker instanceof L2PcInstance)
                    {
                        attackerParty = ((L2PcInstance) attacker).getParty();
                    }
                    else
                        return;

                    // If this attacker is a L2PcInstance with a summoned L2SummonInstance, get Exp Penalty applied for the current summoned L2SummonInstance
                    if(attacker instanceof L2PcInstance && ((L2PcInstance) attacker).getPet() instanceof L2SummonInstance)
                    {
                        penalty = ((L2SummonInstance) ((L2PcInstance) attacker).getPet()).getExpPenalty();
                    }

                    // We must avoid "over damage", if any
                    if(damage > getMaxHp())
                    {
                        damage = getMaxHp();
                    }

                    // If there's NO party in progress
                    if(attackerParty == null)
                    {
                        // Calculate Exp and SP rewards
                        if(attacker.getKnownList().knowsObject(this))
                        {
                            // Calculate the difference of level between this attacker (L2PcInstance or L2SummonInstance owner) and the L2Attackable
                            // mob = 24, atk = 10, diff = -14 (full xp)
                            // mob = 24, atk = 28, diff = 4 (some xp)
                            // mob = 24, atk = 50, diff = 26 (no xp)
                            levelDiff = attacker.getLevel() - getLevel();

                            tmp = calculateExpAndSp(levelDiff, damage);
                            exp = tmp[0];
                            exp *= 1 - penalty;
                            sp = tmp[1];

                            if(Config.L2JMOD_CHAMPION_ENABLE && isChampion())
                            {
                                exp *= Config.L2JMOD_CHAMPION_REWARDS;
                                sp *= Config.L2JMOD_CHAMPION_REWARDS;
                            }

                            // Check for an over-hit enabled strike and Donator options
                            if(attacker instanceof L2PcInstance)
                            {
                                L2PcInstance player = (L2PcInstance) attacker;
                                if(isOverhit() && attacker == getOverhitAttacker())
                                {
                                    player.sendPacket(new SystemMessage(SystemMessageId.OVER_HIT));
                                    exp += calculateOverhitExp(exp);
                                }
                                if(player.isDonator())
                                {
                                    exp = (long) (exp * Config.DONATOR_XPSP_RATE);
                                    sp = (int) (sp * Config.DONATOR_XPSP_RATE);
                                }

                                player = null;
                            }

                            // Distribute the Exp and SP between the L2PcInstance and its L2Summon
                            if(!attacker.isDead())
                            {
                                attacker.addExpAndSp(Math.round(attacker.calcStat(Stats.EXPSP_RATE, exp, null, null)), (int) attacker.calcStat(Stats.EXPSP_RATE, sp, null, null));
                            }
                        }
                    }
                    else
                    {
                        //share with party members
                        partyDmg = 0;
                        partyMul = 1.f;
                        partyLvl = 0;

                        // Get all L2Character that can be rewarded in the party
                        List<L2PlayableInstance> rewardedMembers = new FastList<L2PlayableInstance>();

                        // Go through all L2PcInstance in the party
                        List<L2PcInstance> groupMembers;

                        if(attackerParty.isInCommandChannel())
                        {
                            groupMembers = attackerParty.getCommandChannel().getMembers();
                        }
                        else
                        {
                            groupMembers = attackerParty.getPartyMembers();
                        }

                        for(L2PcInstance pl : groupMembers)
                        {
                            if(pl == null || pl.isDead())
                            {
                                continue;
                            }

                            // Get the RewardInfo of this L2PcInstance from L2Attackable rewards
                            reward2 = rewards.get(pl);

                            // If the L2PcInstance is in the L2Attackable rewards add its damages to party damages
                            if(reward2 != null)
                            {
                                if(Util.checkIfInRange(Config.ALT_PARTY_RANGE, this, pl, true))
                                {
                                    partyDmg += reward2._dmg; // Add L2PcInstance damages to party damages
                                    rewardedMembers.add(pl);

                                    if(pl.getLevel() > partyLvl)
                                    {
                                        if(attackerParty.isInCommandChannel())
                                        {
                                            partyLvl = attackerParty.getCommandChannel().getLevel();
                                        }
                                        else
                                        {
                                            partyLvl = pl.getLevel();
                                        }
                                    }
                                }

                                rewards.remove(pl); // Remove the L2PcInstance from the L2Attackable rewards
                            }
                            else
                            {
                                // Add L2PcInstance of the party (that have attacked or not) to members that can be rewarded
                                // and in range of the monster.
                                if(Util.checkIfInRange(Config.ALT_PARTY_RANGE, this, pl, true))
                                {
                                    rewardedMembers.add(pl);

                                    if(pl.getLevel() > partyLvl)
                                    {
                                        if(attackerParty.isInCommandChannel())
                                        {
                                            partyLvl = attackerParty.getCommandChannel().getLevel();
                                        }
                                        else
                                        {
                                            partyLvl = pl.getLevel();
                                        }
                                    }
                                }
                            }

                            L2PlayableInstance summon = pl.getPet();

                            if(summon != null && summon instanceof L2PetInstance)
                            {
                                reward2 = rewards.get(summon);

                                if(reward2 != null) // Pets are only added if they have done damage
                                {
                                    if(Util.checkIfInRange(Config.ALT_PARTY_RANGE, this, summon, true))
                                    {
                                        partyDmg += reward2._dmg; // Add summon damages to party damages
                                        rewardedMembers.add(summon);

                                        if(summon.getLevel() > partyLvl)
                                        {
                                            partyLvl = summon.getLevel();
                                        }
                                    }

                                    rewards.remove(summon); // Remove the summon from the L2Attackable rewards
                                }
                            }

                            summon = null;
                        }

                        // If the party didn't killed this L2Attackable alone
                        if(partyDmg < getMaxHp())
                        {
                            partyMul = (float) partyDmg / (float) getMaxHp();
                        }

                        // Avoid "over damage"
                        if(partyDmg > getMaxHp())
                        {
                            partyDmg = getMaxHp();
                        }

                        // Calculate the level difference between Party and L2Attackable
                        levelDiff = partyLvl - getLevel();

                        // Calculate Exp and SP rewards
                        tmp = calculateExpAndSp(levelDiff, partyDmg);
                        exp = tmp[0];
                        sp = tmp[1];

                        if(Config.L2JMOD_CHAMPION_ENABLE && isChampion())
                        {
                            exp *= Config.L2JMOD_CHAMPION_REWARDS;
                            sp *= Config.L2JMOD_CHAMPION_REWARDS;
                        }

                        exp *= partyMul;
                        sp *= partyMul;

                        // Check for an over-hit enabled strike
                        // (When in party, the over-hit exp bonus is given to the whole party and splitted proportionally through the party members)
                        if(attacker instanceof L2PcInstance)
                        {
                            L2PcInstance player = (L2PcInstance) attacker;

                            if(isOverhit() && attacker == getOverhitAttacker())
                            {
                                player.sendPacket(new SystemMessage(SystemMessageId.OVER_HIT));
                                exp += calculateOverhitExp(exp);
                            }

                            player = null;
                        }

                        // Distribute Experience and SP rewards to L2PcInstance Party members in the known area of the last attacker
                        if(partyDmg > 0)
                        {
                            attackerParty.distributeXpAndSp(exp, sp, rewardedMembers, partyLvl);
                        }

                        groupMembers = null;
                        rewardedMembers = null;
                    }
                }

                attackerParty = null;
                reward2 = null;
            }

            rewards = null;
            attacker = null;
            ddealer = null;

        }
        catch(Exception e)
        {
            _log.log(Level.SEVERE, "", e);
        }
    }

интересует последний вопрос, как лучше проверить именно на инстанс?, ведь здесь есть только attacker. а нужно сделать как бы проверку на target.

я понимаю, что такой вариант:

Код:

if(activeChar.getTarget() instanceof L2NpcWalkerInstance)
{
    return false;
}

довольно некорректен для данной ситуации, ведь речь идет об уже мертвой цели.

вот этот участок кода из L2Attackable, где нужно проверять на инстанс:

Код:

// Distribute the Exp and SP between the L2PcInstance and its L2Summon
if(!attacker.isDead())
{                            attacker.addExpAndSp(Math.round(attacker.calcStat(Stats.EXPSP_RATE, exp, null, null)), (int) attacker.calcStat(Stats.EXPSP_RATE, sp, null, null));
}