lineage2/l2j_mobius
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Sync with L2jServer HighFive Apr 21st 2015.

Browse Source
This commit is contained in:
MobiusDev
2015-04-22 09:59:28 +00:00
parent c896c6cd51
commit 1a6970e30d
37 changed files with 1518 additions and 1298 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
trunk/java/com/l2jserver/gameserver/model/actor/L2Character.java
View File

@ -139,6 +139,7 @@ import com.l2jserver.gameserver.network.serverpackets.ChangeWaitType;
import com.l2jserver.gameserver.network.serverpackets.CharInfo;
import com.l2jserver.gameserver.network.serverpackets.ExRotation;
import com.l2jserver.gameserver.network.serverpackets.ExTeleportToLocationActivate;
import com.l2jserver.gameserver.network.serverpackets.FlyToLocation.FlyType;
import com.l2jserver.gameserver.network.serverpackets.L2GameServerPacket;
import com.l2jserver.gameserver.network.serverpackets.MagicSkillCanceld;
import com.l2jserver.gameserver.network.serverpackets.MagicSkillLaunched;
@ -2062,7 +2063,7 @@ public abstract class L2Character extends L2Object implements ISkillsHolder, IDe
*/
public boolean checkDoCastConditions(Skill skill)
{
if ((skill == null) || isSkillDisabled(skill) || (((skill.getFlyRadius() > 0) || (skill.getFlyType() != null)) && isMovementDisabled()))
if ((skill == null) || isSkillDisabled(skill) || ((skill.getFlyType() == FlyType.CHARGE) && isMovementDisabled()))
{
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);

23
trunk/java/com/l2jserver/gameserver/model/actor/instance/L2PcInstance.java
View File

@ -9083,29 +9083,6 @@ public final class L2PcInstance extends L2Playable
}
}
if (skill.hasEffectType(L2EffectType.TELEPORT_TO_TARGET))
{
// You cannot jump while rooted right ;)
if (isMovementDisabled())
{
// Sends message that skill cannot be used...
SystemMessage sm = SystemMessage.getSystemMessage(SystemMessageId.S1_CANNOT_BE_USED_DUE_TO_UNSUITABLE_TERMS);
sm.addSkillName(skill.getId());
sendPacket(sm);
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return false;
}
// And this skill cannot be used in peace zone, not even on NPCs!
if (isInsideZone(ZoneId.PEACE))
{
// Sends a sys msg to client
sendPacket(SystemMessageId.YOU_MAY_NOT_ATTACK_THIS_TARGET_IN_A_PEACEFUL_ZONE);
// Send a Server->Client packet ActionFailed to the L2PcInstance
sendPacket(ActionFailed.STATIC_PACKET);
return false;
}
}
// Check if the skill is a good magic, target is a monster and if force attack is set, if not then we don't want to cast.
if ((skill.getEffectPoint() > 0) && target.isMonster() && !forceUse)
{

58
trunk/java/com/l2jserver/gameserver/model/drops/CorpseDropItem.java
View File

@ -1,58 +0,0 @@
/*
* Copyright (C) 2004-2015 L2J Server
*
* This file is part of L2J Server.
*
* L2J Server 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 3 of the License, or
* (at your option) any later version.
*
* L2J Server 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, see <http://www.gnu.org/licenses/>.
*/
package com.l2jserver.gameserver.model.drops;
import com.l2jserver.Config;
/**
* @author NosBit
*/
public class CorpseDropItem extends GeneralDropItem
{
/**
* @param itemId the item id
* @param min the min count
* @param max the max count
* @param chance the chance of this drop item
*/
public CorpseDropItem(int itemId, long min, long max, double chance)
{
super(itemId, min, max, chance);
}
/*
* (non-Javadoc)
* @see com.l2jserver.gameserver.model.drops.GeneralDropItem#getGlobalAmountMultiplier()
*/
@Override
protected double getGlobalAmountMultiplier(boolean isPremium)
{
return isPremium ? Config.PREMIUM_RATE_SPOIL_AMOUNT * Config.RATE_CORPSE_DROP_AMOUNT_MULTIPLIER : Config.RATE_CORPSE_DROP_AMOUNT_MULTIPLIER;
}
/*
* (non-Javadoc)
* @see com.l2jserver.gameserver.model.drops.GeneralDropItem#getGlobalChanceMultiplier()
*/
@Override
protected double getGlobalChanceMultiplier(boolean isPremium)
{
return isPremium ? Config.PREMIUM_RATE_SPOIL_CHANCE * Config.RATE_CORPSE_DROP_CHANCE_MULTIPLIER : Config.RATE_CORPSE_DROP_CHANCE_MULTIPLIER;
}
}

58
trunk/java/com/l2jserver/gameserver/model/drops/DeathDropItem.java
View File

@ -1,58 +0,0 @@
/*
* Copyright (C) 2004-2015 L2J Server
*
* This file is part of L2J Server.
*
* L2J Server 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 3 of the License, or
* (at your option) any later version.
*
* L2J Server 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, see <http://www.gnu.org/licenses/>.
*/
package com.l2jserver.gameserver.model.drops;
import com.l2jserver.Config;
/**
* @author NosBit
*/
public class DeathDropItem extends GeneralDropItem
{
/**
* @param itemId the item id
* @param min the min count
* @param max the max count
* @param chance the chance of this drop item
*/
public DeathDropItem(int itemId, long min, long max, double chance)
{
super(itemId, min, max, chance);
}
/*
* (non-Javadoc)
* @see com.l2jserver.gameserver.model.drops.GeneralDropItem#getGlobalAmountMultiplier()
*/
@Override
protected double getGlobalAmountMultiplier(boolean isPremium)
{
return isPremium ? Config.PREMIUM_RATE_DROP_AMOUNT * Config.RATE_DEATH_DROP_AMOUNT_MULTIPLIER : Config.RATE_DEATH_DROP_AMOUNT_MULTIPLIER;
}
/*
* (non-Javadoc)
* @see com.l2jserver.gameserver.model.drops.GeneralDropItem#getGlobalChanceMultiplier()
*/
@Override
protected double getGlobalChanceMultiplier(boolean isPremium)
{
return isPremium ? Config.PREMIUM_RATE_DROP_CHANCE * Config.RATE_DEATH_DROP_CHANCE_MULTIPLIER : Config.RATE_DEATH_DROP_CHANCE_MULTIPLIER;
}
}

77
trunk/java/com/l2jserver/gameserver/model/drops/DropListScope.java
View File

@ -18,75 +18,46 @@
*/
package com.l2jserver.gameserver.model.drops;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.logging.Level;
import java.util.logging.Logger;
import com.l2jserver.gameserver.model.drops.strategy.IAmountMultiplierStrategy;
import com.l2jserver.gameserver.model.drops.strategy.IChanceMultiplierStrategy;
import com.l2jserver.gameserver.model.drops.strategy.IGroupedItemDropCalculationStrategy;
import com.l2jserver.gameserver.model.drops.strategy.IKillerChanceModifierStrategy;
import com.l2jserver.gameserver.model.drops.strategy.IPreciseDeterminationStrategy;
/**
* @author NosBit
*/
public enum DropListScope
public enum DropListScope implements IDropItemFactory, IGroupedDropItemFactory
{
DEATH(DeathDropItem.class, GroupedDeathDropItem.class),
CORPSE(CorpseDropItem.class, GroupedCorpseDropItem.class);
DEATH((itemId, min, max, chance) -> new GeneralDropItem(itemId, min, max, chance, IAmountMultiplierStrategy.DROP, IChanceMultiplierStrategy.DROP), chance -> new GroupedGeneralDropItem(chance)),
CORPSE((itemId, min, max, chance) -> new GeneralDropItem(itemId, min, max, chance, IAmountMultiplierStrategy.SPOIL, IChanceMultiplierStrategy.SPOIL), DEATH),
private static final Logger _log = Logger.getLogger(DropListScope.class.getName());
/**
* This droplist scope isn't affected by ANY rates, nor Champion, etc...
*/
STATIC(
(itemId, min, max, chance) -> new GeneralDropItem(itemId, min, max, chance, IAmountMultiplierStrategy.STATIC, IChanceMultiplierStrategy.STATIC, IPreciseDeterminationStrategy.ALWAYS, IKillerChanceModifierStrategy.NO_RULES),
chance -> new GroupedGeneralDropItem(chance, IGroupedItemDropCalculationStrategy.DEFAULT_STRATEGY, IKillerChanceModifierStrategy.NO_RULES, IPreciseDeterminationStrategy.ALWAYS)),
QUEST((itemId, min, max, chance) -> new GeneralDropItem(itemId, min, max, chance, IAmountMultiplierStrategy.STATIC, IChanceMultiplierStrategy.QUEST, IPreciseDeterminationStrategy.ALWAYS, IKillerChanceModifierStrategy.NO_RULES), STATIC);
private final Class<? extends GeneralDropItem> _dropItemClass;
private final Class<? extends GroupedGeneralDropItem> _groupedDropItemClass;
private final IDropItemFactory _factory;
private final IGroupedDropItemFactory _groupFactory;
private DropListScope(Class<? extends GeneralDropItem> dropItemClass, Class<? extends GroupedGeneralDropItem> groupedDropItemClass)
private DropListScope(IDropItemFactory factory, IGroupedDropItemFactory groupFactory)
{
_dropItemClass = dropItemClass;
_groupedDropItemClass = groupedDropItemClass;
_factory = factory;
_groupFactory = groupFactory;
}
@Override
public IDropItem newDropItem(int itemId, long min, long max, double chance)
{
final Constructor<? extends GeneralDropItem> constructor;
try
{
constructor = _dropItemClass.getConstructor(int.class, long.class, long.class, double.class);
}
catch (NoSuchMethodException | SecurityException e)
{
_log.log(Level.SEVERE, "Constructor(int, long, long, double) not found for " + _dropItemClass.getSimpleName(), e);
return null;
}
try
{
return constructor.newInstance(itemId, min, max, chance);
}
catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e)
{
_log.log(Level.SEVERE, "", e);
return null;
}
return _factory.newDropItem(itemId, min, max, chance);
}
@Override
public GroupedGeneralDropItem newGroupedDropItem(double chance)
{
final Constructor<? extends GroupedGeneralDropItem> constructor;
try
{
constructor = _groupedDropItemClass.getConstructor(double.class);
}
catch (NoSuchMethodException | SecurityException e)
{
_log.log(Level.SEVERE, "Constructor(double) not found for " + _groupedDropItemClass.getSimpleName(), e);
return null;
}
try
{
return constructor.newInstance(chance);
}
catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e)
{
_log.log(Level.SEVERE, "", e);
return null;
}
return _groupFactory.newGroupedDropItem(chance);
}
}

