стоимость

Crystal: привет всем меня очень сильно заинтересовала команда ФЕНИКС и её сборки но поевление этих сборок как-то странно или там крыса завелась или это ход такой со стороны команды спросите что за ход такой? ну к примеру баги наружу народ выевляет а ани себе науме читают форумы где косяки или же черт его разбереш но наверно все-таки им нужно пообщаться с народом

Поиск юзай, таких тем как твоя тысяча,
Чесно уже надоело писать одно и тоже 100 раз

Crystal: привет всем меня очень сильно заинтересовала команда ФЕНИКС и её сборки но поевление этих сборок как-то странно или там крыса завелась или это ход такой со стороны команды спросите что за ход такой? ну к примеру баги наружу народ выевляет а ани себе науме читают форумы где косяки или же черт его разбереш но наверно все-таки им нужно пообщаться с народом

тебя беспокоит что у ребят завелась крыса или что ребята умрут без общения?
ты из общества святой терезы? или из общества защиты феникса?

какой твой тут интерес?

Lelouch: На сколько я знаю сборки случайно слитые, после моего ухода из фениксов точнее скажем меня убрали как ненужный элемент у них осталось 3-4 человека. Это так сказать основатели феникса и их родители.

Если магистр больше не в фениксах то в команде осталось 3 человека активных. И уж поверьте они имеют со своих разработок достаточно чтобы заниматься своими разработками дальше без напряга и чьей либо помощи.

package l2p.debug.benchmark;

import l2p.gameserver.geodata.GeoEngine;

public class GeoCheckOptimized
{
public static void main(String[] args)
throws Exception
{
common.init();
l2p.Config.GEOFILES_PATTERN = "(\\d{2}_\\d{2})\\.l2j";
l2p.Config.ALLOW_DOORS = false; <---- НЕ ПОДСКАЖЕШ ПОЧЕМУ ТУТ FALSE
l2p.Config.COMPACT_GEO = true;
GeoEngine.loadGeo();
common.PromptEnterToContinue();
}
}

Crystal: l2p.Config.ALLOW_DOORS = false; <---- НЕ ПОДСКАЖЕШ ПОЧЕМУ ТУТ FALSE

tanomist:

иеще вот это што такое


package l2p.gameserver.skills;

import java.io.File;
import java.io.IOException;
import java.util.Map.Entry;
import java.util.TreeMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.logging.Logger;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import l2p.Config;
import l2p.extensions.multilang.CustomMessage;
import l2p.gameserver.cache.Msg;
import l2p.gameserver.instancemanager.CastleManager;
import l2p.gameserver.instancemanager.ClanHallManager;
import l2p.gameserver.instancemanager.FortressManager;
import l2p.gameserver.model.EffectList;
import l2p.gameserver.model.L2Character;
import l2p.gameserver.model.L2Clan;
import l2p.gameserver.model.L2Effect.EffectType;
import l2p.gameserver.model.L2Playable;
import l2p.gameserver.model.L2Player;
import l2p.gameserver.model.L2Skill;
import l2p.gameserver.model.L2Skill.SkillType;
import l2p.gameserver.model.L2Summon;
import l2p.gameserver.model.PcInventory;
import l2p.gameserver.model.base.ClassId;
import l2p.gameserver.model.base.Race;
import l2p.gameserver.model.entity.SevenSigns;
import l2p.gameserver.model.entity.residence.Castle;
import l2p.gameserver.model.entity.residence.ClanHall;
import l2p.gameserver.model.entity.residence.Fortress;
import l2p.gameserver.model.entity.residence.ResidenceFunction;
import l2p.gameserver.model.entity.residence.ResidenceType;
import l2p.gameserver.model.instances.L2ItemInstance;
import l2p.gameserver.model.instances.L2RaidBossInstance;
import l2p.gameserver.serverpackets.SystemMessage;
import l2p.gameserver.skills.conditions.Condition;
import l2p.gameserver.skills.conditions.ConditionPlayerState;
import l2p.gameserver.skills.conditions.ConditionPlayerState.CheckPlayerState;
import l2p.gameserver.skills.funcs.Func;
import l2p.gameserver.templates.L2Armor.ArmorType;
import l2p.gameserver.templates.L2CharTemplate;
import l2p.gameserver.templates.L2PlayerTemplate;
import l2p.gameserver.templates.L2Weapon;
import l2p.gameserver.templates.L2Weapon.WeaponType;
import l2p.util.Rnd;
import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.xml.sax.SAXException;

