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

Project update.

Browse Source
This commit is contained in:
MobiusDev
2015-12-31 23:53:41 +00:00
parent e0d681a17e
commit ad2bcd79be
4084 changed files with 83696 additions and 86998 deletions
Download Patch File Download Diff File Expand all files Collapse all files

65
trunk/java/com/l2jmobius/gameserver/model/drops/strategy/IAmountMultiplierStrategy.java Normal file
View File

@ -0,0 +1,65 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package com.l2jmobius.gameserver.model.drops.strategy;
import com.l2jmobius.Config;
import com.l2jmobius.gameserver.datatables.ItemTable;
import com.l2jmobius.gameserver.model.actor.L2Character;
import com.l2jmobius.gameserver.model.drops.GeneralDropItem;
import com.l2jmobius.gameserver.model.itemcontainer.Inventory;
/**
* @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) -> 1;
public static IAmountMultiplierStrategy DEFAULT_STRATEGY(final double defaultMultiplier)
{
return (item, victim) ->
{
double multiplier = 1;
if (victim.isChampion())
{
multiplier *= item.getItemId() != Inventory.ADENA_ID ? Config.L2JMOD_CHAMPION_REWARDS_AMOUNT : Config.L2JMOD_CHAMPION_ADENAS_REWARDS_AMOUNT;
}
final Float dropAmountMultiplier = Config.RATE_DROP_AMOUNT_MULTIPLIER.get(item.getItemId());
if (dropAmountMultiplier != null)
{
multiplier *= dropAmountMultiplier;
}
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
{
multiplier *= defaultMultiplier;
}
return multiplier;
};
}
public double getAmountMultiplier(GeneralDropItem item, L2Character victim);
}

80
trunk/java/com/l2jmobius/gameserver/model/drops/strategy/IChanceMultiplierStrategy.java Normal file
View File

@ -0,0 +1,80 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package com.l2jmobius.gameserver.model.drops.strategy;
import com.l2jmobius.Config;
import com.l2jmobius.gameserver.datatables.ItemTable;
import com.l2jmobius.gameserver.model.actor.L2Character;
import com.l2jmobius.gameserver.model.drops.GeneralDropItem;
import com.l2jmobius.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) -> 1;
public static final IChanceMultiplierStrategy QUEST = (item, victim) ->
{
double championmult;
if ((item.getItemId() == Inventory.ADENA_ID) || (item.getItemId() == Inventory.ANCIENT_ADENA_ID))
{
championmult = Config.L2JMOD_CHAMPION_ADENAS_REWARDS_CHANCE;
}
else
{
championmult = Config.L2JMOD_CHAMPION_REWARDS_CHANCE;
}
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) ->
{
float multiplier = 1;
if (victim.isChampion())
{
multiplier *= item.getItemId() != Inventory.ADENA_ID ? Config.L2JMOD_CHAMPION_REWARDS_CHANCE : Config.L2JMOD_CHAMPION_ADENAS_REWARDS_CHANCE;
}
final Float dropChanceMultiplier = Config.RATE_DROP_CHANCE_MULTIPLIER.get(item.getItemId());
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
{
multiplier *= defaultMultiplier;
}
return multiplier;
};
}
public double getChanceMultiplier(GeneralDropItem item, L2Character victim);
}

54
trunk/java/com/l2jmobius/gameserver/model/drops/strategy/IDropCalculationStrategy.java Normal file
View File

@ -0,0 +1,54 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package com.l2jmobius.gameserver.model.drops.strategy;
import java.util.Collections;
import java.util.List;
import com.l2jmobius.gameserver.model.actor.L2Character;
import com.l2jmobius.gameserver.model.drops.GeneralDropItem;
import com.l2jmobius.gameserver.model.holders.ItemHolder;
import com.l2jmobius.util.Rnd;
/**
* @author Battlecruiser
*/
public interface IDropCalculationStrategy
{
public static final IDropCalculationStrategy DEFAULT_STRATEGY = (item, victim, killer) ->
{
final 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);
}

130
trunk/java/com/l2jmobius/gameserver/model/drops/strategy/IGroupedItemDropCalculationStrategy.java Normal file
View File

@ -0,0 +1,130 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package com.l2jmobius.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.l2jmobius.gameserver.model.actor.L2Character;
import com.l2jmobius.gameserver.model.drops.GeneralDropItem;
import com.l2jmobius.gameserver.model.drops.GroupedGeneralDropItem;
import com.l2jmobius.gameserver.model.drops.IDropItem;
import com.l2jmobius.gameserver.model.holders.ItemHolder;
import com.l2jmobius.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);
}
final 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 += Math.sqrt(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) ->
{
final 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);
}
final GroupedGeneralDropItem newItem = new GroupedGeneralDropItem(item.getChance(), DEFAULT_STRATEGY, item.getKillerChanceModifierStrategy(), IPreciseDeterminationStrategy.NEVER);
newItem.setItems(item.getItems());
final 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++;
}
final 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);
}

68
trunk/java/com/l2jmobius/gameserver/model/drops/strategy/IKillerChanceModifierStrategy.java Normal file
View File

@ -0,0 +1,68 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package com.l2jmobius.gameserver.model.drops.strategy;
import com.l2jmobius.Config;
import com.l2jmobius.gameserver.model.actor.L2Character;
import com.l2jmobius.gameserver.model.drops.GeneralDropItem;
import com.l2jmobius.gameserver.model.drops.IDropItem;
import com.l2jmobius.gameserver.model.itemcontainer.Inventory;
import com.l2jmobius.gameserver.util.Util;
/**
* @author Battlecruiser
*/
public interface IKillerChanceModifierStrategy extends INonGroupedKillerChanceModifierStrategy
{
public static final IKillerChanceModifierStrategy DEFAULT_STRATEGY = (item, victim, killer) ->
{
final 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))
{
final 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);
}
}

28
trunk/java/com/l2jmobius/gameserver/model/drops/strategy/INonGroupedKillerChanceModifierStrategy.java Normal file
View File

@ -0,0 +1,28 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package com.l2jmobius.gameserver.model.drops.strategy;
import com.l2jmobius.gameserver.model.actor.L2Character;
import com.l2jmobius.gameserver.model.drops.GeneralDropItem;
/**
* @author Battlecruiser
*/
public interface INonGroupedKillerChanceModifierStrategy
{
public double getKillerChanceModifier(GeneralDropItem item, L2Character victim, L2Character killer);
}

38
trunk/java/com/l2jmobius/gameserver/model/drops/strategy/IPreciseDeterminationStrategy.java Normal file
View File

@ -0,0 +1,38 @@
/*
* This file is part of the L2J Mobius project.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package com.l2jmobius.gameserver.model.drops.strategy;
import com.l2jmobius.Config;
import com.l2jmobius.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);
}