317
trunk/java/com/l2jserver/gameserver/model/drops/GeneralDropItem.java
View File

@ -1,45 +1,50 @@
/*
* Copyright (C) 2004-2015 L2J Server
*
*
* This file is part of L2J Server.
*
*
* L2J Server 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 3 of the License, or
* (at your option) any later version.
*
*
* L2J Server 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, see <http://www.gnu.org/licenses/>.
*/
package com.l2jserver.gameserver.model.drops;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import com.l2jserver.Config;
import com.l2jserver.gameserver.datatables.ItemTable;
import com.l2jserver.gameserver.model.actor.L2Character;
import com.l2jserver.gameserver.model.drops.strategy.IAmountMultiplierStrategy;
import com.l2jserver.gameserver.model.drops.strategy.IChanceMultiplierStrategy;
import com.l2jserver.gameserver.model.drops.strategy.IDropCalculationStrategy;
import com.l2jserver.gameserver.model.drops.strategy.IKillerChanceModifierStrategy;
import com.l2jserver.gameserver.model.drops.strategy.INonGroupedKillerChanceModifierStrategy;
import com.l2jserver.gameserver.model.drops.strategy.IPreciseDeterminationStrategy;
import com.l2jserver.gameserver.model.holders.ItemHolder;
import com.l2jserver.gameserver.model.itemcontainer.Inventory;
import com.l2jserver.gameserver.model.items.L2Item;
import com.l2jserver.gameserver.util.Util;
import com.l2jserver.util.Rnd;
/**
* @author NosBit
*/
public class GeneralDropItem implements IDropItem
public final class GeneralDropItem implements IDropItem
{
private final int _itemId;
private final long _min;
private final long _max;
private final double _chance;
protected final IAmountMultiplierStrategy _amountStrategy;
protected final IChanceMultiplierStrategy _chanceStrategy;
protected final IPreciseDeterminationStrategy _preciseStrategy;
protected final INonGroupedKillerChanceModifierStrategy _killerStrategy;
protected final IDropCalculationStrategy _dropCalculationStrategy;
/**
* @param itemId the item id
* @param min the min count
@ -47,233 +52,193 @@ public class GeneralDropItem implements IDropItem
* @param chance the chance of this drop item
*/
public GeneralDropItem(int itemId, long min, long max, double chance)
{
this(itemId, min, max, chance, 1, 1);
}
public GeneralDropItem(int itemId, long min, long max, double chance, double defaultAmountMultiplier, double defaultChanceMultiplier)
{
this(itemId, min, max, defaultChanceMultiplier, IAmountMultiplierStrategy.DEFAULT_STRATEGY(defaultAmountMultiplier), IChanceMultiplierStrategy.DEFAULT_STRATEGY(defaultChanceMultiplier));
}
public GeneralDropItem(int itemId, long min, long max, double chance, IAmountMultiplierStrategy amountMultiplierStrategy, IChanceMultiplierStrategy chanceMultiplierStrategy)
{
this(itemId, min, max, chance, amountMultiplierStrategy, chanceMultiplierStrategy, IPreciseDeterminationStrategy.DEFAULT, IKillerChanceModifierStrategy.DEFAULT_NONGROUP_STRATEGY);
}
public GeneralDropItem(int itemId, long min, long max, double chance, IAmountMultiplierStrategy amountMultiplierStrategy, IChanceMultiplierStrategy chanceMultiplierStrategy, IPreciseDeterminationStrategy preciseStrategy, INonGroupedKillerChanceModifierStrategy killerStrategy)
{
this(itemId, min, max, chance, amountMultiplierStrategy, chanceMultiplierStrategy, preciseStrategy, killerStrategy, IDropCalculationStrategy.DEFAULT_STRATEGY);
}
public GeneralDropItem(int itemId, long min, long max, double chance, IAmountMultiplierStrategy amountMultiplierStrategy, IChanceMultiplierStrategy chanceMultiplierStrategy, IPreciseDeterminationStrategy preciseStrategy, INonGroupedKillerChanceModifierStrategy killerStrategy, IDropCalculationStrategy dropCalculationStrategy)
{
_itemId = itemId;
_min = min;
_max = max;
_chance = chance;
_amountStrategy = amountMultiplierStrategy;
_chanceStrategy = chanceMultiplierStrategy;
_preciseStrategy = preciseStrategy;
_killerStrategy = killerStrategy;
_dropCalculationStrategy = dropCalculationStrategy;
}
protected double getGlobalChanceMultiplier(boolean isPremium)
/**
* @return the _amountStrategy
*/
public final IAmountMultiplierStrategy getAmountStrategy()
{
return 1.;
return _amountStrategy;
}
protected double getGlobalAmountMultiplier(boolean isPremium)
/**
* @return the _chanceStrategy
*/
public final IChanceMultiplierStrategy getChanceStrategy()
{
return 1.;
return _chanceStrategy;
}
private final long getMinMax(L2Character victim, L2Character killer, long val)
/**
* @return the _preciseStrategy
*/
public final IPreciseDeterminationStrategy getPreciseStrategy()
{
double multiplier = 1;
// individual drop amount
Float individualDropAmountMultiplier = null;
if (killer.getActingPlayer().hasPremiumStatus())
{
final Float normalMultiplier = Config.RATE_DROP_AMOUNT_MULTIPLIER.get(getItemId());
final Float premiumMultiplier = Config.PREMIUM_RATE_DROP_AMOUNT_BY_ID.get(getItemId());
if ((normalMultiplier != null) && (premiumMultiplier != null))
{
individualDropAmountMultiplier = normalMultiplier * premiumMultiplier;
}
else if (normalMultiplier != null)
{
individualDropAmountMultiplier = normalMultiplier;
}
else if (premiumMultiplier != null)
{
individualDropAmountMultiplier = premiumMultiplier;
}
}
else
{
individualDropAmountMultiplier = Config.RATE_DROP_AMOUNT_MULTIPLIER.get(getItemId());
}
if (individualDropAmountMultiplier != null)
{
// individual amount list multiplier
multiplier *= individualDropAmountMultiplier;
}
else
{
final L2Item item = ItemTable.getInstance().getTemplate(getItemId());
// global amount multiplier
if ((item != null) && item.hasExImmediateEffect())
{
// global herb amount multiplier
multiplier *= Config.RATE_HERB_DROP_AMOUNT_MULTIPLIER;
}
else
{
// drop type specific amount multiplier
multiplier *= getGlobalAmountMultiplier(killer.getActingPlayer().hasPremiumStatus());
}
}
// global champions amount multiplier
if (victim.isChampion())
{
multiplier *= getItemId() != Inventory.ADENA_ID ? Config.L2JMOD_CHAMPION_REWARDS : Config.L2JMOD_CHAMPION_ADENAS_REWARDS;
}
return (long) (val * multiplier);
return _preciseStrategy;
}
/**
* @return the _killerStrategy
*/
public final INonGroupedKillerChanceModifierStrategy getKillerChanceModifierStrategy()
{
return _killerStrategy;
}
/**
* @return the _dropCalculationStrategy
*/
public final IDropCalculationStrategy getDropCalculationStrategy()
{
return _dropCalculationStrategy;
}
/**
* Gets the item id
* @return the item id
*/
public int getItemId()
public final int getItemId()
{
return _itemId;
}
/**
* Gets the min drop count
* Gets the base min drop count
* @return the min
*/
public long getMin()
public final long getMin()
{
return _min;
}
/**
* Gets the min drop count
* @param victim the victim
* @param killer the killer
* Gets the min drop count modified by server rates
* @param victim the victim who drops the item
* @param killer
* @return the min modified by any rates.
*/
public long getMin(L2Character victim, L2Character killer)
public final long getMin(L2Character victim, L2Character killer)
{
return getMinMax(victim, killer, getMin());
return (long) (getMin() * getAmountMultiplier(victim, killer));
}
/**
* Gets the max drop count
* Gets the base max drop count
* @return the max
*/
public long getMax()
public final long getMax()
{
return _max;
}
/**
* Gets the max drop count
* @param victim the victim
* @param killer the killer
* Gets the max drop count modified by server rates
* @param victim the victim who drops the item
* @param killer
* @return the max modified by any rates.
*/
public long getMax(L2Character victim, L2Character killer)
public final long getMax(L2Character victim, L2Character killer)
{
return getMinMax(victim, killer, getMax());
return (long) (getMax() * getAmountMultiplier(victim, killer));
}
/**
* Gets the chance of this drop item.
* @return the chance
*/
public double getChance()
public final double getChance()
{
return _chance;
}
/**
* Gets the chance of this drop item.
* @param victim the victim
* @param killer the killer
* @return the chance modified by any rates.
* Gets the chance of dropping this item for current killer and victim (modified by server rates and another rules based on killer) <br>
* This shall be used to calculate chance outside of drop groups.
* @param victim the victim who drops the item
* @param killer who kills the victim
* @return a chance to drop modified by deep blue drop rules
*/
public double getChance(L2Character victim, L2Character killer)
public final double getChance(L2Character victim, L2Character killer)
{
double multiplier = 1;
// individual drop chance
Float individualDropChanceMultiplier = null;
if (killer.getActingPlayer().hasPremiumStatus())
{
final Float normalMultiplier = Config.RATE_DROP_CHANCE_MULTIPLIER.get(getItemId());
final Float premiumMultiplier = Config.PREMIUM_RATE_DROP_CHANCE_BY_ID.get(getItemId());
if ((normalMultiplier != null) && (premiumMultiplier != null))
{
individualDropChanceMultiplier = normalMultiplier * premiumMultiplier;
}
else if (normalMultiplier != null)
{
individualDropChanceMultiplier = normalMultiplier;
}
else if (premiumMultiplier != null)
{
individualDropChanceMultiplier = premiumMultiplier;
}
}
else
{
individualDropChanceMultiplier = Config.RATE_DROP_CHANCE_MULTIPLIER.get(getItemId());
}
if (individualDropChanceMultiplier != null)
{
multiplier *= individualDropChanceMultiplier;
}
else
{
final L2Item item = ItemTable.getInstance().getTemplate(getItemId());
if ((item != null) && item.hasExImmediateEffect())
{
multiplier *= Config.RATE_HERB_DROP_CHANCE_MULTIPLIER;
}
else
{
multiplier *= getGlobalChanceMultiplier(killer.getActingPlayer().hasPremiumStatus());
}
}
if (victim.isChampion())
{
multiplier *= Config.L2JMOD_CHAMPION_REWARDS;
}
return (getChance() * multiplier);
return (getKillerChanceModifier(victim, killer) * getChance());
}
/*
* (non-Javadoc)
* @see com.l2jserver.gameserver.model.drop.IDropItem#calculateDrops(com.l2jserver.gameserver.model.actor.L2Character, com.l2jserver.gameserver.model.actor.L2Character)
*/
@Override
public Collection<ItemHolder> calculateDrops(L2Character victim, L2Character killer)
public final List<ItemHolder> calculateDrops(L2Character victim, L2Character killer)
{
final int levelDifference = victim.getLevel() - killer.getLevel();
final double levelGapChanceToDrop;
if (getItemId() == Inventory.ADENA_ID)
{
levelGapChanceToDrop = Util.map(levelDifference, -Config.DROP_ADENA_MAX_LEVEL_DIFFERENCE, -Config.DROP_ADENA_MIN_LEVEL_DIFFERENCE, Config.DROP_ADENA_MIN_LEVEL_GAP_CHANCE, 100.0);
}
else
{
levelGapChanceToDrop = Util.map(levelDifference, -Config.DROP_ITEM_MAX_LEVEL_DIFFERENCE, -Config.DROP_ITEM_MIN_LEVEL_DIFFERENCE, Config.DROP_ITEM_MIN_LEVEL_GAP_CHANCE, 100.0);
}
// There is a chance of level gap that it wont drop this item
if (levelGapChanceToDrop < (Rnd.nextDouble() * 100))
{
return null;
}
final double chance = getChance(victim, killer);
final boolean successes = chance > (Rnd.nextDouble() * 100);
if (successes)
{
final Collection<ItemHolder> items = new ArrayList<>(1);
final long baseDropCount = Rnd.get(getMin(victim, killer), getMax(victim, killer));
final long finaldropCount = (long) (Config.L2JMOD_OLD_DROP_BEHAVIOR ? (baseDropCount * Math.max(1, chance / 100)) + (chance > 100 ? (chance % 100) > (Rnd.nextDouble() * 100) ? baseDropCount : 0 : 0) : baseDropCount);
items.add(new ItemHolder(getItemId(), finaldropCount));
return items;
}
return null;
return _dropCalculationStrategy.calculateDrops(this, victim, killer);
}
/**
* @return <code>true</code> if chance over 100% should be handled
*/
public final boolean isPreciseCalculated()
{
return _preciseStrategy.isPreciseCalculated(this);
}
/**
* This handles by default deep blue drop rules. It may also be used to handle another drop chance rules based on killer
* @param victim the victim who drops the item
* @param killer who kills the victim
* @return a number between 0 and 1 (usually)
*/
protected final double getKillerChanceModifier(L2Character victim, L2Character killer)
{
return _killerStrategy.getKillerChanceModifier(this, victim, killer);
}
/**
* This gets standard server rates for this item
* @param victim who drops the item
* @param killer
* @return
*/
protected final double getAmountMultiplier(L2Character victim, L2Character killer)
{
return _amountStrategy.getAmountMultiplier(this, victim, killer);
}
/**
* This gets standard server rates for this item
* @param victim who drops the item
* @param killer
* @return
*/
protected final double getChanceMultiplier(L2Character victim, L2Character killer)
{
return _chanceStrategy.getChanceMultiplier(this, victim, killer);
}
}

