PaperMC/Spigot-Server-Patches/0235-Configurable-Alternative-LootPool-Luck-Formula.patch
Spottedleaf 5c7081fecc Update upstream & fix some chunk related issues (#2177)
* Updated Upstream (Bukkit/CraftBukkit)

Upstream has released updates that appears to apply and compile correctly.
This update has not been tested by PaperMC and as with ANY update, please do your own testing

Bukkit Changes:
45690fe9 SPIGOT-5047: Correct slot types for 1.14 inventories

CraftBukkit Changes:
4090d01f SPIGOT-5047: Correct slot types for 1.14 inventories
e8c08362 SPIGOT-5046: World#getLoadedChunks returning inaccessible cached chunks.
d445af3b SPIGOT-5067: Add item meta for 1.14 spawn eggs

* Bring Chunk load checks in-line with spigot

As of the last upstream merge spigot now checks ticket level status
when returning loaded chunks for a world from api. Now our checks
will respect that decision.

* Fix spawn ticket levels

Vanilla would keep the inner chunks of spawn available for ticking,
however my changes made all chunks non-ticking. Resolve by changing
ticket levels for spawn chunks inside the border to respect this
behavior.


* Make World#getChunkIfLoadedImmediately return only entity ticking chunks

Mojang appears to be using chunks with level > 33 (non-ticking chunks)
as cached chunks and not actually loaded chunks.

* Bring all loaded checks in line with spigot

Loaded chunks must be at least border  chunks, or level <= 33
2019-06-14 03:27:40 +01:00

113 lines
4.7 KiB
Diff

From 9b22bb2970ca9180368fad766e58ffcfc3029c26 Mon Sep 17 00:00:00 2001
From: Aikar <aikar@aikar.co>
Date: Fri, 15 Jun 2018 00:30:32 -0400
Subject: [PATCH] Configurable Alternative LootPool Luck Formula
Rewrites the Vanilla luck application formula so that luck can be
applied to items that do not have any quality defined.
See: https://luckformula.emc.gs for data and details
-----------
The rough summary is:
My goal was that in a pool, when luck was applied, the pool
rebalances so the percentages for bigger items is
lowered and smaller items is boosted.
Do this by boosting and then reducing the weight value,
so that larger numbers are penalized more than smaller numbers.
resulting in a larger reduction of entries for more common
items than the reduction on small weights,
giving smaller weights more of a chance
-----------
This work kind of obsoletes quality, but quality would be useful
for 2 items with same weight that you want luck to impact
in varying directions.
Fishing still falls into that as the weights are closer, so luck
will invalidate junk more.
This change will result in some major changes to fishing formulas.
-----------
I would love to see this change in Vanilla, so Mojang please pull :)
diff --git a/src/main/java/com/destroystokyo/paper/PaperConfig.java b/src/main/java/com/destroystokyo/paper/PaperConfig.java
index a186b6eb01..a9b71c85d5 100644
--- a/src/main/java/com/destroystokyo/paper/PaperConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperConfig.java
@@ -279,4 +279,12 @@ public class PaperConfig {
"such as inventories, experience points, advancements and the like will not be saved when they log out.");
}
}
+
+ public static boolean useAlternativeLuckFormula = false;
+ private static void useAlternativeLuckFormula() {
+ useAlternativeLuckFormula = getBoolean("settings.use-alternative-luck-formula", false);
+ if (useAlternativeLuckFormula) {
+ Bukkit.getLogger().log(Level.INFO, "Using Aikar's Alternative Luck Formula to apply Luck attribute to all loot pool calculations. See https://luckformula.emc.gs");
+ }
+ }
}
diff --git a/src/main/java/net/minecraft/server/LootSelectorEntry.java b/src/main/java/net/minecraft/server/LootSelectorEntry.java
index 1016325bd7..2c979e0b74 100644
--- a/src/main/java/net/minecraft/server/LootSelectorEntry.java
+++ b/src/main/java/net/minecraft/server/LootSelectorEntry.java
@@ -13,8 +13,8 @@ import org.apache.commons.lang3.ArrayUtils;
public abstract class LootSelectorEntry extends LootEntryAbstract {
- protected final int e;
- protected final int f;
+ protected final int e; public int getWeight() { return e; } // Paper - OBFHELPER
+ protected final int f; public int getQuality() { return f; } // Paper - OBFHELPER
protected final LootItemFunction[] g;
private final BiFunction<ItemStack, LootTableInfo, ItemStack> c;
private final LootEntry h = new LootSelectorEntry.c() {
@@ -147,11 +147,38 @@ public abstract class LootSelectorEntry extends LootEntryAbstract {
public abstract class c implements LootEntry {
- protected c() {}
+ protected c() {
+ }
@Override
public int a(float f) {
- return Math.max(MathHelper.d((float) LootSelectorEntry.this.e + (float) LootSelectorEntry.this.f * f), 0);
+ // Paper start - Offer an alternative loot formula to refactor how luck bonus applies
+ // SEE: https://luckformula.emc.gs for details and data
+ if (lastLuck != null && lastLuck == f) {
+ return lastWeight;
+ }
+ // This is vanilla
+ float qualityModifer = (float) getQuality() * f;
+ double baseWeight = (getWeight() + qualityModifer);
+ if (com.destroystokyo.paper.PaperConfig.useAlternativeLuckFormula) {
+ // Random boost to avoid losing precision in the final int cast on return
+ final int weightBoost = 100;
+ baseWeight *= weightBoost;
+ // If we have vanilla 1, bump that down to 0 so nothing is is impacted
+ // vanilla 3 = 300, 200 basis = impact 2%
+ // =($B2*(($B2-100)/100/100))
+ double impacted = baseWeight * ((baseWeight - weightBoost) / weightBoost / 100);
+ // =($B$7/100)
+ float luckModifier = Math.min(100, f * 10) / 100;
+ // =B2 - (C2 *($B$7/100))
+ baseWeight = Math.ceil(baseWeight - (impacted * luckModifier));
+ }
+ lastLuck = f;
+ lastWeight = (int) Math.max(0, Math.floor(baseWeight));
+ return lastWeight;
}
}
+ private Float lastLuck = null;
+ private int lastWeight = 0;
+ // Paper end
}
--
2.21.0