public class Formulas
{
protected static final Logger _log = Logger.getLogger(L2Character.class.getName());
public static int MAX_STAT_VALUE = 100;
public static final double[] WITbonus = new double[MAX_STAT_VALUE];
public static final double[] MENbonus = new double[MAX_STAT_VALUE];
public static final double[] INTbonus = new double[MAX_STAT_VALUE];
public static final double[] STRbonus = new double[MAX_STAT_VALUE];
public static final double[] DEXbonus = new double[MAX_STAT_VALUE];
public static final double[] CONbonus = new double[MAX_STAT_VALUE];

public static void addFuncsToNewCharacter(L2Character cha)
{
if (cha.isPlayer())
{
cha.addStatFunc(FuncMultRegenResting.getFunc(Stats.REGENERATE_CP_RATE));
cha.addStatFunc(FuncMultRegenStanding.getFunc(Stats.REGENERATE_CP_RATE));
cha.addStatFunc(FuncMultRegenRunning.getFunc(Stats.REGENERATE_CP_RATE));
cha.addStatFunc(FuncMultRegenResting.getFunc(Stats.REGENERATE_HP_RATE));
cha.addStatFunc(FuncMultRegenStanding.getFunc(Stats.REGENERATE_HP_RATE));
cha.addStatFunc(FuncMultRegenRunning.getFunc(Stats.REGENERATE_HP_RATE));
cha.addStatFunc(FuncMultRegenResting.getFunc(Stats.REGENERATE_MP_RATE));
cha.addStatFunc(FuncMultRegenStanding.getFunc(Stats.REGENERATE_MP_RATE));
cha.addStatFunc(FuncMultRegenRunning.getFunc(Stats.REGENERATE_MP_RATE));

cha.addStatFunc(FuncMaxCpAdd.func);
cha.addStatFunc(FuncMaxHpAdd.func);
cha.addStatFunc(FuncMaxMpAdd.func);

cha.addStatFunc(FuncMaxCpMul.func);
cha.addStatFunc(FuncMaxHpMul.func);
cha.addStatFunc(FuncMaxMpMul.func);

cha.addStatFunc(FuncAttackRange.func);

cha.addStatFunc(FuncMoveSpeedMul.func);

cha.addStatFunc(FuncHennaSTR.func);
cha.addStatFunc(FuncHennaDEX.func);
cha.addStatFunc(FuncHennaINT.func);
cha.addStatFunc(FuncHennaMEN.func);
cha.addStatFunc(FuncHennaCON.func);
cha.addStatFunc(FuncHennaWIT.func);

cha.addStatFunc(FuncInventory.func);
cha.addStatFunc(FuncWarehouse.func);
cha.addStatFunc(FuncTradeLimit.func);

cha.addStatFunc(FuncFatalBlowMul.func);

cha.addStatFunc(FuncPAtkMul.func);
cha.addStatFunc(FuncMAtkMul.func);
cha.addStatFunc(FuncPDefMul.func);
cha.addStatFunc(FuncMDefMul.func);

cha.addStatFunc(FuncPCriticalDmgRcpt.func);

cha.addStatFunc(FuncPAtkSpeedMul.func);
cha.addStatFunc(FuncMAtkSpeedMul.func);

cha.addStatFunc(FuncSDefPlayers.func);
}

cha.addStatFunc(FuncSDefAll.func);

cha.addStatFunc(FuncPCriticalRateMul.func);
cha.addStatFunc(FuncMCriticalRateMul.func);

cha.addStatFunc(FuncAccuracyAdd.func);
cha.addStatFunc(FuncEvasionAdd.func);

cha.addStatFunc(FuncPDamageResists.func);
cha.addStatFunc(FuncMDamageResists.func);
}

public static double calcHpRegen(L2Character cha)
{
double init;
if (cha.isPlayer())
init = ((cha.getLevel() <= 10) ? 1.95D + cha.getLevel() / 20.0D : 1.3999999999999999D + cha.getLevel() / 10.0D) * cha.getLevelMod() * CONbonus[cha.getCON()];
else
init = cha.getTemplate().baseHpReg * CONbonus[cha.getCON()];

if (cha instanceof L2Playable)
{
L2Player player = cha.getPlayer();
if ((player != null) && (player.getClan() != null) && (player.getInResidence() != ResidenceType.None))
switch (1.$SwitchMap$l2p$gameserver$model$entity$residence$ResidenceType[player.getInResidence().ordinal()])
{
case 1:
int clanHallIndex = player.getClan().getHasHideout();
if (clanHallIndex <= 0)
break label329;
ClanHall clansHall = ClanHallManager.getInstance().getClanHall(clanHallIndex);
if ((clansHall == null) ||
(!(clansHall.isFunctionActive(3)))) break label209;
init = init * (1D + clansHall.getFunction(3).getLevel() / 100.0D);
break;
case 2:
int caslteIndex = player.getClan().getHasCastle();
if (caslteIndex <= 0)
break label329;
Castle castle = CastleManager.getInstance().getCastleByIndex(caslteIndex);
if ((castle == null) ||
(!(castle.isFunctionActive(3)))) break label269;
init = init * (1D + castle.getFunction(3).getLevel() / 100.0D);
break;
case 3:
label209: int fortIndex = player.getClan().getHasCastle();
label269: if (fortIndex <= 0)
break label329;
Fortress fort = FortressManager.getInstance().getFortressByIndex(fortIndex);
if ((fort == null) ||
(!(fort.isFunctionActive(3)))) break label329;
init = init * (1D + fort.getFunction(3).getLevel() / 100.0D);
}


}

label329: return cha.calcStat(Stats.REGENERATE_HP_RATE, init, null, null);
}

public static double calcMpRegen(L2Character cha)
{
double init;
if (cha.isPlayer())
init = (0.87D + cha.getLevel() * 0.029999999999999999D) * cha.getLevelMod();
else
init = cha.getTemplate().baseMpReg;

if (cha.isPlayable())
init = init * MENbonus[cha.getMEN()];
if (cha.isSummon())
init = init * 2.0D;
if (cha.isRaid())
init = init * 3.0D;

if (cha.isPlayable())
{
L2Player player = cha.getPlayer();
if (player != null)
{
L2Clan clan = player.getClan();
if (clan != null)
switch (1.$SwitchMap$l2p$gameserver$model$entity$residence$ResidenceType[player.getInResidence().ordinal()])
{
case 1:
int clanHallIndex = clan.getHasHideout();
if (clanHallIndex <= 0)
break label319;
ClanHall clansHall = ClanHallManager.getInstance().getClanHall(clanHallIndex);
if ((clansHall == null) ||
(!(clansHall.isFunctionActive(4)))) break label203;
init = init * (1D + clansHall.getFunction(4).getLevel() / 100.0D);
break;
case 2:
int caslteIndex = clan.getHasCastle();
if (caslteIndex <= 0)
break label319;
Castle castle = CastleManager.getInstance().getCastleByIndex(caslteIndex);
if ((castle == null) ||
(!(castle.isFunctionActive(4)))) break label261;
init = init * (1D + castle.getFunction(4).getLevel() / 100.0D);
break;
case 3:
label203: int fortIndex = clan.getHasCastle();
label261: if (fortIndex <= 0)
break label319;
Fortress fort = FortressManager.getInstance().getFortressByIndex(fortIndex);
if ((fort == null) ||
(!(fort.isFunctionActive(4)))) break label319;
init = init * (1D + fort.getFunction(4).getLevel() / 100.0D);
}

}

}

label319: return cha.calcStat(Stats.REGENERATE_MP_RATE, init, null, null);
}

public static double calcCpRegen(L2Character cha)
{
double init = (1.5D + cha.getLevel() / 10) * cha.getLevelMod() * CONbonus[cha.getCON()];
return cha.calcStat(Stats.REGENERATE_CP_RATE, init, null, null);
}

public static AttackInfo calcPhysDam(L2Character attacker, L2Character target, L2Skill skill, boolean dual, boolean blow, boolean ss)
{
target.doCounterAttack(skill, attacker);

AttackInfo info = new AttackInfo();

info.damage = attacker.getPAtk(target);
info.defence = target.getPDef(attacker);
info.crit_rcpt = (0.01D * target.calcStat(Stats.CRIT_DAMAGE_RECEPTIVE, null, null));
info.crit_static = attacker.calcStat(Stats.CRITICAL_DAMAGE_STATIC, target, null);
info.death_rcpt = (0.01D * target.calcStat(Stats.DEATH_RECEPTIVE, 100.0D, null, null));
info.lethal1 = ((skill == null) ? 0D : skill.getLethal1() * info.death_rcpt);
info.lethal2 = ((skill == null) ? 0D : skill.getLethal1() * info.death_rcpt);
info.crit = calcCrit(attacker, target, skill);
info.shld = ((((skill == null) || (!(skill.getShieldIgnore())))) && (calcShldUse(attacker, target)));
info.lethal = false;

if (info.shld)
info.defence = (info.defence + target.getShldDef());

if (!(info.defence < 0D))
info.defence = 1D;

if (skill != null)
{
double power = Math.max(0D, skill.getPower());

if (blow)
power = info.crit_rcpt * (power + info.crit_static) * 0.01D * attacker.calcStat(Stats.CRITICAL_DAMAGE, target, skill);

info.damage = (info.damage + power);

if (skill.isChargeBoost())
info.damage = (info.damage * (0.80000000000000004D + 0.20000000000000001D * attacker.getIncreasedForce()));

if (skill.isSoulBoost())
info.damage = (info.damage * (1D + 0.059999999999999998D * Math.min(attacker.getConsumedSouls(), 5)));

if (info.crit)
info.damage = ((1D + info.crit_rcpt) * info.damage);
}
else
{
if (dual)
info.damage = (info.damage / 2.0D);

if (info.crit)
{
info.damage = ((1D + info.crit_rcpt) * info.damage * 0.01D * attacker.calcStat(Stats.CRITICAL_DAMAGE, target, skill));
info.damage = (info.damage + info.crit_static);
}
}

if (info.crit)
{
int chance = attacker.getSkillLevel(Integer.valueOf(467));
if (chance > 0)
{
if (chance >= 21)
chance = 30;
else if (chance >= 15)
chance = 25;
else if (chance >= 9)
chance = 20;
else if (chance >= 4)
chance = 15;
if (Rnd.chance(chance))
attacker.setConsumedSouls(attacker.getConsumedSouls() + 1, null);
}
}

switch (1.$SwitchMap$l2p$gameserver$model$L2Character$TargetDirection[attacker.getDirectionTo(target, true).ordinal()])
{
case 1:
info.damage = (info.damage * ((info.crit) ? 1.1000000000000001D : 1.2D));
break;
case 2:
info.damage = (info.damage * ((info.crit) ? 1.0249999999999999D : 1.05D));
}

if (ss)
info.damage = (info.damage * ((blow) ? 1.5D : 2.0D));

info.damage = (info.damage * 70.0D / info.defence);
info.damage = (info.damage * (1F + (Rnd.get() * attacker.getRandomDamage() * 2F - attacker.getRandomDamage()) / 100.0F));
info.damage = attacker.calcStat(Stats.PHYSICAL_DAMAGE, info.damage, target, skill);

if ((attacker.isSummon()) && (target.isPlayer()))
info.damage = (info.damage * 0.90000000000000002D);

if ((info.shld) && (Rnd.chance(5))) {
info.damage = 1D;
}

if (skill != null)
{
if (info.shld)
if (!(info.damage < 1D))
target.sendPacket(Msg.YOUR_EXCELLENT_SHIELD_DEFENSE_WAS_A_SUCCESS);
else
target.sendPacket(Msg.YOUR_SHIELD_DEFENSE_HAS_SUCCEEDED);

if (Rnd.chance(target.calcStat(Stats.PSKILL_EVASION, 0D, null, skill)))
{
attacker.sendPacket(new SystemMessage(2265).addName(attacker));
target.sendPacket(new SystemMessage(2264).addName(target).addName(attacker));
info.damage = 1D;
}

if ((info.damage < 1D) && (skill.isDeathlink()))
info.damage = (info.damage * 1.8D * (1D - attacker.getCurrentHpRatio()));

if (Rnd.chance(info.lethal1))
{
if (target.isPlayer())
{
info.damage = Math.max(info.damage, target.getCurrentCp());
target.sendPacket(Msg.CP_DISAPPEARS_WHEN_HIT_WITH_A_HALF_KILL_SKILL);
info.lethal = true;
}
else if (target.isLethalImmune())
info.damage = (info.damage * 2.0D);
else
info.damage = Math.max(info.damage, target.getCurrentHp() / 2.0D);
attacker.sendPacket(Msg.HALF_KILL);
}
else if (Rnd.chance(info.lethal2))
{
if (target.isPlayer())
{
info.damage = Math.max(info.damage, target.getCurrentHp() + target.getCurrentCp() - 1D);
target.sendPacket(Msg.LETHAL_STRIKE);
info.lethal = true;
}
else if (target.isLethalImmune())
info.damage = (info.damage * 3.0D);
else
info.damage = Math.max(info.damage, target.getCurrentHp());
attacker.sendPacket(Msg.YOUR_LETHAL_STRIKE_WAS_SUCCESSFUL);
}

if (attacker instanceof L2Summon)
((L2Summon)attacker).displayHitMessage(target, (int)info.damage, info.crit, false);
else if (attacker instanceof L2Player)
{
if (info.crit)
attacker.sendPacket(new SystemMessage(2266).addName(attacker));
attacker.sendPacket(new SystemMessage(2261).addName(attacker).addName(target).addNumber(Integer.valueOf(
(int)info.damage)));
}

if ((target.isStunned()) && (calcStunBreak(info.crit)))
{
target.getEffectList().stopEffects(L2Effect.EffectType.Stun);
target.getEffectList().stopEffects(L2Effect.EffectType.Turner);
}

if (calcCastBreak(target, info.crit))
target.breakCast(false);
}

info.damage = Math.max(1D, info.damage);

return info;
}

public static double calcMagicDam(L2Character attacker, L2Character target, L2Skill skill, int sps)
{
boolean shield = (skill.getShieldIgnore()) && (calcShldUse(attacker, target));

double mAtk = attacker.getMAtk(target, skill);

if (sps == 2)
mAtk = mAtk * 4.0D;
else if (sps == 1)
mAtk = mAtk * 2.0D;

double mdef = target.getMDef(null, skill);

if (shield)
mdef = mdef + target.getShldDef();
if (!(mdef < 0D))
mdef = 1D;

double power = skill.getPower();

if (skill.isSoulBoost())
power = power * (1D + 0.059999999999999998D * Math.min(attacker.getConsumedSouls(), 5));

double damage = 91.0D * power * Math.sqrt(mAtk) / mdef;

damage = damage * (1F + (Rnd.get() * attacker.getRandomDamage() * 2F - attacker.getRandomDamage()) / 100.0F);

boolean crit = calcMCrit(attacker.getMagicCriticalRate(target, skill));

if (crit)
damage = damage * 3.0D;

damage = attacker.calcStat(Stats.MAGIC_DAMAGE, damage, target, skill);

if (shield)
{
if (Rnd.chance(5))
{
damage = 1D;
target.sendPacket(Msg.YOUR_EXCELLENT_SHIELD_DEFENSE_WAS_A_SUCCESS);
}
else
target.sendPacket(Msg.YOUR_SHIELD_DEFENSE_HAS_SUCCEEDED);
attacker.sendMessage("Spell deflected");
}

int mLevel = (skill.getMagicLevel() == 0) ? attacker.getLevel() : skill.getMagicLevel();
int levelDiff = target.getLevel() - mLevel;

if (levelDiff > -4)
{
SystemMessage msg;
double failChance = 5 * Math.max(1, levelDiff);
if (Rnd.chance(0.10000000000000001D * failChance))
{
damage = 1D;
msg = new SystemMessage(2269).addName(target).addName(attacker);
attacker.sendPacket(msg);
target.sendPacket(msg);
}
else if (Rnd.chance(failChance))
{
damage = damage / 2.0D;
msg = new SystemMessage(2280).addName(target).addName(attacker);
attacker.sendPacket(msg);
target.sendPacket(msg);
}
}

if (Rnd.chance(target.calcStat(Stats.MSKILL_EVASION, 0D, null, skill)))
{
attacker.sendPacket(new SystemMessage(2265).addName(attacker));
target.sendPacket(new SystemMessage(2264).addName(target).addName(attacker));
damage = 1D;
}

if ((damage < 1D) && (skill.isDeathlink()))
damage = damage * 1.8D * (1D - attacker.getCurrentHpRatio());

if ((damage < 1D) && (skill.isBasedOnTargetDebuff()))
damage = damage * (1D + 0.050000000000000003D * target.getEffectList().getAllEffects().size());

if (attacker instanceof L2Summon)
((L2Summon)attacker).displayHitMessage(target, (int)damage, crit, false);
else if (attacker instanceof L2Player)
{
if (crit)
attacker.sendPacket(new SystemMessage(1280).addName(attacker));
attacker.sendPacket(new SystemMessage(2261).addName(attacker).addName(target).addNumber(Integer.valueOf(
(int)damage)));
}

if (calcCastBreak(target, crit))
target.breakCast(false);

return damage;
}

public static boolean calcStunBreak(boolean crit)
{
return Rnd.chance(10);
}

public static boolean calcBlow(L2Character activeChar, L2Character target, L2Skill skill)
{
return Rnd.chance((int)activeChar.calcStat(Stats.FATALBLOW_RATE, activeChar.getDEX(), target, skill));
}

public static boolean calcCrit(L2Character attacker, L2Character target, L2Skill skill)
{
if ((attacker.isPlayer()) && (attacker.getActiveWeaponItem() == null))
return false;
if ((skill != null) && (!(skill.isCritical())))
return false;

int rate = (skill == null) ? attacker.getCriticalHit(target, null) : (int)(attacker.getTemplate().baseCritRate * STRbonus[attacker.getSTR()]);
if (skill == null)
{
rate = (int)(rate * 0.01D * target.calcStat(Stats.CRIT_CHANCE_RECEPTIVE, null, null));
switch (1.$SwitchMap$l2p$gameserver$model$L2Character$TargetDirection[attacker.getDirectionTo(target, true).ordinal()])
{
case 1:
rate = (int)(rate * 1.3999999999999999D);
break;
case 2:
rate = (int)(rate * 1.2D);
}

}

return (!(Rnd.get() * 1000.0F > rate));
}

public static boolean calcMCrit(double mRate)
{
return (!(Rnd.get() * 100.0F > Math.min(Config.LIM_MCRIT.intValue(), mRate)));
}

public static boolean calcCastBreak(L2Character target, boolean crit)
{
if ((target.isCastingNow()) && (!(target instanceof L2RaidBossInstance)));
return (Rnd.chance((int)target.calcStat(Stats.CAST_INTERRUPT, 10.0D, null, null)));
}

public static int calcPAtkSpd(double rate)
{
return (int)(500000.0D / rate);
}

public static int calcMAtkSpd(L2Character attacker, L2Skill skill, double skillTime)
{
if (skill.isMagic())
return (int)(skillTime * 333.0D / Math.max(attacker.getMAtkSpd(), 1));
return (int)(skillTime * 333.0D / Math.max(attacker.getPAtkSpd(), 1));
}

public static long calcSkillReuseDelay(L2Character actor, L2Skill skill)
{
long reuseDelay = skill.getReuseDelay();
if (!(actor.isPlayable()))
if (skill.isMagic())
reuseDelay = 0L;
else {
if (skill.isMagic());
reuseDelay = Math.min(skill.getHitTime() + 5000, reuseDelay); }
if ((skill.isReuseDelayPermanent()) || (skill.isHandler()) || (skill.isItemSkill()))
return reuseDelay;
if (actor.getSkillMastery(Integer.valueOf(skill.getId())) == 1)
{
actor.removeSkillMastery(Integer.valueOf(skill.getId()));
return 0L;
}
if (skill.isMagic())
return ()(actor.calcStat(Stats.MAGIC_REUSE_RATE, reuseDelay, null, skill) * 333.0D / Math.max(actor.getMAtkSpd(), 1));
return (()actor.calcStat(Stats.PHYSIC_REUSE_RATE, reuseDelay, null, skill) * 333 / Math.max(actor.getPAtkSpd(), 1));
}

public static boolean calcHitMiss(L2Character attacker, L2Character target)
{
int chanceToHit = 88 + 2 * (attacker.getAccuracy() - target.getEvasionRate(attacker));

chanceToHit = Math.max(chanceToHit, 28);
chanceToHit = Math.min(chanceToHit, 98);

if (attacker.isBehindTarget(target))
chanceToHit = (int)(chanceToHit * 1.2D);
if (attacker.isToSideOfTarget(target))
chanceToHit = (int)(chanceToHit * 1.1000000000000001D);

return (!(Rnd.chance(chanceToHit)));
}

public static boolean calcShldUse(L2Character attacker, L2Character target)
{
int angle = (int)target.calcStat(Stats.SHIELD_ANGLE, null, null);
if (!(target.isInFront(attacker, angle)))
return false;
return Rnd.chance(target.calcStat(Stats.SHIELD_RATE, attacker, null)); }
// ERROR //
public static double calcSavevsDependence(int save, L2Character cha) { // Byte code:
// 0: iload_0
// 1: tableswitch default:+93 -> 94, 1:+39->40, 2:+48->49, 3:+57->58, 4:+66->67, 5:+75->76, 6:+84->85
// 41: aconst_null
// 42: iconst_2
// 43: aload_1
// 44: invokevirtual 262 l2p/gameserver/model/L2Character:getINT ()B
// 47: daload
// 48: dreturn
// 49: getstatic 263 l2p/gameserver/skills/Formulas:WITbonus [D
// 52: aload_1
// 53: invokevirtual 264 l2p/gameserver/model/L2Character:getWIT ()B
// 56: daload
// 57: dreturn
// 58: getstatic 88 l2p/gameserver/skills/Formulas:MENbonus [D
// 61: aload_1
// 62: invokevirtual 89 l2p/gameserver/model/L2Character:getMEN ()B
// 65: daload
// 66: dreturn
// 67: getstatic 53 l2p/gameserver/skills/Formulas:CONbonus [D
// 70: aload_1
// 71: invokevirtual 54 l2p/gameserver/model/L2Character:getCON ()B
// 74: daload
// 75: dreturn
// 76: getstatic 265 l2p/gameserver/skills/Formulas:DEXbonus [D
// 79: aload_1
// 80: invokevirtual 215 l2p/gameserver/model/L2Character:getDEX ()B
// 83: daload
// 84: dreturn
// 85: getstatic 220 l2p/gameserver/skills/Formulas:STRbonus [D
// 88: aload_1
// 89: invokevirtual 221 l2p/gameserver/model/L2Character:getSTR ()B
// 92: daload
// 93: dreturn
// 94: goto +44 -> 138
// 97: astore_2
// 98: getstatic 267 l2p/gameserver/skills/Formulas:_log Ljava/util/logging/Logger;
// 101: new 268 java/lang/StringBuilder
// 104: dup
// 105: invokespecial 269 java/lang/StringBuilder:<init> ()V
// 108: ldc_w 270
// 111: invokevirtual 271 java/lang/StringBuilder:append (Ljava/lang/String;)Ljava/lang/StringBuilder;
// 114: aload_1
// 115: invokevirtual 272 java/lang/StringBuilder:append (Ljava/lang/Object;)Ljava/lang/StringBuilder;
// 118: ldc_w 273
// 121: invokevirtual 271 java/lang/StringBuilder:append (Ljava/lang/String;)Ljava/lang/StringBuilder;
// 124: iload_0
// 125: invokevirtual 274 java/lang/StringBuilder:append (I)Ljava/lang/StringBuilder;
// 128: invokevirtual 275 java/lang/StringBuilder:toString ()Ljava/lang/String;
// 131: invokevirtual 276 java/util/logging/Logger:warning (Ljava/lang/String;)V
// 134: aload_2
// 135: invokevirtual 277 java/lang/ArrayIndexOutOfBoundsException:printStackTrace ()V
// 138: dconst_1
// 139: dreturn
//
// Exception table:
// from to target type
// 0 48 97 java/lang/ArrayIndexOutOfBoundsException
// 49 57 97 java/lang/ArrayIndexOutOfBoundsException
// 58 66 97 java/lang/ArrayIndexOutOfBoundsException
// 67 75 97 java/lang/ArrayIndexOutOfBoundsException
// 76 84 97 java/lang/ArrayIndexOutOfBoundsException
// 85 93 97 java/lang/ArrayIndexOutOfBoundsException }
public static boolean calcSkillSuccess(Env env, Stats resistType, Stats attibuteType) { if (!(env.value < -1.0D))
return true;

env.value = Math.max(Math.min(env.value, 100.0D), 1D);

double min = Math.min(env.value, Config.SKILLS_CHANCE_MIN);

if (env.skill.isMagic())
{
int mdef = Math.max(1, env.target.getMDef(env.target, env.skill));

env.value = (env.value * Config.SKILLS_CHANCE_MOD * Math.sqrt(env.character.getMAtk(env.target, env.skill)) / mdef);

if (env.skill.isSSPossible())
switch (env.character.getChargedSpiritShot())
{
case 1:
env.value = (env.value * 1.4099999999999999D);
break;
case 2:
env.value = (env.value * 2.0D);
}

}

env.value = Math.max(Math.min(env.value, 100.0D), 1D);

env.value = (env.value / calcSavevsDependence(env.skill.getSavevs(), env.target));

if (resistType != null)
env.value = (env.value * 0.01D * env.target.calcStat(resistType, 100.0D, null, null));

if (attibuteType != null)
env.value = (env.value * 0.01D * env.character.calcStat(attibuteType, 100.0D, null, null));

env.value = env.character.calcStat(Stats.ACTIVATE_RATE, env.value, env.target, env.skill);

if (env.skill.isSoulBoost())
env.value = (env.value * (0.84999999999999998D + 0.059999999999999998D * Math.min(env.character.getConsumedSouls(), 5)));

env.value = Math.max(env.value, min);

double mLevel = env.skill.getMagicLevel();
env.value = (env.value + (mLevel - env.target.getLevel()) * env.skill.getLevelModifier());

env.value = Math.max(Math.min(env.value, Config.SKILLS_CHANCE_CAP), 1D);

if ((Config.SKILLS_SHOW_CHANCE) && (env.character.isPlayer()) && (!(((L2Player)(L2Player)env.character).getVarB("SkillsHideChance"))))
env.character.sendMessage(new CustomMessage("l2p.gameserver.skills.Formulas.Chance", env.character).addString(env.skill.getName()).addNumber((int)env.value));

return Rnd.chance(env.value);
}

public static boolean calcSkillSuccess(L2Character player, L2Character target, L2Skill skill)
{
Env env = new Env();
env.character = player;
env.target = target;
env.skill = skill;
env.value = skill.getActivateRate();
switch (1.$SwitchMap$l2p$gameserver$model$L2Skill$SkillType[skill.getSkillType().ordinal()])
{
case 1:
case 2:
case 3:
return calcSkillSuccess(env, Stats.CANCEL_RECEPTIVE, Stats.CANCEL_POWER);
case 4:
return calcSkillSuccess(env, Stats.MENTAL_RECEPTIVE, Stats.MENTAL_POWER);
}
return calcSkillSuccess(env, null, null);
}

public static void calcSkillMastery(L2Skill skill, L2Character activeChar)
{
if (skill.isHandler()) {
return;
}

if (((activeChar.getSkillLevel(Integer.valueOf(331)) > 0) && (!(activeChar.calcStat(Stats.SKILL_MASTERY, activeChar.getINT(), null, skill) < Rnd.get(1000)))) || ((activeChar.getSkillLevel(Integer.valueOf(330)) > 0) && (!(activeChar.calcStat(Stats.SKILL_MASTERY, activeChar.getSTR(), null, skill) < Rnd.get(1000)))))
{
byte masteryLevel;
L2Skill.SkillType type = skill.getSkillType();
if ((type == L2Skill.SkillType.BUFF) || (type == L2Skill.SkillType.MUSIC) || (type == L2Skill.SkillType.HOT) || (type == L2Skill.SkillType.HEAL_PERCENT))
masteryLevel = 2;
else if (type == L2Skill.SkillType.HEAL)
masteryLevel = 3;
else
masteryLevel = 1;
if (masteryLevel > 0)
activeChar.setSkillMastery(Integer.valueOf(skill.getId()), masteryLevel);
}
}

public static double calcDamageResists(L2Skill skill, L2Character attacker, L2Character defender, double value)
{
if (skill != null) {
switch (1.$SwitchMap$l2p$gameserver$model$L2Skill$Element[skill.getElement().ordinal()])
{
case 1:
return applyDefense(attacker, defender, Stats.FIRE_RECEPTIVE, (int)attacker.calcStat(Stats.ATTACK_ELEMENT_FIRE, skill.getElementPower(), null, null), value, skill);
case 2:
return applyDefense(attacker, defender, Stats.WATER_RECEPTIVE, (int)attacker.calcStat(Stats.ATTACK_ELEMENT_WATER, skill.getElementPower(), null, null), value, skill);
case 3:
return applyDefense(attacker, defender, Stats.WIND_RECEPTIVE, (int)attacker.calcStat(Stats.ATTACK_ELEMENT_WIND, skill.getElementPower(), null, null), value, skill);
case 4:
return applyDefense(attacker, defender, Stats.EARTH_RECEPTIVE, (int)attacker.calcStat(Stats.ATTACK_ELEMENT_EARTH, skill.getElementPower(), null, null), value, skill);
case 5:
return applyDefense(attacker, defender, Stats.SACRED_RECEPTIVE, (int)attacker.calcStat(Stats.ATTACK_ELEMENT_SACRED, skill.getElementPower(), null, null), value, skill);
case 6:
return applyDefense(attacker, defender, Stats.UNHOLY_RECEPTIVE, (int)attacker.calcStat(Stats.ATTACK_ELEMENT_UNHOLY, skill.getElementPower(), null, null), value, skill);
}
return value;
}

int fire_attack = (int)attacker.calcStat(Stats.ATTACK_ELEMENT_FIRE, 0D, null, null);
int water_attack = (int)attacker.calcStat(Stats.ATTACK_ELEMENT_WATER, 0D, null, null);
int wind_attack = (int)attacker.calcStat(Stats.ATTACK_ELEMENT_WIND, 0D, null, null);
int earth_attack = (int)attacker.calcStat(Stats.ATTACK_ELEMENT_EARTH, 0D, null, null);
int sacred_attack = (int)attacker.calcStat(Stats.ATTACK_ELEMENT_SACRED, 0D, null, null);
int unholy_attack = (int)attacker.calcStat(Stats.ATTACK_ELEMENT_UNHOLY, 0D, null, null);

if ((fire_attack == 0) && (water_attack == 0) && (earth_attack == 0) && (wind_attack == 0) && (unholy_attack == 0) && (sacred_attack == 0))
return value;

TreeMap sort_attibutes = new TreeMap();
sort_attibutes.put(Integer.valueOf(fire_attack), Stats.FIRE_RECEPTIVE);
sort_attibutes.put(Integer.valueOf(water_attack), Stats.WATER_RECEPTIVE);
sort_attibutes.put(Integer.valueOf(wind_attack), Stats.WIND_RECEPTIVE);
sort_attibutes.put(Integer.valueOf(earth_attack), Stats.EARTH_RECEPTIVE);
sort_attibutes.put(Integer.valueOf(sacred_attack), Stats.SACRED_RECEPTIVE);
sort_attibutes.put(Integer.valueOf(unholy_attack), Stats.UNHOLY_RECEPTIVE);

int attack = ((Integer)sort_attibutes.lastEntry().getKey()).intValue();
Stats defence_type = (Stats)sort_attibutes.lastEntry().getValue();

return applyDefense(attacker, defender, defence_type, attack, value, null);
}

public static double applyDefense(L2Character attacker, L2Character defender, Stats defence_type, int attack, double value, L2Skill skill)
{
double defenseFull = -defender.calcStat(defence_type, 0D, null, null);

if ((skill == null) || (!(skill.isMagic())))
{
if (defenseFull > attack)
return (value + value * (attack - defenseFull) / 400.0D);
return value;
}

double defenseFirst60 = Math.min(60.0D, defenseFull);

value = value * (1D + (attack - defenseFirst60) / 400.0D);

if (!(defenseFull > defenseFirst60))
return value;

defenseFull = defenseFull - defenseFirst60;

if ((defenseFull < 0D) && (Rnd.chance(defenseFull / 3.0D)))
{
value = value / 2.0D;
attacker.sendPacket(new SystemMessage(2280).addName(defender).addName(attacker));
}

return value;
}

public static int[] calcAttackElement(L2Character attacker)
{
int fire_attack = (int)attacker.calcStat(Stats.ATTACK_ELEMENT_FIRE, 0D, null, null);
int water_attack = (int)attacker.calcStat(Stats.ATTACK_ELEMENT_WATER, 0D, null, null);
int wind_attack = (int)attacker.calcStat(Stats.ATTACK_ELEMENT_WIND, 0D, null, null);
int earth_attack = (int)attacker.calcStat(Stats.ATTACK_ELEMENT_EARTH, 0D, null, null);
int sacred_attack = (int)attacker.calcStat(Stats.ATTACK_ELEMENT_SACRED, 0D, null, null);
int unholy_attack = (int)attacker.calcStat(Stats.ATTACK_ELEMENT_UNHOLY, 0D, null, null);

if ((fire_attack == 0) && (water_attack == 0) && (earth_attack == 0) && (wind_attack == 0) && (unholy_attack == 0) && (sacred_attack == 0))
return null;

TreeMap sort_attibutes = new TreeMap();
sort_attibutes.put(Integer.valueOf(fire_attack), Stats.ATTACK_ELEMENT_FIRE);
sort_attibutes.put(Integer.valueOf(water_attack), Stats.ATTACK_ELEMENT_WATER);
sort_attibutes.put(Integer.valueOf(wind_attack), Stats.ATTACK_ELEMENT_WIND);
sort_attibutes.put(Integer.valueOf(earth_attack), Stats.ATTACK_ELEMENT_EARTH);
sort_attibutes.put(Integer.valueOf(sacred_attack), Stats.ATTACK_ELEMENT_SACRED);
sort_attibutes.put(Integer.valueOf(unholy_attack), Stats.ATTACK_ELEMENT_UNHOLY);

int element = 0;
switch (1.$SwitchMap$l2p$gameserver$skills$Stats[((Stats)sort_attibutes.lastEntry().getValue()).ordinal()])
{
case 1:
element = 0;
break;
case 2:
element = 1;
break;
case 3:
element = 2;
break;
case 4:
element = 3;
break;
case 5:
element = 4;
break;
case 6:
element = 5;
}

return { element, ((Integer)sort_attibutes.lastEntry().getKey()).intValue() };
}

static
{
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setValidating(false);
factory.setIgnoringComments(true);
File file = new File(Config.AttributeBonusFile);
Document doc = null;
try
{
doc = factory.newDocumentBuilder().parse(file);
}
catch (SAXException e)
{
e.printStackTrace();
}
catch (IOException e)
{
e.printStackTrace();
}
catch (ParserConfigurationException e)
{
e.printStackTrace();
}

if (doc != null)
for (Node z = doc.getFirstChild(); z != null; z = z.getNextSibling()) {
Node n = z.getFirstChild();
while (true) { int i;
double val;
Node d;
String node;
if (n == null)
break;
if (n.getNodeName().equalsIgnoreCase("str_bonus"))
for (d = n.getFirstChild(); d != null; d = d.getNextSibling())
{
node = d.getNodeName();
if (node.equalsIgnoreCase("set"))
{
i = Integer.valueOf(d.getAttributes().getNamedItem("attribute").getNodeValue()).intValue();
val = Integer.valueOf(d.getAttributes().getNamedItem("val").getNodeValue()).intValue();
STRbonus[i] = ((100.0D + val) / 100.0D);
}
}
if (n.getNodeName().equalsIgnoreCase("int_bonus"))
for (d = n.getFirstChild(); d != null; d = d.getNextSibling())
{
node = d.getNodeName();
if (node.equalsIgnoreCase("set"))
{
i = Integer.valueOf(d.getAttributes().getNamedItem("attribute").getNodeValue()).intValue();
val = Integer.valueOf(d.getAttributes().getNamedItem("val").getNodeValue()).intValue();
INTbonus[i] = ((100.0D + val) / 100.0D);
}
}
if (n.getNodeName().equalsIgnoreCase("con_bonus"))
for (d = n.getFirstChild(); d != null; d = d.getNextSibling())
{
node = d.getNodeName();
if (node.equalsIgnoreCase("set"))
{
i = Integer.valueOf(d.getAttributes().getNamedItem("attribute").getNodeValue()).intValue();
val = Integer.valueOf(d.getAttributes().getNamedItem("val").getNodeValue()).intValue();
CONbonus[i] = ((100.0D + val) / 100.0D);
}
}
if (n.getNodeName().equalsIgnoreCase("men_bonus"))
for (d = n.getFirstChild(); d != null; d = d.getNextSibling())
{
node = d.getNodeName();
if (node.equalsIgnoreCase("set"))
{
i = Integer.valueOf(d.getAttributes().getNamedItem("attribute").getNodeValue()).intValue();
val = Integer.valueOf(d.getAttributes().getNamedItem("val").getNodeValue()).intValue();
MENbonus[i] = ((100.0D + val) / 100.0D);
}
}
if (n.getNodeName().equalsIgnoreCase("dex_bonus"))
for (d = n.getFirstChild(); d != null; d = d.getNextSibling())
{
node = d.getNodeName();
if (node.equalsIgnoreCase("set"))
{
i = Integer.valueOf(d.getAttributes().getNamedItem("attribute").getNodeValue()).intValue();
val = Integer.valueOf(d.getAttributes().getNamedItem("val").getNodeValue()).intValue();
DEXbonus[i] = ((100.0D + val) / 100.0D);
}
}
if (n.getNodeName().equalsIgnoreCase("wit_bonus"))
for (d = n.getFirstChild(); d != null; d = d.getNextSibling())
{
node = d.getNodeName();
if (node.equalsIgnoreCase("set"))
{
i = Integer.valueOf(d.getAttributes().getNamedItem("attribute").getNodeValue()).intValue();
val = Integer.valueOf(d.getAttributes().getNamedItem("val").getNodeValue()).intValue();
WITbonus[i] = ((100.0D + val) / 100.0D);
}
}
n = n.getNextSibling();
}
}
}

public static class AttackInfo
{
public double damage;
public double defence;
public double crit_rcpt;
public double crit_static;
public double death_rcpt;
public double lethal1;
public double lethal2;
public boolean crit;
public boolean shld;
public boolean lethal;
}

private static class FuncSDefPlayers extends Func
{
static final FuncSDefPlayers func = new FuncSDefPlayers();

private FuncSDefPlayers()
{
super(Stats.SHIELD_RATE, 32, null);
}

public void calc(Env env)
{
if (!(env.value < 0D))
return;

L2Character cha = env.character;
L2ItemInstance shld = ((L2Player)cha).getInventory().getPaperdollItem(7);
if ((shld == null) || (shld.getItemType() != L2Weapon.WeaponType.NONE))
return;
env.value = (env.value * Formulas.DEXbonus[cha.getDEX()]);
}
}

private static class FuncSDefAll extends Func
{
static final FuncSDefAll func = new FuncSDefAll();

private FuncSDefAll()
{
super(Stats.SHIELD_RATE, 32, null);
}

public void calc(Env env)
{
if (!(env.value < 0D))
return;

L2Character target = env.target;
if (target != null)
{
L2Weapon weapon = target.getActiveWeaponItem();
if (weapon != null)
switch (Formulas.1.$SwitchMap$l2p$gameserver$templates$L2Weapon$WeaponType[weapon.getItemType().ordinal()])
{
case 1:
case 2:
env.value = (env.value + 30.0D);
break;
case 5:
env.value = (env.value + 12.0D);
case 3:
case 4:
}
}
}
}

private static class FuncTradeLimit extends Func
{
static final FuncTradeLimit func = new FuncTradeLimit();

private FuncTradeLimit()
{
super(Stats.TRADE_LIMIT, 1, null);
}

public void calc(Env env)
{
L2Player _cha = (L2Player)env.character;
if (_cha.getRace() == Race.dwarf)
env.value = Config.MAX_PVTSTORE_SLOTS_DWARF;
else
env.value = Config.MAX_PVTSTORE_SLOTS_OTHER;
}
}

private static class FuncWarehouse extends Func
{
static final FuncWarehouse func = new FuncWarehouse();

private FuncWarehouse()
{
super(Stats.STORAGE_LIMIT, 1, null);
}

public void calc(Env env)
{
L2Player player = (L2Player)env.character;
if (player.getTemplate().race == Race.dwarf)
env.value = Config.WAREHOUSE_SLOTS_DWARF;
else
env.value = Config.WAREHOUSE_SLOTS_NO_DWARF;
env.value = (env.value + player.getExpandWarehouse());
}
}

private static class FuncInventory extends Func
{
static final FuncInventory func = new FuncInventory();

private FuncInventory()
{
super(Stats.INVENTORY_LIMIT, 1, null);
}

public void calc(Env env)
{
L2Player player = (L2Player)env.character;
if (player.isGM())
env.value = Config.INVENTORY_MAXIMUM_GM;
else if (player.getTemplate().race == Race.dwarf)
env.value = Config.INVENTORY_MAXIMUM_DWARF;
else
env.value = Config.INVENTORY_MAXIMUM_NO_DWARF;
env.value = (env.value + player.getExpandInventory());
}
}

private static class FuncMDamageResists extends Func
{
static final FuncMDamageResists func = new FuncMDamageResists();

private FuncMDamageResists()
{
super(Stats.MAGIC_DAMAGE, 48, null);
}

public void calc(Env env)
{
if ((env.target.isRaid()) && (Math.abs(env.character.getLevel() - env.target.getLevel()) > Config.RAID_MAX_LEVEL_DIFF))
{
env.value = 1D;
return;
}
env.value = Formulas.calcDamageResists(env.skill, env.character, env.target, env.value);
}
}

private static class FuncPDamageResists extends Func
{
static final FuncPDamageResists func = new FuncPDamageResists();

private FuncPDamageResists()
{
super(Stats.PHYSICAL_DAMAGE, 48, null);
}

public void calc(Env env)
{
if ((env.target.isRaid()) && (env.character.getLevel() - env.target.getLevel() > Config.RAID_MAX_LEVEL_DIFF))
{
env.value = 1D;
return;
}

L2Weapon weapon = env.character.getActiveWeaponItem();
if (weapon != null)
switch (Formulas.1.$SwitchMap$l2p$gameserver$templates$L2Weapon$WeaponType[weapon.getItemType().ordinal()])
{
case 1:
env.value = (env.value * 0.01D * env.target.calcStat(Stats.BOW_WPN_RECEPTIVE, 100.0D, null, null));
break;
case 2:
env.value = (env.value * 0.01D * env.target.calcStat(Stats.CROSSBOW_WPN_RECEPTIVE, 100.0D, null, null));
break;
case 3:
env.value = (env.value * 0.01D * env.target.calcStat(Stats.BLUNT_WPN_RECEPTIVE, 100.0D, null, null));
break;
case 4:
case 5:
env.value = (env.value * 0.01D * env.target.calcStat(Stats.DAGGER_WPN_RECEPTIVE, 100.0D, null, null));
break;
case 6:
env.value = (env.value * 0.01D * env.target.calcStat(Stats.DUAL_WPN_RECEPTIVE, 100.0D, null, null));
break;
case 7:
case 8:
case 9:
env.value = (env.value * 0.01D * env.target.calcStat(Stats.SWORD_WPN_RECEPTIVE, 100.0D, null, null));
break;
case 10:
env.value = (env.value * 0.01D * env.target.calcStat(Stats.POLE_WPN_RECEPTIVE, 100.0D, null, null));
break;
case 11:
env.value = (env.value * 0.01D * env.target.calcStat(Stats.FIST_WPN_RECEPTIVE, 100.0D, null, null));
}


env.value = Formulas.calcDamageResists(env.skill, env.character, env.target, env.value);
}
}

private static class FuncFatalBlowMul extends Func
{
static final FuncFatalBlowMul func = new FuncFatalBlowMul();

private FuncFatalBlowMul()
{
super(Stats.FATALBLOW_RATE, 32, null);
}

public void calc(Env env)
{
if (env.target == null)
return;

if (!(env.target.isInCombat()))
env.value = (env.value * 1.1000000000000001D);

if ((env.skill != null) && (env.skill.isBehind()))
{
int head = env.character.getHeadingTo(env.target, true);
if ((head <= 10430) || (head >= 55105))
env.value = 90.0D;
else if ((head <= 21000) || (head >= 44500))
env.value = 60.0D;
else
env.value = 10.0D;
}

if (env.target.isPlayer())
{
L2Player pcTarget = (L2Player)env.target;
if (pcTarget.isWearingArmor(L2Armor.ArmorType.HEAVY))
env.value = (env.value * 0.59999999999999998D);
else if (pcTarget.isWearingArmor(L2Armor.ArmorType.MAGIC))
env.value = (env.value * 1.1899999999999999D);
}
}
}

private static class FuncMaxMpMul extends Func
{
static final FuncMaxMpMul func = new FuncMaxMpMul();

private FuncMaxMpMul()
{
super(Stats.MAX_MP, 32, null);
}

public void calc(Env env)
{
env.value = (env.value * Formulas.MENbonus[env.character.getMEN()]);
}
}

private static class FuncMaxMpAdd extends Func
{
static final FuncMaxMpAdd func = new FuncMaxMpAdd();

private FuncMaxMpAdd()
{
super(Stats.MAX_MP, 16, null);
}

public void calc(Env env)
{
L2PlayerTemplate t = (L2PlayerTemplate)env.character.getTemplate();
int lvl = Math.max(0, env.character.getLevel() - t.classBaseLevel);
double mpmod = t.lvlMpMod * lvl;
double mpmax = (t.lvlMpAdd + mpmod) * lvl;
double mpmin = t.lvlMpAdd * lvl + mpmod;
env.value = (env.value + (mpmax + mpmin) / 2.0D);
}
}

private static class FuncMaxCpMul extends Func
{
static final FuncMaxCpMul func = new FuncMaxCpMul();

private FuncMaxCpMul()
{
super(Stats.MAX_CP, 32, null);
}

public void calc(Env env)
{
double cpSSmod = 1D;
int sealOwnedBy = SevenSigns.getInstance().getSealOwner(3);
int playerCabal = SevenSigns.getInstance().getPlayerCabal((L2Player)env.character);

if (sealOwnedBy != 0)
if (playerCabal == sealOwnedBy)
cpSSmod = 1.1000000000000001D;
else
cpSSmod = 0.90000000000000002D;

env.value = (env.value * Formulas.CONbonus[env.character.getCON()] * cpSSmod);
}
}

private static class FuncMaxCpAdd extends Func
{
static final FuncMaxCpAdd func = new FuncMaxCpAdd();

private FuncMaxCpAdd()
{
super(Stats.MAX_CP, 16, null);
}

public void calc(Env env)
{
L2PlayerTemplate t = (L2PlayerTemplate)env.character.getTemplate();
int lvl = Math.max(0, env.character.getLevel() - t.classBaseLevel);
double cpmod = t.lvlCpMod * lvl;
double cpmax = (t.lvlCpAdd + cpmod) * lvl;
double cpmin = t.lvlCpAdd * lvl + cpmod;
env.value = (env.value + (cpmax + cpmin) / 2.0D);
}
}

private static class FuncMaxHpMul extends Func
{
static final FuncMaxHpMul func = new FuncMaxHpMul();

private FuncMaxHpMul()
{
super(Stats.MAX_HP, 32, null);
}

public void calc(Env env)
{
env.value = (env.value * Formulas.CONbonus[env.character.getCON()]);
}
}

private static class FuncMaxHpAdd extends Func
{
static final FuncMaxHpAdd func = new FuncMaxHpAdd();

private FuncMaxHpAdd()
{
super(Stats.MAX_HP, 16, null);
}

public void calc(Env env)
{
L2PlayerTemplate t = (L2PlayerTemplate)env.character.getTemplate();
int lvl = Math.max(0, env.character.getLevel() - t.classBaseLevel);
double hpmod = t.lvlHpMod * lvl;
double hpmax = (t.lvlHpAdd + hpmod) * lvl;
double hpmin = t.lvlHpAdd * lvl + hpmod;
env.value = (env.value + (hpmax + hpmin) / 2.0D);
}
}

private static class FuncHennaWIT extends Func
{
static final FuncHennaWIT func = new FuncHennaWIT();

private FuncHennaWIT()
{
super(Stats.STAT_WIT, 16, null);
}

public void calc(Env env)
{
L2Player pc = (L2Player)env.character;
if (pc != null)
env.value = Math.max(1D, env.value + pc.getHennaStatWIT());
}
}

private static class FuncHennaCON extends Func
{
static final FuncHennaCON func = new FuncHennaCON();

private FuncHennaCON()
{
super(Stats.STAT_CON, 16, null);
}

public void calc(Env env)
{
L2Player pc = (L2Player)env.character;
if (pc != null)
env.value = Math.max(1D, env.value + pc.getHennaStatCON());
}
}

private static class FuncHennaMEN extends Func
{
static final FuncHennaMEN func = new FuncHennaMEN();

private FuncHennaMEN()
{
super(Stats.STAT_MEN, 16, null);
}

public void calc(Env env)
{
L2Player pc = (L2Player)env.character;
if (pc != null)
env.value = Math.max(1D, env.value + pc.getHennaStatMEN());
}
}

private static class FuncHennaINT extends Func
{
static final FuncHennaINT func = new FuncHennaINT();

private FuncHennaINT()
{
super(Stats.STAT_INT, 16, null);
}

public void calc(Env env)
{
L2Player pc = (L2Player)env.character;
if (pc != null)
env.value = Math.max(1D, env.value + pc.getHennaStatINT());
}
}

private static class FuncHennaDEX extends Func
{
static final FuncHennaDEX func = new FuncHennaDEX();

private FuncHennaDEX()
{
super(Stats.STAT_DEX, 16, null);
}

public void calc(Env env)
{
L2Player pc = (L2Player)env.character;
if (pc != null)
env.value = Math.max(1D, env.value + pc.getHennaStatDEX());
}
}

private static class FuncHennaSTR extends Func
{
static final FuncHennaSTR func = new FuncHennaSTR();

private FuncHennaSTR()
{
super(Stats.STAT_STR, 16, null);
}

public void calc(Env env)
{
L2Player pc = (L2Player)env.character;
if (pc != null)
env.value = Math.max(1D, env.value + pc.getHennaStatSTR());
}
}

private static class FuncMAtkSpeedMul extends Func
{
static final FuncMAtkSpeedMul func = new FuncMAtkSpeedMul();

private FuncMAtkSpeedMul()
{
super(Stats.MAGIC_ATTACK_SPEED, 32, null);
}

public void calc(Env env)
{
env.value = (env.value * Formulas.WITbonus[env.character.getWIT()]);
}
}

private static class FuncPAtkSpeedMul extends Func
{
static final FuncPAtkSpeedMul func = new FuncPAtkSpeedMul();

private FuncPAtkSpeedMul()
{
super(Stats.POWER_ATTACK_SPEED, 32, null);
}

public void calc(Env env)
{
env.value = (env.value * Formulas.DEXbonus[env.character.getDEX()]);
}
}

private static class FuncMoveSpeedMul extends Func
{
static final FuncMoveSpeedMul func = new FuncMoveSpeedMul();

private FuncMoveSpeedMul()
{
super(Stats.RUN_SPEED, 32, null);
}

public void calc(Env env)
{
env.value = (env.value * Formulas.DEXbonus[env.character.getDEX()]);
}
}

private static class FuncPCriticalDmgRcpt extends Func
{
static final FuncPCriticalDmgRcpt func = new FuncPCriticalDmgRcpt();

private FuncPCriticalDmgRcpt()
{
super(Stats.CRIT_DAMAGE_RECEPTIVE, 32, null);
}

public void calc(Env env)
{
L2ItemInstance i = ((L2Player)env.character).getInventory().getPaperdollItem(6);
if ((i != null) && (i.getItemType() == L2Armor.ArmorType.HEAVY))
env.value = (env.value - 20.0D);
}
}

private static class FuncPCriticalRateMul extends Func
{
static final FuncPCriticalRateMul func = new FuncPCriticalRateMul();

private FuncPCriticalRateMul()
{
super(Stats.CRITICAL_BASE, 16, null);
}

public void calc(Env env)
{
if (!(env.character instanceof L2Summon))
env.value = (env.value * Formulas.DEXbonus[env.character.getDEX()]);
env.value = (env.value * 0.01D * env.character.calcStat(Stats.CRITICAL_RATE, env.target, env.skill));
}
}

private static class FuncMCriticalRateMul extends Func
{
static final FuncMCriticalRateMul func = new FuncMCriticalRateMul();

private FuncMCriticalRateMul()
{
super(Stats.MCRITICAL_RATE, 16, null);
}

public void calc(Env env)
{
env.value = (env.value * Formulas.WITbonus[env.character.getWIT()]);
}
}

private static class FuncEvasionAdd extends Func
{
static final FuncEvasionAdd func = new FuncEvasionAdd();

private FuncEvasionAdd()
{
super(Stats.EVASION_RATE, 16, null);
}

public void calc(Env env)
{
env.value = (env.value + Math.sqrt(env.character.getDEX()) * 6.0D + env.character.getLevel());
}
}

private static class FuncAccuracyAdd extends Func
{
static final FuncAccuracyAdd func = new FuncAccuracyAdd();

private FuncAccuracyAdd()
{
super(Stats.ACCURACY_COMBAT, 16, null);
}

public void calc(Env env)
{
env.value = (env.value + Math.sqrt(env.character.getDEX()) * 6.0D + env.character.getLevel());
if (env.character.isSummon())
env.value = (env.value + 5.0D);
}
}

private static class FuncAttackRange extends Func
{
static final FuncAttackRange func = new FuncAttackRange();

private FuncAttackRange()
{
super(Stats.POWER_ATTACK_RANGE, 32, null);
}

public void calc(Env env)
{
L2Weapon weapon = env.character.getActiveWeaponItem();
if (weapon != null)
env.value = (env.value + weapon.getAttackRange());
}
}

private static class FuncMDefMul extends Func
{
static final FuncMDefMul func = new FuncMDefMul();

private FuncMDefMul()
{
super(Stats.MAGIC_DEFENCE, 32, null);
}

public void calc(Env env)
{
env.value = (env.value * Formulas.MENbonus[env.character.getMEN()] * env.character.getLevelMod());
}
}

private static class FuncPDefMul extends Func
{
static final FuncPDefMul func = new FuncPDefMul();

private FuncPDefMul()
{
super(Stats.POWER_DEFENCE, 32, null);
}

public void calc(Env env)
{
env.value = (env.value * env.character.getLevelMod());
}
}

private static class FuncMAtkMul extends Func
{
static final FuncMAtkMul func = new FuncMAtkMul();

private FuncMAtkMul()
{
super(Stats.MAGIC_ATTACK, 32, null);
}

public void calc(Env env)
{
double ib = Formulas.INTbonus[env.character.getINT()];
double lvlb = env.character.getLevelMod();
env.value = (env.value * lvlb * lvlb * ib * ib);
}
}

private static class FuncPAtkMul extends Func
{
static final FuncPAtkMul func = new FuncPAtkMul();

private FuncPAtkMul()
{
super(Stats.POWER_ATTACK, 32, null);
}

public void calc(Env env)
{
env.value = (env.value * Formulas.STRbonus[env.character.getSTR()] * env.character.getLevelMod());
}
}

private static class FuncMultRegenRunning extends Func
{
static final FuncMultRegenRunning[] func = new FuncMultRegenRunning[Stats.NUM_STATS];

static Func getFunc(Stats stat)
{
int pos = stat.ordinal();
if (func[pos] == null)
func[pos] = new FuncMultRegenRunning(stat);
return func[pos];
}

private FuncMultRegenRunning(Stats stat)
{
super(stat, 48, null);
setCondition(new ConditionPlayerState(ConditionPlayerState.CheckPlayerState.RUNNING, true));
}

public void calc(Env env)
{
if (!(this._cond.test(env)))
return;
env.value = (env.value * 0.69999999999999996D);
}
}

private static class FuncMultRegenStanding extends Func
{
static final FuncMultRegenStanding[] func = new FuncMultRegenStanding[Stats.NUM_STATS];

static Func getFunc(Stats stat)
{
int pos = stat.ordinal();
if (func[pos] == null)
func[pos] = new FuncMultRegenStanding(stat);
return func[pos];
}

private FuncMultRegenStanding(Stats stat)
{
super(stat, 48, null);
setCondition(new ConditionPlayerState(ConditionPlayerState.CheckPlayerState.STANDING, true));
}

public void calc(Env env)
{
if (!(this._cond.test(env)))
return;

env.value = (env.value * 1.1000000000000001D);
}
}

private static class FuncMultRegenResting extends Func
{
static final FuncMultRegenResting[] func = new FuncMultRegenResting[Stats.NUM_STATS];

static Func getFunc(Stats stat)
{
int pos = stat.ordinal();
if (func[pos] == null)
func[pos] = new FuncMultRegenResting(stat);
return func[pos];
}

private FuncMultRegenResting(Stats stat)
{
super(stat, 48, null);
setCondition(new ConditionPlayerState(ConditionPlayerState.CheckPlayerState.RESTING, true));
}

public void calc(Env env)
{
if (!(this._cond.test(env)))
return;

if ((env.character.isPlayer()) && (env.character.getLevel() <= 40) && (((L2Player)env.character).getClassId().getLevel() < 3) && (this._stat == Stats.REGENERATE_HP_RATE))
env.value = (env.value * 6.0D);
else
env.value = (env.value * 1.5D);
}
}
}

MaPuIIIKa: тваю ж...через спойлер все это дело...
по теме:

проесни непонел

хочеш еще интересней чегонебудь?

Crystal: проесни непонел

хочеш еще интересней чегонебудь?

P.S мой бог живет тут http://nmap.org/

Crystal: http://www.linezeus.gr/formulas.php к примеру

http://z13.invisionfree.com/Zeus/index.php?showtopic=45590 к стате не плохой девелопер у тут