246
trunk/java/com/l2jserver/gameserver/model/drops/GroupedGeneralDropItem.java
View File

@ -19,134 +19,234 @@
package com.l2jserver.gameserver.model.drops;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import com.l2jserver.Config;
import com.l2jserver.gameserver.datatables.ItemTable;
import com.l2jserver.gameserver.model.actor.L2Character;
import com.l2jserver.gameserver.model.actor.instance.L2RaidBossInstance;
import com.l2jserver.gameserver.model.drops.strategy.IAmountMultiplierStrategy;
import com.l2jserver.gameserver.model.drops.strategy.IChanceMultiplierStrategy;
import com.l2jserver.gameserver.model.drops.strategy.IGroupedItemDropCalculationStrategy;
import com.l2jserver.gameserver.model.drops.strategy.IKillerChanceModifierStrategy;
import com.l2jserver.gameserver.model.drops.strategy.IPreciseDeterminationStrategy;
import com.l2jserver.gameserver.model.holders.ItemHolder;
import com.l2jserver.gameserver.model.items.L2Item;
import com.l2jserver.gameserver.util.Util;
import com.l2jserver.util.Rnd;
/**
* @author NosBit
*/
public class GroupedGeneralDropItem implements IDropItem
public final class GroupedGeneralDropItem implements IDropItem
{
private final double _chance;
private List<GeneralDropItem> _items;
protected final IGroupedItemDropCalculationStrategy _dropCalculationStrategy;
protected final IKillerChanceModifierStrategy _killerChanceModifierStrategy;
protected final IPreciseDeterminationStrategy _preciseStrategy;
/**
* @param chance the chance of this drop item.
*/
public GroupedGeneralDropItem(double chance)
{
_chance = chance;
this(chance, IGroupedItemDropCalculationStrategy.DEFAULT_STRATEGY, IKillerChanceModifierStrategy.DEFAULT_STRATEGY, IPreciseDeterminationStrategy.DEFAULT);
}
protected double getGlobalChanceMultiplier()
/**
* @param chance the chance of this drop item.
* @param dropStrategy to calculate drops.
* @param killerStrategy
* @param preciseStrategy
*/
public GroupedGeneralDropItem(double chance, IGroupedItemDropCalculationStrategy dropStrategy, IKillerChanceModifierStrategy killerStrategy, IPreciseDeterminationStrategy preciseStrategy)
{
return 1.;
_chance = chance;
_dropCalculationStrategy = dropStrategy;
_killerChanceModifierStrategy = killerStrategy;
_preciseStrategy = preciseStrategy;
}
/**
* Gets the chance of this drop item.
* @return the chance
*/
public double getChance()
public final double getChance()
{
return _chance;
}
/**
* Gets the chance of this drop item.
* @param victim the victim
* @param killer the killer
* @return the chance modified by any rates.
*/
public double getChance(L2Character victim, L2Character killer)
{
for (final GeneralDropItem gdi : getItems())
{
final L2Item item = ItemTable.getInstance().getTemplate(gdi.getItemId());
if ((item == null) || !item.hasExImmediateEffect())
{
return getChance() * getGlobalChanceMultiplier();
}
}
return getChance() * Config.RATE_HERB_DROP_CHANCE_MULTIPLIER;
}
/**
* Gets the items.
* @return the items
*/
public List<GeneralDropItem> getItems()
public final List<GeneralDropItem> getItems()
{
return _items;
}
/**
* @return the strategy
*/
public final IGroupedItemDropCalculationStrategy getDropCalculationStrategy()
{
return _dropCalculationStrategy;
}
/**
* @return the _killerChanceModifierStrategy
*/
public IKillerChanceModifierStrategy getKillerChanceModifierStrategy()
{
return _killerChanceModifierStrategy;
}
/**
* @return the _preciseStrategy
*/
public final IPreciseDeterminationStrategy getPreciseStrategy()
{
return _preciseStrategy;
}
/**
* Sets an item list to this drop item.
* @param items the item list
*/
public void setItems(List<GeneralDropItem> items)
public final void setItems(List<GeneralDropItem> items)
{
_items = Collections.unmodifiableList(items);
}
/*
* (non-Javadoc)
* @see com.l2jserver.gameserver.model.drop.IDropItem#calculateDrops(com.l2jserver.gameserver.model.actor.L2Character, com.l2jserver.gameserver.model.actor.L2Character)
/**
* Returns a list of items in the group with chance multiplied by chance of the group
* @return the list of items with modified chances
*/
@Override
public Collection<ItemHolder> calculateDrops(L2Character victim, L2Character killer)
public final List<GeneralDropItem> extractMe()
{
final int levelDifference = victim.getLevel() - killer.getLevel();
double chanceModifier;
if (victim instanceof L2RaidBossInstance)
List<GeneralDropItem> items = new ArrayList<>();
for (final GeneralDropItem item : getItems())
{
chanceModifier = Math.max(0, Math.min(1, (levelDifference * 0.15) + 1));
// precise and killer strategies of the group
items.add(new GeneralDropItem(item.getItemId(), item.getMin(), item.getMax(), (item.getChance() * getChance()) / 100, item.getAmountStrategy(), item.getChanceStrategy(), getPreciseStrategy(), getKillerChanceModifierStrategy(), item.getDropCalculationStrategy()));
}
else
return items;
}
/**
* statically normalizes a group, useful when need to convert legacy SQL data
* @return a new group with items, which have a sum of getChance() of 100%
*/
public final GroupedGeneralDropItem normalizeMe()
{
double sumchance = 0;
for (GeneralDropItem item : getItems())
{
chanceModifier = 1;
double levelGapChanceToDrop = Util.map(levelDifference, -Config.DROP_ITEM_MAX_LEVEL_DIFFERENCE, -Config.DROP_ITEM_MIN_LEVEL_DIFFERENCE, Config.DROP_ITEM_MIN_LEVEL_GAP_CHANCE, 100.0);
// There is a chance of level gap that it wont drop this item
if (levelGapChanceToDrop < (Rnd.nextDouble() * 100))
{
return null;
}
sumchance += (item.getChance() * getChance()) / 100;
}
final double chance = getChance(victim, killer) * chanceModifier;
final boolean successes = chance > (Rnd.nextDouble() * 100);
if (successes)
final double sumchance1 = sumchance;
GroupedGeneralDropItem group = new GroupedGeneralDropItem(sumchance1, getDropCalculationStrategy(), IKillerChanceModifierStrategy.NO_RULES, getPreciseStrategy());
List<GeneralDropItem> items = new ArrayList<>();
for (final GeneralDropItem item : getItems())
{
double totalChance = 0;
final double random = (Rnd.nextDouble() * 100);
for (GeneralDropItem item : getItems())
{
// Grouped item chance rates should not be modified.
totalChance += item.getChance();
if (totalChance > random)
{
final Collection<ItemHolder> items = new ArrayList<>(1);
final long baseDropCount = Rnd.get(item.getMin(victim, killer), item.getMax(victim, killer));
final long finaldropCount = (long) (Config.L2JMOD_OLD_DROP_BEHAVIOR ? (baseDropCount * Math.max(1, chance / 100)) + (chance > 100 ? (chance % 100) > (Rnd.nextDouble() * 100) ? baseDropCount : 0 : 0) : baseDropCount);
items.add(new ItemHolder(item.getItemId(), finaldropCount));
return items;
}
}
// modify only the chance, leave all other rules intact
items.add(new GeneralDropItem(item.getItemId(), item.getMin(), item.getMax(), (item.getChance() * getChance()) / sumchance1, item.getAmountStrategy(), item.getChanceStrategy(), item.getPreciseStrategy(), item.getKillerChanceModifierStrategy(), item.getDropCalculationStrategy()));
}
group.setItems(items);
return group;
}
/**
* Creates a normalized group taking into account all drop modifiers, needed when handling a group which has items with different chance rates
* @param victim
* @param killer
* @return a new normalized group with all drop modifiers applied
*/
public final GroupedGeneralDropItem normalizeMe(L2Character victim, L2Character killer)
{
return normalizeMe(victim, killer, true, 1);
}
/**
* Creates a normalized group taking into account all drop modifiers, needed when handling a group which has items with different chance rates
* @param victim
* @param killer
* @param chanceModifier an additional chance modifier
* @return a new normalized group with all drop modifiers applied
*/
public final GroupedGeneralDropItem normalizeMe(L2Character victim, L2Character killer, double chanceModifier)
{
return normalizeMe(victim, killer, true, chanceModifier);
}
/**
* Creates a normalized group taking into account all drop modifiers, needed when handling a group which has items with different chance rates
* @param victim
* @return a new normalized group with all victim modifiers applied
*/
public final GroupedGeneralDropItem normalizeMe(L2Character victim)
{
return normalizeMe(victim, null, false, 1);
}
/**
* Creates a normalized group taking into account all drop modifiers, needed when handling a group which has items with different chance rates
* @param victim
* @param chanceModifier an additional chance modifier
* @return a new normalized group with all victim modifiers applied
*/
public final GroupedGeneralDropItem normalizeMe(L2Character victim, double chanceModifier)
{
return normalizeMe(victim, null, false, chanceModifier);
}
/**
* Creates a normalized group taking into account all drop modifiers, needed when handling a group which has items with different chance rates
* @param victim
* @param killer
* @param applyKillerModifier if to modify chance by {@link GroupedGeneralDropItem#getKillerChanceModifier(L2Character, L2Character)}
* @param chanceModifier an additional chance modifier
* @return a new normalized group with all drop modifiers applied
*/
private final GroupedGeneralDropItem normalizeMe(L2Character victim, L2Character killer, boolean applyKillerModifier, double chanceModifier)
{
if (applyKillerModifier)
{
chanceModifier *= (getKillerChanceModifier(victim, killer));
}
double sumchance = 0;
for (GeneralDropItem item : getItems())
{
sumchance += (item.getChance(victim, killer) * getChance() * chanceModifier) / 100;
}
GroupedGeneralDropItem group = new GroupedGeneralDropItem(sumchance, getDropCalculationStrategy(), IKillerChanceModifierStrategy.NO_RULES, getPreciseStrategy()); // to discard further deep blue calculations
List<GeneralDropItem> items = new ArrayList<>();
for (GeneralDropItem item : getItems())
{
// the item is made almost "static"
items.add(new GeneralDropItem(item.getItemId(), item.getMin(victim, killer), item.getMax(victim, killer), (item.getChance(victim, killer) * getChance() * chanceModifier) / sumchance, IAmountMultiplierStrategy.STATIC, IChanceMultiplierStrategy.STATIC, getPreciseStrategy(), IKillerChanceModifierStrategy.NO_RULES, item.getDropCalculationStrategy()));
}
group.setItems(items);
return group;
return null;
}
@Override
public final List<ItemHolder> calculateDrops(L2Character victim, L2Character killer)
{
return _dropCalculationStrategy.calculateDrops(this, victim, killer);
}
/**
* This handles by default deep blue drop rules. It may also be used to handle another drop chance rules based on killer
* @param victim the victim who drops the item
* @param killer who kills the victim
* @return a number between 0 and 1 (usually)
*/
public final double getKillerChanceModifier(L2Character victim, L2Character killer)
{
return _killerChanceModifierStrategy.getKillerChanceModifier(this, victim, killer);
}
public boolean isPreciseCalculated()
{
return _preciseStrategy.isPreciseCalculated(this);
}
}

