Share L2JSERVER MOST PRECISE DROP STRATEGY

[Cherish]

On 5/3/2021 at 2:29 PM, Porthos said:

Cherish threw a fit because he wanted credits for 4 lines of code, not to mention he was continuously derailing discussions offtopic because he was going into opinionated tangents about random things. The credits thing was the worst fit ive seen him throw and im not surprised he got booted from the discord for that.

L2JServer has certain criteria about giving credits which you can read here: https://www.l2jserver.com/forum/viewtopic.php?f=29&t=30453&p=182222#p182580

Based on these rules did he deserve credits other than in the commit comment? That's for each one of you to decide.

 

Also theres no randoms taking over L2JServer, if anything the new team members have brought the pack back to life. Theres a lot of cool shit coming like complete High Five Skills with proper handlers and a targeting rework that both will address a lot of issues.

 

Generally i see a lot of ego from people involved in the l2j scene, this needs to stop unless you like to be paying hundreds of dollars or euros for subpar work.

Here you go. You can change it into double and push to main branch.
I have already asked for more appropriate way to present my work.

What if is ego? Say I've "learned" java, got familiar with project enough to fix a broken drop calc, present for many years, with close to none assistance and I have shared it, if not for money, what's left?

If you can not appreciate my effort to give it few bytes of credits that is not being compiled, then users should apply patch manually on demand, found here.

After all, this is a custom feature for a custom drop on a custom rate and L2JServer focuses on "Retail" behavior and code does not take part of main branch.
 

 

 

/*
 * Copyright © 2004-2021 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.commons.util.Rnd;
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;

/**
 *@author Battlecruiser, Cherish
 */

public interface IGroupedItemDropCalculationStrategy {
	/**
	 * L2J Server most percise drop calculation when group chances are over one houdred percent.
	 */
	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()) {
					totalChance += item2.getChance();
					if (totalChance > random) {
						int amountMultiply = 1;
						if (dropItem.isPreciseCalculated() && normalized.getChance() > 100) {
							int MostPreciseFormula = 0;
							MostPreciseFormula += item2.getChance() * (normalized.getChance() / 100);
							if (MostPreciseFormula >= 100) {
								amountMultiply = (int) MostPreciseFormula / 100;
								if ((MostPreciseFormula % 100) > (Rnd.nextDouble() * 100)) {
									amountMultiply++;
								}
							}
						}	
						return Collections.singletonList(new ItemHolder(item2.getItemId(), Rnd.get(item2.getMin(victim), item2.getMax(victim)) * amountMultiply));
					}
				}
			}
			return null;
		}
	};
	
	/**
	 * This strategy calculates a group's drop by calculating drops of its individual items and merging its results.
	 */
	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.
	 */
	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;
	};
	
	List<ItemHolder> calculateDrops(GroupedGeneralDropItem item, L2Character victim, L2Character killer);
}

 

Edited September 4, 2022 by Cherish

[the0ffspring]

Many applauds for L2JServer!

Edited September 4, 2022 by the0ffspring

[ZaNteR]

39 minutes ago, the0ffspring said:

Many applauds for L2JServer!

Isnt it you bedtime? Why are you necroposting?

[Cherish]

The people that are killing L2JServer must be publicly exposed.
I've shared with you Improved Crystal Caverns and Precision Formula.
In return all I received was disrespect and humiliation?
Well, that was the last of me for the true open source L2JServer.

Have fun copycats!

 

Edited September 4, 2022 by Cherish

[arm4729]

[barao45]

Hi people. Does anybody solved this formula?. I found that this is not exact with drops groups. I have for example 100% drop on a mob but is not 100% really. If i add a item drop outside of any group it's drops 100%