5
trunk/java/com/l2jserver/gameserver/model/drops/IDropItem.java
View File

@ -18,7 +18,7 @@
*/
package com.l2jserver.gameserver.model.drops;
import java.util.Collection;
import java.util.List;
import com.l2jserver.gameserver.model.actor.L2Character;
import com.l2jserver.gameserver.model.holders.ItemHolder;
@ -28,11 +28,12 @@ import com.l2jserver.gameserver.model.holders.ItemHolder;
*/
public interface IDropItem
{
/**
* Calculates drops of this drop item.
* @param victim the victim
* @param killer the killer
* @return {@code null} or empty collection if there are no drops, a collection containing all items to drop otherwise
*/
public Collection<ItemHolder> calculateDrops(L2Character victim, L2Character killer);
public List<ItemHolder> calculateDrops(L2Character victim, L2Character killer);
}

27
trunk/java/com/l2jserver/gameserver/model/drops/GroupedDeathDropItem.java → trunk/java/com/l2jserver/gameserver/model/drops/IDropItemFactory.java
View File

@ -18,28 +18,17 @@
*/
package com.l2jserver.gameserver.model.drops;
import com.l2jserver.Config;
/**
* @author NosBit
* @author Battlecruiser
*/
public class GroupedDeathDropItem extends GroupedGeneralDropItem
public interface IDropItemFactory
{
/**
* @param chance the chance of this drop item.
* @param itemId the item id
* @param min the min count
* @param max the max count
* @param chance the chance of this drop item
* @return the drop item created by this factory
*/
public GroupedDeathDropItem(double chance)
{
super(chance);
}
/*
* (non-Javadoc)
* @see com.l2jserver.gameserver.model.drops.GroupedGeneralDropItem#getGlobalChanceMultiplier()
*/
@Override
protected double getGlobalChanceMultiplier()
{
return Config.RATE_DEATH_DROP_CHANCE_MULTIPLIER;
}
public IDropItem newDropItem(int itemId, long min, long max, double chance);
}

32
trunk/java/com/l2jserver/gameserver/model/drops/GroupedCorpseDropItem.java → trunk/java/com/l2jserver/gameserver/model/drops/IGroupedDropItemFactory.java
View File

@ -1,45 +1,27 @@
/*
* Copyright (C) 2004-2015 L2J Server
*
*
* This file is part of L2J Server.
*
*
* L2J Server 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 3 of the License, or
* (at your option) any later version.
*
*
* L2J Server 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, see <http://www.gnu.org/licenses/>.
*/
package com.l2jserver.gameserver.model.drops;
import com.l2jserver.Config;
/**
* @author NosBit
* @author Battlecruiser
*/
public class GroupedCorpseDropItem extends GroupedGeneralDropItem
public interface IGroupedDropItemFactory
{
/**
* @param chance the chance of this drop item.
*/
public GroupedCorpseDropItem(double chance)
{
super(chance);
}
/*
* (non-Javadoc)
* @see com.l2jserver.gameserver.model.drops.GroupedGeneralDropItem#getGlobalChanceMultiplier()
*/
@Override
protected double getGlobalChanceMultiplier()
{
return Config.RATE_CORPSE_DROP_CHANCE_MULTIPLIER;
}
public GroupedGeneralDropItem newGroupedDropItem(double chance);
}

79
trunk/java/com/l2jserver/gameserver/model/drops/strategy/IAmountMultiplierStrategy.java Normal file
View File

@ -0,0 +1,79 @@
/*
* Copyright (C) 2004-2014 L2J Server
*
* This file is part of L2J Server.
*
* L2J Server 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 3 of the License, or
* (at your option) any later version.
*
* L2J Server 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, see <http://www.gnu.org/licenses/>.
*/
package com.l2jserver.gameserver.model.drops.strategy;
import com.l2jserver.Config;
import com.l2jserver.gameserver.datatables.ItemTable;
import com.l2jserver.gameserver.model.actor.L2Character;
import com.l2jserver.gameserver.model.drops.GeneralDropItem;
/**
* @author Battlecruiser
*/
public interface IAmountMultiplierStrategy
{
public static final IAmountMultiplierStrategy DROP = DEFAULT_STRATEGY(Config.RATE_DEATH_DROP_AMOUNT_MULTIPLIER);
public static final IAmountMultiplierStrategy SPOIL = DEFAULT_STRATEGY(Config.RATE_CORPSE_DROP_AMOUNT_MULTIPLIER);
public static final IAmountMultiplierStrategy STATIC = (item, victim, killer) -> 1;
public static IAmountMultiplierStrategy DEFAULT_STRATEGY(final double defaultMultiplier)
{
return (item, victim, killer) ->
{
double multiplier = 1;
final Float dropChanceMultiplier = Config.RATE_DROP_AMOUNT_MULTIPLIER.get(item.getItemId());
final Float premiumAmountMultiplier = Config.PREMIUM_RATE_DROP_AMOUNT_BY_ID.get(item.getItemId());
if (Config.PREMIUM_SYSTEM_ENABLED && (premiumAmountMultiplier != null) && (killer != null) && killer.isPlayer() && killer.getActingPlayer().hasPremiumStatus())
{
multiplier *= premiumAmountMultiplier;
}
else if (dropChanceMultiplier != null)
{
multiplier *= dropChanceMultiplier;
}
else if (ItemTable.getInstance().getTemplate(item.getItemId()).hasExImmediateEffect())
{
multiplier *= Config.RATE_HERB_DROP_AMOUNT_MULTIPLIER;
}
else if (victim.isRaid())
{
multiplier *= Config.RATE_RAID_DROP_AMOUNT_MULTIPLIER;
}
else if (Config.PREMIUM_SYSTEM_ENABLED && (killer != null) && killer.isPlayer() && killer.getActingPlayer().hasPremiumStatus())
{
if ((defaultMultiplier == Config.RATE_DEATH_DROP_AMOUNT_MULTIPLIER) && (defaultMultiplier != Config.RATE_CORPSE_DROP_AMOUNT_MULTIPLIER))
{
multiplier *= Config.PREMIUM_RATE_DROP_AMOUNT;
}
else
{
multiplier *= Config.PREMIUM_RATE_SPOIL_AMOUNT;
}
}
else
{
multiplier *= defaultMultiplier;
}
return multiplier;
};
}
public double getAmountMultiplier(GeneralDropItem item, L2Character victim, L2Character killer);
}

98
trunk/java/com/l2jserver/gameserver/model/drops/strategy/IChanceMultiplierStrategy.java Normal file
View File

@ -0,0 +1,98 @@
/*
* Copyright (C) 2004-2014 L2J Server
*
* This file is part of L2J Server.
*
* L2J Server 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 3 of the License, or
* (at your option) any later version.
*
* L2J Server 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, see <http://www.gnu.org/licenses/>.
*/
package com.l2jserver.gameserver.model.drops.strategy;
import com.l2jserver.Config;
import com.l2jserver.gameserver.datatables.ItemTable;
import com.l2jserver.gameserver.model.actor.L2Character;
import com.l2jserver.gameserver.model.drops.GeneralDropItem;
import com.l2jserver.gameserver.model.itemcontainer.Inventory;
/**
* @author Battlecruiser
*/
public interface IChanceMultiplierStrategy
{
public static final IChanceMultiplierStrategy DROP = DEFAULT_STRATEGY(Config.RATE_DEATH_DROP_CHANCE_MULTIPLIER);
public static final IChanceMultiplierStrategy SPOIL = DEFAULT_STRATEGY(Config.RATE_CORPSE_DROP_CHANCE_MULTIPLIER);
public static final IChanceMultiplierStrategy STATIC = (item, victim, killer) -> 1;
public static final IChanceMultiplierStrategy QUEST = (item, victim, killer) ->
{
double championmult;
if ((item.getItemId() == Inventory.ADENA_ID) || (item.getItemId() == Inventory.ANCIENT_ADENA_ID))
{
championmult = Config.L2JMOD_CHAMPION_ADENAS_REWARDS;
}
else
{
championmult = Config.L2JMOD_CHAMPION_REWARDS;
}
return (Config.L2JMOD_CHAMPION_ENABLE && (victim != null) && victim.isChampion()) ? (Config.RATE_QUEST_DROP * championmult) : Config.RATE_QUEST_DROP;
};
public static IChanceMultiplierStrategy DEFAULT_STRATEGY(final double defaultMultiplier)
{
return (item, victim, killer) ->
{
float multiplier = 1;
if (victim.isChampion())
{
multiplier *= item.getItemId() != Inventory.ADENA_ID ? Config.L2JMOD_CHAMPION_REWARDS : Config.L2JMOD_CHAMPION_ADENAS_REWARDS;
}
final Float dropChanceMultiplier = Config.RATE_DROP_CHANCE_MULTIPLIER.get(item.getItemId());
final Float premiumChanceMultiplier = Config.PREMIUM_RATE_DROP_CHANCE_BY_ID.get(item.getItemId());
if (Config.PREMIUM_SYSTEM_ENABLED && (premiumChanceMultiplier != null) && (killer != null) && killer.isPlayer() && killer.getActingPlayer().hasPremiumStatus())
{
multiplier *= premiumChanceMultiplier;
}
else if (dropChanceMultiplier != null)
{
multiplier *= dropChanceMultiplier;
}
else if (ItemTable.getInstance().getTemplate(item.getItemId()).hasExImmediateEffect())
{
multiplier *= Config.RATE_HERB_DROP_CHANCE_MULTIPLIER;
}
else if (victim.isRaid())
{
multiplier *= Config.RATE_RAID_DROP_CHANCE_MULTIPLIER;
}
else if (Config.PREMIUM_SYSTEM_ENABLED && (killer != null) && killer.isPlayer() && killer.getActingPlayer().hasPremiumStatus())
{
if ((defaultMultiplier == Config.RATE_DEATH_DROP_CHANCE_MULTIPLIER) && (defaultMultiplier != Config.RATE_CORPSE_DROP_CHANCE_MULTIPLIER))
{
multiplier *= Config.PREMIUM_RATE_DROP_CHANCE;
}
else
{
multiplier *= Config.PREMIUM_RATE_SPOIL_CHANCE;
}
}
else
{
multiplier *= defaultMultiplier;
}
return multiplier;
};
}
public double getChanceMultiplier(GeneralDropItem item, L2Character victim, L2Character killer);
}

56
trunk/java/com/l2jserver/gameserver/model/drops/strategy/IDropCalculationStrategy.java Normal file
View File

@ -0,0 +1,56 @@
/*
* Copyright (C) 2004-2014 L2J Server
*
* This file is part of L2J Server.
*
* L2J Server 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 3 of the License, or
* (at your option) any later version.
*
* L2J Server 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, see <http://www.gnu.org/licenses/>.
*/
package com.l2jserver.gameserver.model.drops.strategy;
import java.util.Collections;
import java.util.List;
import com.l2jserver.gameserver.model.actor.L2Character;
import com.l2jserver.gameserver.model.drops.GeneralDropItem;
import com.l2jserver.gameserver.model.holders.ItemHolder;
import com.l2jserver.util.Rnd;
/**
* @author Battlecruiser
*/
public interface IDropCalculationStrategy
{
public static final IDropCalculationStrategy DEFAULT_STRATEGY = (item, victim, killer) ->
{
double chance = item.getChance(victim, killer);
if (chance > (Rnd.nextDouble() * 100))
{
int amountMultiply = 1;
if (item.isPreciseCalculated() && (chance > 100))
{
amountMultiply = (int) chance / 100;
if ((chance % 100) > (Rnd.nextDouble() * 100))
{
amountMultiply++;
}
}
return Collections.singletonList(new ItemHolder(item.getItemId(), Rnd.get(item.getMin(victim, killer), item.getMax(victim, killer)) * amountMultiply));
}
return null;
};
public List<ItemHolder> calculateDrops(GeneralDropItem item, L2Character victim, L2Character killer);
}

132
trunk/java/com/l2jserver/gameserver/model/drops/strategy/IGroupedItemDropCalculationStrategy.java Normal file
View File

@ -0,0 +1,132 @@
/*
* Copyright (C) 2004-2014 L2J Server
*
* This file is part of L2J Server.
*
* L2J Server 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 3 of the License, or
* (at your option) any later version.
*
* L2J Server 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, see <http://www.gnu.org/licenses/>.
*/
package com.l2jserver.gameserver.model.drops.strategy;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import com.l2jserver.gameserver.model.actor.L2Character;
import com.l2jserver.gameserver.model.drops.GeneralDropItem;
import com.l2jserver.gameserver.model.drops.GroupedGeneralDropItem;
import com.l2jserver.gameserver.model.drops.IDropItem;
import com.l2jserver.gameserver.model.holders.ItemHolder;
import com.l2jserver.util.Rnd;
/**
* @author Battlecruiser
*/
public interface IGroupedItemDropCalculationStrategy
{
/**
* The default strategy used in L2J to calculate drops. When the group's chance raises over 100% and group has precise calculation, the dropped item's amount increases.
*/
public static final IGroupedItemDropCalculationStrategy DEFAULT_STRATEGY = new IGroupedItemDropCalculationStrategy()
{
private final Map<GroupedGeneralDropItem, GeneralDropItem> singleItemCache = new ConcurrentHashMap<>();
private GeneralDropItem getSingleItem(GroupedGeneralDropItem dropItem)
{
final GeneralDropItem item1 = dropItem.getItems().iterator().next();
singleItemCache.putIfAbsent(dropItem, new GeneralDropItem(item1.getItemId(), item1.getMin(), item1.getMax(), (item1.getChance() * dropItem.getChance()) / 100, item1.getAmountStrategy(), item1.getChanceStrategy(), dropItem.getPreciseStrategy(), dropItem.getKillerChanceModifierStrategy(), item1.getDropCalculationStrategy()));
return singleItemCache.get(dropItem);
}
@Override
public List<ItemHolder> calculateDrops(GroupedGeneralDropItem dropItem, L2Character victim, L2Character killer)
{
if (dropItem.getItems().size() == 1)
{
return getSingleItem(dropItem).calculateDrops(victim, killer);
}
GroupedGeneralDropItem normalized = dropItem.normalizeMe(victim, killer);
if (normalized.getChance() > (Rnd.nextDouble() * 100))
{
final double random = (Rnd.nextDouble() * 100);
double totalChance = 0;
for (GeneralDropItem item2 : normalized.getItems())
{
// Grouped item chance rates should not be modified (the whole magic was already done by normalizing thus the items' chance sum is always 100%).
totalChance += item2.getChance();
if (totalChance > random)
{
int amountMultiply = 1;
if (dropItem.isPreciseCalculated() && (normalized.getChance() >= 100))
{
amountMultiply = (int) (normalized.getChance()) / 100;
if ((normalized.getChance() % 100) > (Rnd.nextDouble() * 100))
{
amountMultiply++;
}
}
return Collections.singletonList(new ItemHolder(item2.getItemId(), Rnd.get(item2.getMin(victim, killer), item2.getMax(victim, killer)) * amountMultiply));
}
}
}
return null;
}
};
/**
* This strategy calculates a group's drop by calculating drops of its individual items and merging its results.
*/
public static final IGroupedItemDropCalculationStrategy DISBAND_GROUP = (item, victim, killer) ->
{
List<ItemHolder> dropped = new ArrayList<>();
for (IDropItem dropItem : item.extractMe())
{
dropped.addAll(dropItem.calculateDrops(victim, killer));
}
return dropped.isEmpty() ? null : dropped;
};
/**
* This strategy when group has precise calculation rolls multiple times over group to determine drops when group's chance raises over 100% instead of just multiplying the dropped item's amount. Thus it can produce different items from group at once.
*/
public static final IGroupedItemDropCalculationStrategy PRECISE_MULTIPLE_GROUP_ROLLS = (item, victim, killer) ->
{
if (!item.isPreciseCalculated())
{
// if item hasn't precise calculation there's no change from DEFAULT_STRATEGY
return DEFAULT_STRATEGY.calculateDrops(item, victim, victim);
}
GroupedGeneralDropItem newItem = new GroupedGeneralDropItem(item.getChance(), DEFAULT_STRATEGY, item.getKillerChanceModifierStrategy(), IPreciseDeterminationStrategy.NEVER);
newItem.setItems(item.getItems());
GroupedGeneralDropItem normalized = newItem.normalizeMe(victim, killer);
// Let's determine the number of rolls.
int rolls = (int) (normalized.getChance() / 100);
if ((Rnd.nextDouble() * 100) < (normalized.getChance() % 100))
{
rolls++;
}
List<ItemHolder> dropped = new ArrayList<>(rolls);
for (int i = 0; i < rolls; i++)
{
// As further normalizing on already normalized drop group does nothing, we can just pass the calculation to DEFAULT_STRATEGY with precise calculation disabled as we handle it.
dropped.addAll(normalized.calculateDrops(victim, killer));
}
return dropped.isEmpty() ? null : dropped;
};
public List<ItemHolder> calculateDrops(GroupedGeneralDropItem item, L2Character victim, L2Character killer);
}

71
trunk/java/com/l2jserver/gameserver/model/drops/strategy/IKillerChanceModifierStrategy.java Normal file
View File

@ -0,0 +1,71 @@
/*
* Copyright (C) 2004-2014 L2J Server
*
* This file is part of L2J Server.
*
* L2J Server 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 3 of the License, or
* (at your option) any later version.
*
* L2J Server 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, see <http://www.gnu.org/licenses/>.
*/
package com.l2jserver.gameserver.model.drops.strategy;
import com.l2jserver.Config;
import com.l2jserver.gameserver.model.actor.L2Character;
import com.l2jserver.gameserver.model.drops.GeneralDropItem;
import com.l2jserver.gameserver.model.drops.IDropItem;
import com.l2jserver.gameserver.model.itemcontainer.Inventory;
import com.l2jserver.gameserver.util.Util;
/**
* @author Battlecruiser
*/
public interface IKillerChanceModifierStrategy extends INonGroupedKillerChanceModifierStrategy
{
public static final IKillerChanceModifierStrategy DEFAULT_STRATEGY = (item, victim, killer) ->
{
int levelDifference = victim.getLevel() - killer.getLevel();
if ((victim.isRaid()) && Config.DEEPBLUE_DROP_RULES_RAID)
{
// FIXME: Config?
return Math.max(0, Math.min(1, (levelDifference * 0.15) + 1));
}
else if (Config.DEEPBLUE_DROP_RULES)
{
return Util.map(levelDifference, -Config.DROP_ITEM_MAX_LEVEL_DIFFERENCE, -Config.DROP_ITEM_MIN_LEVEL_DIFFERENCE, Config.DROP_ITEM_MIN_LEVEL_GAP_CHANCE, 100.0) / 100;
}
return 1;
};
public static final INonGroupedKillerChanceModifierStrategy DEFAULT_NONGROUP_STRATEGY = (item, victim, killer) ->
{
if (((!(victim.isRaid())) && Config.DEEPBLUE_DROP_RULES) || ((victim.isRaid()) && Config.DEEPBLUE_DROP_RULES_RAID))
{
int levelDifference = victim.getLevel() - killer.getLevel();
if (item.getItemId() == Inventory.ADENA_ID)
{
return Util.map(levelDifference, -Config.DROP_ADENA_MAX_LEVEL_DIFFERENCE, -Config.DROP_ADENA_MIN_LEVEL_DIFFERENCE, Config.DROP_ADENA_MIN_LEVEL_GAP_CHANCE, 100.0) / 100;
}
return Util.map(levelDifference, -Config.DROP_ITEM_MAX_LEVEL_DIFFERENCE, -Config.DROP_ITEM_MIN_LEVEL_DIFFERENCE, Config.DROP_ITEM_MIN_LEVEL_GAP_CHANCE, 100.0) / 100;
}
return 1;
};
IKillerChanceModifierStrategy NO_RULES = (item, victim, killer) -> 1;
public double getKillerChanceModifier(IDropItem item, L2Character victim, L2Character killer);
@Override
public default double getKillerChanceModifier(GeneralDropItem item, L2Character victim, L2Character killer)
{
return getKillerChanceModifier((IDropItem) item, victim, killer);
}
}

30
trunk/java/com/l2jserver/gameserver/model/drops/strategy/INonGroupedKillerChanceModifierStrategy.java Normal file
View File

@ -0,0 +1,30 @@
/*
* Copyright (C) 2004-2014 L2J Server
*
* This file is part of L2J Server.
*
* L2J Server 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 3 of the License, or
* (at your option) any later version.
*
* L2J Server 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, see <http://www.gnu.org/licenses/>.
*/
package com.l2jserver.gameserver.model.drops.strategy;
import com.l2jserver.gameserver.model.actor.L2Character;
import com.l2jserver.gameserver.model.drops.GeneralDropItem;
/**
* @author Battlecruiser
*/
public interface INonGroupedKillerChanceModifierStrategy
{
public double getKillerChanceModifier(GeneralDropItem item, L2Character victim, L2Character killer);
}

40
trunk/java/com/l2jserver/gameserver/model/drops/strategy/IPreciseDeterminationStrategy.java Normal file
View File

@ -0,0 +1,40 @@
/*
* Copyright (C) 2004-2014 L2J Server
*
* This file is part of L2J Server.
*
* L2J Server 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 3 of the License, or
* (at your option) any later version.
*
* L2J Server 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, see <http://www.gnu.org/licenses/>.
*/
package com.l2jserver.gameserver.model.drops.strategy;
import com.l2jserver.Config;
import com.l2jserver.gameserver.model.drops.IDropItem;
/**
* @author Battlecruiser
*/
public interface IPreciseDeterminationStrategy
{
public static final IPreciseDeterminationStrategy ALWAYS = dropItem -> true;
public static final IPreciseDeterminationStrategy DEFAULT = dropItem -> Config.PRECISE_DROP_CALCULATION;
public static final IPreciseDeterminationStrategy NEVER = dropItem -> false;
/**
* @param dropItem
* @return <code>true</code> if drop calculation strategy should use precise rules
*/
public boolean isPreciseCalculated(IDropItem dropItem);
}

3
trunk/java/com/l2jserver/gameserver/model/event/LongTimeEvent.java
View File

@ -39,6 +39,7 @@ import com.l2jserver.gameserver.datatables.EventDroplist;
import com.l2jserver.gameserver.datatables.ItemTable;
import com.l2jserver.gameserver.model.Location;
import com.l2jserver.gameserver.model.announce.EventAnnouncement;
import com.l2jserver.gameserver.model.drops.DropListScope;
import com.l2jserver.gameserver.model.drops.GeneralDropItem;
import com.l2jserver.gameserver.model.quest.Quest;
import com.l2jserver.gameserver.script.DateRange;
@ -188,7 +189,7 @@ public class LongTimeEvent extends Quest
continue;
}
_dropList.add(new GeneralDropItem(itemId, minCount, maxCount, finalChance));
_dropList.add((GeneralDropItem) DropListScope.STATIC.newDropItem(itemId, minCount, maxCount, finalChance));
}
catch (NumberFormatException nfe)
{

507
trunk/java/com/l2jserver/gameserver/model/events/AbstractScript.java
View File

@ -25,8 +25,12 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
@ -59,6 +63,9 @@ import com.l2jserver.gameserver.model.actor.instance.L2MonsterInstance;
import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
import com.l2jserver.gameserver.model.actor.instance.L2TrapInstance;
import com.l2jserver.gameserver.model.actor.templates.L2NpcTemplate;
import com.l2jserver.gameserver.model.drops.GeneralDropItem;
import com.l2jserver.gameserver.model.drops.GroupedGeneralDropItem;
import com.l2jserver.gameserver.model.drops.IDropItem;
import com.l2jserver.gameserver.model.entity.Castle;
import com.l2jserver.gameserver.model.entity.Fort;
import com.l2jserver.gameserver.model.entity.Instance;
@ -137,6 +144,7 @@ import com.l2jserver.gameserver.scripting.L2ScriptEngineManager;
import com.l2jserver.gameserver.scripting.ScriptManager;
import com.l2jserver.gameserver.util.MinionList;
import com.l2jserver.util.Rnd;
import com.l2jserver.util.Util;
/**
* Abstract script.
@ -348,7 +356,7 @@ public abstract class AbstractScript implements INamable
// ---------------------------------------------------------------------------------------------------------------------------
/**
* Provides callback operation when L2Attackable dies from a player.
* Provides delayed (Depending on {@link com.l2jserver.gameserver.model.actor.L2Attackable#getOnKillDelay()}) callback operation when L2Attackable dies from a player.
* @param callback
* @param npcIds
* @return
@ -359,7 +367,7 @@ public abstract class AbstractScript implements INamable
}
/**
* Provides callback operation when L2Attackable dies from a player.
* Provides delayed (Depending on {@link com.l2jserver.gameserver.model.actor.L2Attackable#getOnKillDelay()}) callback operation when L2Attackable dies from a player.
* @param callback
* @param npcIds
* @return
@ -2330,6 +2338,501 @@ public abstract class AbstractScript implements INamable
return false;
}
/**
* Gives an item to the player
* @param player
* @param item
* @param victim the character that "dropped" the item
* @return <code>true</code> if at least one item was given, <code>false</code> otherwise
*/
protected static boolean giveItems(L2PcInstance player, IDropItem item, L2Character victim)
{
List<ItemHolder> items = item.calculateDrops(victim, player);
if ((items == null) || items.isEmpty())
{
return false;
}
giveItems(player, items);
return true;
}
/**
* Gives an item to the player
* @param player
* @param items
*/
protected static void giveItems(L2PcInstance player, List<ItemHolder> items)
{
for (ItemHolder item : items)
{
giveItems(player, item);
}
}
/**
* Gives an item to the player
* @param player
* @param item
* @param limit the maximum amount of items the player can have. Won't give more if this limit is reached.
* @return <code>true</code> if at least one item was given to the player, <code>false</code> otherwise
*/
protected static boolean giveItems(L2PcInstance player, ItemHolder item, long limit)
{
long maxToGive = limit - player.getInventory().getInventoryItemCount(item.getId(), -1);
if (maxToGive <= 0)
{
return false;
}
giveItems(player, item.getId(), Math.min(maxToGive, item.getCount()));
return true;
}
protected static boolean giveItems(L2PcInstance player, ItemHolder item, long limit, boolean playSound)
{
boolean drop = giveItems(player, item, limit);
if (drop && playSound)
{
playSound(player, QuestSound.ITEMSOUND_QUEST_ITEMGET);
}
return drop;
}
/**
* @param player
* @param items
* @param limit the maximum amount of items the player can have. Won't give more if this limit is reached.
* @return <code>true</code> if at least one item was given to the player, <code>false</code> otherwise
*/
protected static boolean giveItems(L2PcInstance player, List<ItemHolder> items, long limit)
{
boolean b = false;
for (ItemHolder item : items)
{
b |= giveItems(player, item, limit);
}
return b;
}
protected static boolean giveItems(L2PcInstance player, List<ItemHolder> items, long limit, boolean playSound)
{
boolean drop = giveItems(player, items, limit);
if (drop && playSound)
{
playSound(player, QuestSound.ITEMSOUND_QUEST_ITEMGET);
}
return drop;
}
/**
* @param player
* @param items
* @param limit the maximum amount of items the player can have. Won't give more if this limit is reached. If a no limit for an itemId is specified, item will always be given
* @return <code>true</code> if at least one item was given to the player, <code>false</code> otherwise
*/
protected static boolean giveItems(L2PcInstance player, List<ItemHolder> items, Map<Integer, Long> limit)
{
return giveItems(player, items, Util.mapToFunction(limit));
}
/**
* @param player
* @param items
* @param limit the maximum amount of items the player can have. Won't give more if this limit is reached. If a no limit for an itemId is specified, item will always be given
* @return <code>true</code> if at least one item was given to the player, <code>false</code> otherwise
*/
protected static boolean giveItems(L2PcInstance player, List<ItemHolder> items, Function<Integer, Long> limit)
{
boolean b = false;
for (ItemHolder item : items)
{
if (limit != null)
{
Long longLimit = limit.apply(item.getId());
// null -> no limit specified for that item id. This trick is to avoid limit.apply() be called twice (once for the null check)
if (longLimit != null)
{
b |= giveItems(player, item, longLimit);
continue; // the item is given, continue with next
}
}
// da BIG else
// no limit specified here (either limit or limit.apply(item.getId()) is null)
b = true;
giveItems(player, item);
}
return b;
}
protected static boolean giveItems(L2PcInstance player, List<ItemHolder> items, Function<Integer, Long> limit, boolean playSound)
{
boolean drop = giveItems(player, items, limit);
if (drop && playSound)
{
playSound(player, QuestSound.ITEMSOUND_QUEST_ITEMGET);
}
return drop;
}
protected static boolean giveItems(L2PcInstance player, List<ItemHolder> items, Map<Integer, Long> limit, boolean playSound)
{
return giveItems(player, items, Util.mapToFunction(limit), playSound);
}
/**
* @param player
* @param item
* @param victim the character that "dropped" the item
* @param limit the maximum amount of items the player can have. Won't give more if this limit is reached.
* @return <code>true</code> if at least one item was given to the player, <code>false</code> otherwise
*/
protected static boolean giveItems(L2PcInstance player, IDropItem item, L2Character victim, int limit)
{
return giveItems(player, item.calculateDrops(victim, player), limit);
}
protected static boolean giveItems(L2PcInstance player, IDropItem item, L2Character victim, int limit, boolean playSound)
{
boolean drop = giveItems(player, item, victim, limit);
if (drop && playSound)
{
playSound(player, QuestSound.ITEMSOUND_QUEST_ITEMGET);
}
return drop;
}
/**
* @param player
* @param item
* @param victim the character that "dropped" the item
* @param limit the maximum amount of items the player can have. Won't give more if this limit is reached. If a no limit for an itemId is specified, item will always be given
* @return <code>true</code> if at least one item was given to the player, <code>false</code> otherwise
*/
protected static boolean giveItems(L2PcInstance player, IDropItem item, L2Character victim, Map<Integer, Long> limit)
{
return giveItems(player, item.calculateDrops(victim, player), limit);
}
/**
* @param player
* @param item
* @param victim the character that "dropped" the item
* @param limit the maximum amount of items the player can have. Won't give more if this limit is reached. If a no limit for an itemId is specified, item will always be given
* @return <code>true</code> if at least one item was given to the player, <code>false</code> otherwise
*/
protected static boolean giveItems(L2PcInstance player, IDropItem item, L2Character victim, Function<Integer, Long> limit)
{
return giveItems(player, item.calculateDrops(victim, player), limit);
}
protected static boolean giveItems(L2PcInstance player, IDropItem item, L2Character victim, Map<Integer, Long> limit, boolean playSound)
{
return giveItems(player, item, victim, Util.mapToFunction(limit), playSound);
}
protected static boolean giveItems(L2PcInstance player, IDropItem item, L2Character victim, Function<Integer, Long> limit, boolean playSound)
{
boolean drop = giveItems(player, item, victim, limit);
if (drop && playSound)
{
playSound(player, QuestSound.ITEMSOUND_QUEST_ITEMGET);
}
return drop;
}
/**
* Distributes items to players equally
* @param players the players to whom the items will be distributed
* @param items the items to distribute
* @param limit the limit what single player can have of each item
* @param playSound if to play sound if a player gets at least one item
* @return the counts of each items given to each player
*/
protected static Map<L2PcInstance, Map<Integer, Long>> distributeItems(Collection<L2PcInstance> players, Collection<ItemHolder> items, Function<Integer, Long> limit, boolean playSound)
{
Map<L2PcInstance, Map<Integer, Long>> rewardedCounts = calculateDistribution(players, items, limit);
// now give the calculated items to the players
giveItems(rewardedCounts, playSound);
return rewardedCounts;
}
/**
* Distributes items to players equally
* @param players the players to whom the items will be distributed
* @param items the items to distribute
* @param limit the limit what single player can have of each item
* @param playSound if to play sound if a player gets at least one item
* @return the counts of each items given to each player
*/
protected static Map<L2PcInstance, Map<Integer, Long>> distributeItems(Collection<L2PcInstance> players, Collection<ItemHolder> items, Map<Integer, Long> limit, boolean playSound)
{
return distributeItems(players, items, Util.mapToFunction(limit), playSound);
}
/**
* Distributes items to players equally
* @param players the players to whom the items will be distributed
* @param items the items to distribute
* @param limit the limit what single player can have of each item
* @param playSound if to play sound if a player gets at least one item
* @return the counts of each items given to each player
*/
protected static Map<L2PcInstance, Map<Integer, Long>> distributeItems(Collection<L2PcInstance> players, Collection<ItemHolder> items, long limit, boolean playSound)
{
return distributeItems(players, items, t -> limit, playSound);
}
/**
* Distributes items to players equally
* @param players the players to whom the items will be distributed
* @param item the items to distribute
* @param limit the limit what single player can have of each item
* @param playSound if to play sound if a player gets at least one item
* @return the counts of each items given to each player
*/
protected static Map<L2PcInstance, Long> distributeItems(Collection<L2PcInstance> players, ItemHolder item, long limit, boolean playSound)
{
Map<L2PcInstance, Map<Integer, Long>> distribution = distributeItems(players, Collections.singletonList(item), limit, playSound);
Map<L2PcInstance, Long> returnMap = new HashMap<>();
for (Entry<L2PcInstance, Map<Integer, Long>> entry : distribution.entrySet())
{
for (Entry<Integer, Long> entry2 : entry.getValue().entrySet())
{
returnMap.put(entry.getKey(), entry2.getValue());
}
}
return returnMap;
}
/**
* Distributes items to players equally
* @param players the players to whom the items will be distributed
* @param items the items to distribute
* @param killer the one who "kills" the victim
* @param victim the character that "dropped" the item
* @param limit the limit what single player can have of each item
* @param playSound if to play sound if a player gets at least one item
* @return the counts of each items given to each player
*/
protected static Map<L2PcInstance, Map<Integer, Long>> distributeItems(Collection<L2PcInstance> players, IDropItem items, L2Character killer, L2Character victim, Function<Integer, Long> limit, boolean playSound)
{
return distributeItems(players, items.calculateDrops(victim, killer), limit, playSound);
}
/**
* Distributes items to players equally
* @param players the players to whom the items will be distributed
* @param items the items to distribute
* @param killer the one who "kills" the victim
* @param victim the character that "dropped" the item
* @param limit the limit what single player can have of each item
* @param playSound if to play sound if a player gets at least one item
* @return the counts of each items given to each player
*/
protected static Map<L2PcInstance, Map<Integer, Long>> distributeItems(Collection<L2PcInstance> players, IDropItem items, L2Character killer, L2Character victim, Map<Integer, Long> limit, boolean playSound)
{
return distributeItems(players, items.calculateDrops(victim, killer), limit, playSound);
}
/**
* Distributes items to players equally
* @param players the players to whom the items will be distributed
* @param items the items to distribute
* @param killer the one who "kills" the victim
* @param victim the character that "dropped" the item
* @param limit the limit what single player can have of each item
* @param playSound if to play sound if a player gets at least one item
* @return the counts of each items given to each player
*/
protected static Map<L2PcInstance, Map<Integer, Long>> distributeItems(Collection<L2PcInstance> players, IDropItem items, L2Character killer, L2Character victim, long limit, boolean playSound)
{
return distributeItems(players, items.calculateDrops(victim, killer), limit, playSound);
}
/**
* Distributes items to players equally
* @param players the players to whom the items will be distributed
* @param items the items to distribute
* @param killer the one who "kills" the victim
* @param victim the character that "dropped" the item
* @param limit the limit what single player can have of each item
* @param playSound if to play sound if a player gets at least one item
* @param smartDrop true if to not calculate a drop, which can't be given to any player 'cause of limits
* @return the counts of each items given to each player
*/
protected static Map<L2PcInstance, Map<Integer, Long>> distributeItems(Collection<L2PcInstance> players, final GroupedGeneralDropItem items, L2Character killer, L2Character victim, Function<Integer, Long> limit, boolean playSound, boolean smartDrop)
{
GroupedGeneralDropItem toDrop;
if (smartDrop)
{
toDrop = new GroupedGeneralDropItem(items.getChance(), items.getDropCalculationStrategy(), items.getKillerChanceModifierStrategy(), items.getPreciseStrategy());
List<GeneralDropItem> dropItems = new LinkedList<>(items.getItems());
ITEM_LOOP: for (Iterator<GeneralDropItem> it = dropItems.iterator(); it.hasNext();)
{
GeneralDropItem item = it.next();
for (L2PcInstance player : players)
{
int itemId = item.getItemId();
if (player.getInventory().getInventoryItemCount(itemId, -1, true) < avoidNull(limit, itemId))
{
// we can give this item to this player
continue ITEM_LOOP;
}
}
// there's nobody to give this item to
it.remove();
}
toDrop.setItems(dropItems);
toDrop = toDrop.normalizeMe(victim, killer);
}
else
{
toDrop = items;
}
return distributeItems(players, toDrop, killer, victim, limit, playSound);
}
/**
* Distributes items to players equally
* @param players the players to whom the items will be distributed
* @param items the items to distribute
* @param killer the one who "kills" the victim
* @param victim the character that "dropped" the item
* @param limit the limit what single player can have of each item
* @param playSound if to play sound if a player gets at least one item
* @param smartDrop true if to not calculate a drop, which can't be given to any player
* @return the counts of each items given to each player
*/
protected static Map<L2PcInstance, Map<Integer, Long>> distributeItems(Collection<L2PcInstance> players, final GroupedGeneralDropItem items, L2Character killer, L2Character victim, Map<Integer, Long> limit, boolean playSound, boolean smartDrop)
{
return distributeItems(players, items, killer, victim, Util.mapToFunction(limit), playSound, smartDrop);
}
/**
* Distributes items to players equally
* @param players the players to whom the items will be distributed
* @param items the items to distribute
* @param killer the one who "kills" the victim
* @param victim the character that "dropped" the item
* @param limit the limit what single player can have of each item
* @param playSound if to play sound if a player gets at least one item
* @param smartDrop true if to not calculate a drop, which can't be given to any player
* @return the counts of each items given to each player
*/
protected static Map<L2PcInstance, Map<Integer, Long>> distributeItems(Collection<L2PcInstance> players, final GroupedGeneralDropItem items, L2Character killer, L2Character victim, long limit, boolean playSound, boolean smartDrop)
{
return distributeItems(players, items, killer, victim, t -> limit, playSound, smartDrop);
}
/**
* @param players
* @param items
* @param limit
* @return
*/
private static Map<L2PcInstance, Map<Integer, Long>> calculateDistribution(Collection<L2PcInstance> players, Collection<ItemHolder> items, Function<Integer, Long> limit)
{
Map<L2PcInstance, Map<Integer, Long>> rewardedCounts = new HashMap<>();
for (L2PcInstance player : players)
{
rewardedCounts.put(player, new HashMap<Integer, Long>());
}
NEXT_ITEM: for (ItemHolder item : items)
{
long equaldist = item.getCount() / players.size();
long randomdist = item.getCount() % players.size();
List<L2PcInstance> toDist = new ArrayList<>(players);
do // this must happen at least once in order to get away already full players (and then equaldist can become nonzero)
{
for (Iterator<L2PcInstance> it = toDist.iterator(); it.hasNext();)
{
L2PcInstance player = it.next();
if (!rewardedCounts.get(player).containsKey(item.getId()))
{
rewardedCounts.get(player).put(item.getId(), 0L);
}
long maxGive = avoidNull(limit, item.getId()) - player.getInventory().getInventoryItemCount(item.getId(), -1, true) - rewardedCounts.get(player).get(item.getId());
long toGive = equaldist;
if (equaldist >= maxGive)
{
toGive = maxGive;
randomdist += (equaldist - maxGive); // overflown items are available to next players
it.remove(); // this player is already full
}
rewardedCounts.get(player).put(item.getId(), rewardedCounts.get(player).get(item.getId()) + toGive);
}
if (toDist.isEmpty())
{
// there's no one to give items anymore, all players will be full when we give the items
continue NEXT_ITEM;
}
equaldist = randomdist / toDist.size(); // the rest of items may be allowed to be equally distributed between remaining players
randomdist %= toDist.size();
}
while (equaldist > 0);
while (randomdist > 0)
{
if (toDist.isEmpty())
{
// we don't have any player left
continue NEXT_ITEM;
}
L2PcInstance player = toDist.get(getRandom(toDist.size()));
// avoid null return
long maxGive = avoidNull(limit, item.getId()) - limit.apply(item.getId()) - player.getInventory().getInventoryItemCount(item.getId(), -1, true) - rewardedCounts.get(player).get(item.getId());
if (maxGive > 0)
{
// we can add an item to player
// so we add one item to player
rewardedCounts.get(player).put(item.getId(), rewardedCounts.get(player).get(item.getId()) + 1);
randomdist--;
}
toDist.remove(player); // Either way this player isn't allowable for next random award
}
}
return rewardedCounts;
}
/**
* This function is for avoidance null returns in function limits
* @param <T> the type of function arg
* @param function the function
* @param arg the argument
* @return {@link Long#MAX_VALUE} if function.apply(arg) is null, function.apply(arg) otherwise
*/
private static <T> long avoidNull(Function<T, Long> function, T arg)
{
Long longLimit = function.apply(arg);
return longLimit == null ? Long.MAX_VALUE : longLimit;
}
/**
* Distributes items to players
* @param rewardedCounts A scheme of distribution items (the structure is: Map<player Map<itemId, count>>)
* @param playSound if to play sound if a player gets at least one item
*/
private static void giveItems(Map<L2PcInstance, Map<Integer, Long>> rewardedCounts, boolean playSound)
{
for (Entry<L2PcInstance, Map<Integer, Long>> entry : rewardedCounts.entrySet())
{
L2PcInstance player = entry.getKey();
boolean playPlayerSound = false;
for (Entry<Integer, Long> item : entry.getValue().entrySet())
{
if (item.getValue() >= 0)
{
playPlayerSound = true;
giveItems(player, item.getKey(), item.getValue());
}
}
if (playSound && playPlayerSound)
{
playSound(player, QuestSound.ITEMSOUND_QUEST_ITEMGET);
}
}
}
/**
* Take an amount of a specified item from player's inventory.
* @param player the player whose item to take

8
trunk/java/com/l2jserver/gameserver/model/itemcontainer/ItemContainer.java
View File

@ -239,10 +239,6 @@ public abstract class ItemContainer
// Updates database
float adenaRate = Config.RATE_DROP_AMOUNT_MULTIPLIER.getOrDefault(Inventory.ADENA_ID, 1f);
if (actor.hasPremiumStatus() && Config.PREMIUM_RATE_DROP_AMOUNT_BY_ID.containsKey(Inventory.ADENA_ID))
{
adenaRate *= Config.PREMIUM_RATE_DROP_AMOUNT_BY_ID.get(Inventory.ADENA_ID);
}
if ((item.getId() == Inventory.ADENA_ID) && (count < (10000 * adenaRate)))
{
// Small adena changes won't be saved to database all the time
@ -295,10 +291,6 @@ public abstract class ItemContainer
// Updates database
// If Adena drop rate is not present it will be x1.
float adenaRate = Config.RATE_DROP_AMOUNT_MULTIPLIER.getOrDefault(Inventory.ADENA_ID, 1f);
if (actor.hasPremiumStatus() && Config.PREMIUM_RATE_DROP_AMOUNT_BY_ID.containsKey(Inventory.ADENA_ID))
{
adenaRate *= Config.PREMIUM_RATE_DROP_AMOUNT_BY_ID.get(Inventory.ADENA_ID);
}
if ((itemId == Inventory.ADENA_ID) && (count < (10000 * adenaRate)))
{
// Small adena changes won't be saved to database all the time

25
trunk/java/com/l2jserver/gameserver/model/itemcontainer/Mail.java
View File

@ -25,6 +25,7 @@ import java.util.logging.Level;
import com.l2jserver.L2DatabaseFactory;
import com.l2jserver.gameserver.enums.ItemLocation;
import com.l2jserver.gameserver.idfactory.IdFactory;
import com.l2jserver.gameserver.model.L2World;
import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
import com.l2jserver.gameserver.model.items.instance.L2ItemInstance;
@ -108,19 +109,10 @@ public class Mail extends ItemContainer
item.setItemLocation(getBaseLocation(), _messageId);
}
/*
* Allow saving of the items without owner
*/
@Override
public void updateDatabase()
{
for (L2ItemInstance item : _items)
{
if (item != null)
{
item.updateDatabase(true);
}
}
_items.forEach(i -> i.updateDatabase(true));
}
@Override
@ -168,4 +160,17 @@ public class Mail extends ItemContainer
{
return _ownerId;
}
@Override
public void deleteMe()
{
_items.forEach(i ->
{
i.updateDatabase(true);
i.deleteMe();
L2World.getInstance().removeObject(i);
IdFactory.getInstance().releaseId(i.getObjectId());
});
_items.clear();
}
}

2
trunk/java/com/l2jserver/gameserver/model/items/instance/L2ItemInstance.java
View File

@ -1462,7 +1462,7 @@ public final class L2ItemInstance extends L2Object
/**
* Updates the database.<BR>
* @param force if the update should necessarilly be done.
* @param force if the update should necessarily be done.
*/
public void updateDatabase(boolean force)
{