2018-12-23 18:04:13 +01:00
From 33e61dd190f6ec4964e57784f282124f44568536 Mon Sep 17 00:00:00 2001
2016-05-02 05:54:08 +02:00
From: Aikar <aikar@aikar.co>
Date: Sun, 1 May 2016 21:19:14 -0400
Subject: [PATCH] LootTable API & Replenishable Lootables Feature
Provides an API to control the loot table for an object.
Also provides a feature that any Lootable Inventory (Chests in Structures)
can automatically replenish after a given time.
This feature is good for long term worlds so that newer players
do not suffer with "Every chest has been looted"
diff --git a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
2018-12-13 01:40:29 +01:00
index 7c7d5595a..00f0451ef 100644
2016-05-02 05:54:08 +02:00
--- a/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
+++ b/src/main/java/com/destroystokyo/paper/PaperWorldConfig.java
2018-12-13 01:40:29 +01:00
@@ -270,4 +270,26 @@ public class PaperWorldConfig {
2016-05-02 05:54:08 +02:00
this.frostedIceDelayMax = this.getInt("frosted-ice.delay.max", this.frostedIceDelayMax);
2017-03-25 04:18:58 +01:00
log("Frosted Ice: " + (this.frostedIceEnabled ? "enabled" : "disabled") + " / delay: min=" + this.frostedIceDelayMin + ", max=" + this.frostedIceDelayMax);
2016-05-02 05:54:08 +02:00
}
+
+ public boolean autoReplenishLootables;
+ public boolean restrictPlayerReloot;
+ public boolean changeLootTableSeedOnFill;
+ public int maxLootableRefills;
+ public int lootableRegenMin;
+ public int lootableRegenMax;
+ private void enhancedLootables() {
+ autoReplenishLootables = getBoolean("lootables.auto-replenish", false);
+ restrictPlayerReloot = getBoolean("lootables.restrict-player-reloot", true);
+ changeLootTableSeedOnFill = getBoolean("lootables.reset-seed-on-fill", true);
+ maxLootableRefills = getInt("lootables.max-refills", -1);
+ lootableRegenMin = PaperConfig.getSeconds(getString("lootables.refresh-min", "12h"));
+ lootableRegenMax = PaperConfig.getSeconds(getString("lootables.refresh-max", "2d"));
+ if (autoReplenishLootables) {
+ log("Lootables: Replenishing every " +
+ PaperConfig.timeSummary(lootableRegenMin) + " to " +
+ PaperConfig.timeSummary(lootableRegenMax) +
+ (restrictPlayerReloot ? " (restricting reloot)" : "")
+ );
+ }
+ }
}
2018-08-26 20:11:49 +02:00
diff --git a/src/main/java/com/destroystokyo/paper/loottable/PaperLootableBlockInventory.java b/src/main/java/com/destroystokyo/paper/loottable/PaperLootableBlockInventory.java
2016-05-02 05:54:08 +02:00
new file mode 100644
2018-12-13 01:40:29 +01:00
index 000000000..d6fce3112
2016-05-02 05:54:08 +02:00
--- /dev/null
2018-08-26 20:11:49 +02:00
+++ b/src/main/java/com/destroystokyo/paper/loottable/PaperLootableBlockInventory.java
2016-05-08 03:16:38 +02:00
@@ -0,0 +1,33 @@
2016-05-02 05:54:08 +02:00
+package com.destroystokyo.paper.loottable;
+
+import net.minecraft.server.BlockPosition;
+import net.minecraft.server.TileEntityLootable;
+import net.minecraft.server.World;
+import org.bukkit.Chunk;
+import org.bukkit.block.Block;
+
2018-08-26 20:11:49 +02:00
+public interface PaperLootableBlockInventory extends LootableBlockInventory, PaperLootableInventory {
2016-05-02 05:54:08 +02:00
+
+ TileEntityLootable getTileEntity();
+
+ @Override
2016-05-08 03:16:38 +02:00
+ default LootableInventory getAPILootableInventory() {
+ return this;
+ }
+
+ @Override
2016-05-02 05:54:08 +02:00
+ default World getNMSWorld() {
+ return getTileEntity().getWorld();
+ }
+
+ default Block getBlock() {
+ final BlockPosition position = getTileEntity().getPosition();
+ final Chunk bukkitChunk = getTileEntity().getWorld().getChunkAtWorldCoords(position).bukkitChunk;
+ return bukkitChunk.getBlock(position.getX(), position.getY(), position.getZ());
+ }
+
+ @Override
2018-08-26 20:11:49 +02:00
+ default PaperLootableInventoryData getLootableData() {
+ return getTileEntity().lootableData;
2016-05-02 05:54:08 +02:00
+ }
+}
2018-08-26 20:11:49 +02:00
diff --git a/src/main/java/com/destroystokyo/paper/loottable/PaperLootableEntityInventory.java b/src/main/java/com/destroystokyo/paper/loottable/PaperLootableEntityInventory.java
2016-05-02 05:54:08 +02:00
new file mode 100644
2018-12-13 01:40:29 +01:00
index 000000000..5e637782d
2016-05-02 05:54:08 +02:00
--- /dev/null
2018-08-26 20:11:49 +02:00
+++ b/src/main/java/com/destroystokyo/paper/loottable/PaperLootableEntityInventory.java
@@ -0,0 +1,28 @@
2016-05-02 05:54:08 +02:00
+package com.destroystokyo.paper.loottable;
+
+import net.minecraft.server.World;
+import org.bukkit.entity.Entity;
+
2018-08-26 20:11:49 +02:00
+public interface PaperLootableEntityInventory extends LootableEntityInventory, PaperLootableInventory {
2016-05-02 05:54:08 +02:00
+
+ net.minecraft.server.Entity getHandle();
+
2016-05-08 03:16:38 +02:00
+ @Override
+ default LootableInventory getAPILootableInventory() {
+ return this;
+ }
+
2016-05-02 05:54:08 +02:00
+ default Entity getEntity() {
+ return getHandle().getBukkitEntity();
+ }
+
+ @Override
+ default World getNMSWorld() {
+ return getHandle().getWorld();
+ }
+
+ @Override
2018-08-26 20:11:49 +02:00
+ default PaperLootableInventoryData getLootableData() {
+ return getHandle().lootableData;
2016-05-02 05:54:08 +02:00
+ }
+}
2018-08-26 20:11:49 +02:00
diff --git a/src/main/java/com/destroystokyo/paper/loottable/PaperLootableInventory.java b/src/main/java/com/destroystokyo/paper/loottable/PaperLootableInventory.java
2016-05-02 05:54:08 +02:00
new file mode 100644
2018-12-13 01:40:29 +01:00
index 000000000..856843fc9
2016-05-02 05:54:08 +02:00
--- /dev/null
2018-08-26 20:11:49 +02:00
+++ b/src/main/java/com/destroystokyo/paper/loottable/PaperLootableInventory.java
@@ -0,0 +1,71 @@
2016-05-02 05:54:08 +02:00
+package com.destroystokyo.paper.loottable;
+
2018-08-26 20:11:49 +02:00
+import net.minecraft.server.World;
+import org.bukkit.loot.Lootable;
+
2016-05-02 05:54:08 +02:00
+import java.util.UUID;
+
2018-08-26 20:11:49 +02:00
+public interface PaperLootableInventory extends LootableInventory, Lootable {
2016-05-02 05:54:08 +02:00
+
2018-08-26 20:11:49 +02:00
+ PaperLootableInventoryData getLootableData();
2016-05-08 03:16:38 +02:00
+ LootableInventory getAPILootableInventory();
2016-05-02 05:54:08 +02:00
+
2018-08-26 20:11:49 +02:00
+ World getNMSWorld();
+
+ default org.bukkit.World getBukkitWorld() {
+ return getNMSWorld().getWorld();
+ }
+
2016-05-02 05:54:08 +02:00
+ @Override
+ default boolean isRefillEnabled() {
+ return getNMSWorld().paperConfig.autoReplenishLootables;
+ }
+
+ @Override
+ default boolean hasBeenFilled() {
+ return getLastFilled() != -1;
+ }
+
+ @Override
+ default boolean hasPlayerLooted(UUID player) {
+ return getLootableData().hasPlayerLooted(player);
+ }
+
+ @Override
+ default Long getLastLooted(UUID player) {
+ return getLootableData().getLastLooted(player);
+ }
+
+ @Override
+ default boolean setHasPlayerLooted(UUID player, boolean looted) {
+ final boolean hasLooted = hasPlayerLooted(player);
+ if (hasLooted != looted) {
+ getLootableData().setPlayerLootedState(player, looted);
+ }
+ return hasLooted;
+ }
+
+ @Override
+ default boolean hasPendingRefill() {
+ long nextRefill = getLootableData().getNextRefill();
+ return nextRefill != -1 && nextRefill > getLootableData().getLastFill();
+ }
+
+ @Override
+ default long getLastFilled() {
+ return getLootableData().getLastFill();
+ }
+
+ @Override
+ default long getNextRefill() {
+ return getLootableData().getNextRefill();
+ }
+
+ @Override
+ default long setNextRefill(long refillAt) {
+ if (refillAt < -1) {
+ refillAt = -1;
+ }
+ return getLootableData().setNextRefill(refillAt);
+ }
+}
2018-08-26 20:11:49 +02:00
diff --git a/src/main/java/com/destroystokyo/paper/loottable/PaperLootableInventoryData.java b/src/main/java/com/destroystokyo/paper/loottable/PaperLootableInventoryData.java
2016-05-02 05:54:08 +02:00
new file mode 100644
2018-12-13 01:40:29 +01:00
index 000000000..6e17af86a
2016-05-02 05:54:08 +02:00
--- /dev/null
2018-08-26 20:11:49 +02:00
+++ b/src/main/java/com/destroystokyo/paper/loottable/PaperLootableInventoryData.java
2018-08-12 19:11:08 +02:00
@@ -0,0 +1,179 @@
2016-05-02 05:54:08 +02:00
+package com.destroystokyo.paper.loottable;
+
+import com.destroystokyo.paper.PaperWorldConfig;
+import net.minecraft.server.*;
+import org.bukkit.entity.Player;
2018-08-12 19:11:08 +02:00
+import org.bukkit.loot.LootTable;
2016-05-02 05:54:08 +02:00
+
2016-05-12 04:07:46 +02:00
+import javax.annotation.Nullable;
2016-05-02 05:54:08 +02:00
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Random;
+import java.util.UUID;
+
2018-08-26 20:11:49 +02:00
+public class PaperLootableInventoryData {
2016-05-02 05:54:08 +02:00
+
+ private static final Random RANDOM = new Random();
+
+ private long lastFill = -1;
+ private long nextRefill = -1;
+ private int numRefills = 0;
+ private Map<UUID, Long> lootedPlayers;
2018-08-26 20:11:49 +02:00
+ private final PaperLootableInventory lootable;
2016-05-02 05:54:08 +02:00
+
2018-08-26 20:11:49 +02:00
+ public PaperLootableInventoryData(PaperLootableInventory lootable) {
2016-05-02 05:54:08 +02:00
+ this.lootable = lootable;
+ }
+
+ long getLastFill() {
+ return this.lastFill;
+ }
+
+ long getNextRefill() {
+ return this.nextRefill;
+ }
+
+ long setNextRefill(long nextRefill) {
+ long prev = this.nextRefill;
+ this.nextRefill = nextRefill;
+ return prev;
+ }
+
2016-05-12 04:07:46 +02:00
+ public boolean shouldReplenish(@Nullable EntityHuman player) {
2018-08-12 19:11:08 +02:00
+ LootTable table = this.lootable.getLootTable();
2016-05-02 05:54:08 +02:00
+
+ // No Loot Table associated
2018-08-12 19:11:08 +02:00
+ if (table == null) {
2016-05-02 05:54:08 +02:00
+ return false;
+ }
+
+ // ALWAYS process the first fill
+ if (this.lastFill == -1) {
+ return true;
+ }
+
+ // Only process refills when a player is set
+ if (player == null) {
+ return false;
+ }
+
+ // Chest is not scheduled for refill
+ if (this.nextRefill == -1) {
+ return false;
+ }
+
+ final PaperWorldConfig paperConfig = this.lootable.getNMSWorld().paperConfig;
+
+ // Check if max refills has been hit
+ if (paperConfig.maxLootableRefills != -1 && this.numRefills >= paperConfig.maxLootableRefills) {
+ return false;
+ }
+
+ // Refill has not been reached
+ if (this.nextRefill > System.currentTimeMillis()) {
+ return false;
+ }
+
+
+ final Player bukkitPlayer = (Player) player.getBukkitEntity();
2016-05-08 03:16:38 +02:00
+ LootableInventoryReplenishEvent event = new LootableInventoryReplenishEvent(bukkitPlayer, lootable.getAPILootableInventory());
2016-05-02 05:54:08 +02:00
+ if (paperConfig.restrictPlayerReloot && hasPlayerLooted(player.getUniqueID())) {
+ event.setCancelled(true);
+ }
+ return event.callEvent();
+ }
2016-05-15 08:41:36 +02:00
+ public void processRefill(@Nullable EntityHuman player) {
2016-05-02 05:54:08 +02:00
+ this.lastFill = System.currentTimeMillis();
+ final PaperWorldConfig paperConfig = this.lootable.getNMSWorld().paperConfig;
+ if (paperConfig.autoReplenishLootables) {
2018-06-13 20:15:31 +02:00
+ int min = paperConfig.lootableRegenMin;
+ int max = paperConfig.lootableRegenMax;
+ this.nextRefill = this.lastFill + (min + RANDOM.nextInt(max - min + 1)) * 1000L;
2016-05-02 05:54:08 +02:00
+ this.numRefills++;
+ if (paperConfig.changeLootTableSeedOnFill) {
2018-08-26 20:11:49 +02:00
+ this.lootable.setSeed(0);
2016-05-02 05:54:08 +02:00
+ }
2016-05-15 08:41:36 +02:00
+ if (player != null) { // This means that numRefills can be incremented without a player being in the lootedPlayers list - Seems to be EntityMinecartChest specific
+ this.setPlayerLootedState(player.getUniqueID(), true);
+ }
2016-05-02 05:54:08 +02:00
+ } else {
+ this.lootable.clearLootTable();
+ }
+ }
+
+
+ public void loadNbt(NBTTagCompound base) {
+ if (!base.hasKeyOfType("Paper.LootableData", 10)) { // 10 = compound
+ return;
+ }
+ NBTTagCompound comp = base.getCompound("Paper.LootableData");
+ if (comp.hasKey("lastFill")) {
+ this.lastFill = comp.getLong("lastFill");
+ }
+ if (comp.hasKey("nextRefill")) {
+ this.nextRefill = comp.getLong("nextRefill");
+ }
+
+ if (comp.hasKey("numRefills")) {
+ this.numRefills = comp.getInt("numRefills");
+ }
+ if (comp.hasKeyOfType("lootedPlayers", 9)) { // 9 = list
+ NBTTagList list = comp.getList("lootedPlayers", 10); // 10 = compound
+ final int size = list.size();
+ if (size > 0) {
+ this.lootedPlayers = new HashMap<>(list.size());
+ }
+ for (int i = 0; i < size; i++) {
2018-07-16 17:34:55 +02:00
+ final NBTTagCompound cmp = list.getCompound(i);
2016-05-02 05:54:08 +02:00
+ lootedPlayers.put(cmp.getUUID("UUID"), cmp.getLong("Time"));
+ }
+ }
+ }
+ public void saveNbt(NBTTagCompound base) {
+ NBTTagCompound comp = new NBTTagCompound();
+ if (this.nextRefill != -1) {
+ comp.setLong("nextRefill", this.nextRefill);
+ }
+ if (this.lastFill != -1) {
+ comp.setLong("lastFill", this.lastFill);
+ }
+ if (this.numRefills != 0) {
+ comp.setInt("numRefills", this.numRefills);
+ }
+ if (this.lootedPlayers != null && !this.lootedPlayers.isEmpty()) {
+ NBTTagList list = new NBTTagList();
+ for (Map.Entry<UUID, Long> entry : this.lootedPlayers.entrySet()) {
+ NBTTagCompound cmp = new NBTTagCompound();
+ cmp.setUUID("UUID", entry.getKey());
+ cmp.setLong("Time", entry.getValue());
+ list.add(cmp);
+ }
+ comp.set("lootedPlayers", list);
+ }
+
+ if (!comp.isEmpty()) {
+ base.set("Paper.LootableData", comp);
+ }
+ }
+
+ void setPlayerLootedState(UUID player, boolean looted) {
+ if (looted && this.lootedPlayers == null) {
+ this.lootedPlayers = new HashMap<>();
+ }
+ if (looted) {
+ if (!this.lootedPlayers.containsKey(player)) {
+ this.lootedPlayers.put(player, System.currentTimeMillis());
+ }
+ } else if (this.lootedPlayers != null) {
+ this.lootedPlayers.remove(player);
+ }
+ }
+
+ boolean hasPlayerLooted(UUID player) {
+ return this.lootedPlayers != null && this.lootedPlayers.containsKey(player);
+ }
+
+ Long getLastLooted(UUID player) {
+ return lootedPlayers != null ? lootedPlayers.get(player) : null;
+ }
+}
2018-08-26 20:11:49 +02:00
diff --git a/src/main/java/com/destroystokyo/paper/loottable/PaperMinecartLootableInventory.java b/src/main/java/com/destroystokyo/paper/loottable/PaperMinecartLootableInventory.java
new file mode 100644
2018-12-13 01:40:29 +01:00
index 000000000..f9fbc221b
2018-08-26 20:11:49 +02:00
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/loottable/PaperMinecartLootableInventory.java
@@ -0,0 +1,64 @@
+package com.destroystokyo.paper.loottable;
+
+import net.minecraft.server.Entity;
+import net.minecraft.server.EntityMinecartContainer;
+import net.minecraft.server.MinecraftKey;
+import net.minecraft.server.World;
2018-08-12 19:11:08 +02:00
+import org.bukkit.Bukkit;
+import org.bukkit.craftbukkit.util.CraftNamespacedKey;
2018-08-26 20:11:49 +02:00
+
+public class PaperMinecartLootableInventory implements PaperLootableEntityInventory {
+
+ private EntityMinecartContainer entity;
+
+ public PaperMinecartLootableInventory(EntityMinecartContainer entity) {
+ this.entity = entity;
+ }
+
+ @Override
+ public org.bukkit.loot.LootTable getLootTable() {
+ return entity.getLootTableKey() != null ? Bukkit.getLootTable(CraftNamespacedKey.fromMinecraft(entity.getLootTableKey())) : null;
+ }
+
+ @Override
+ public void setLootTable(org.bukkit.loot.LootTable table, long seed) {
+ setLootTable(table);
+ setSeed(seed);
+ }
+
+ @Override
+ public void setSeed(long seed) {
+ entity.lootTableSeed = seed;
+ }
+
+ @Override
+ public long getSeed() {
+ return entity.lootTableSeed;
+ }
+
+ @Override
+ public void setLootTable(org.bukkit.loot.LootTable table) {
+ MinecraftKey newKey = (table == null) ? null : CraftNamespacedKey.toMinecraft(table.getKey());
+ entity.setLootTable(newKey);
+ }
+
+ @Override
+ public PaperLootableInventoryData getLootableData() {
+ return entity.lootableData;
+ }
+
+ @Override
+ public Entity getHandle() {
+ return entity;
+ }
+
+ @Override
+ public LootableInventory getAPILootableInventory() {
+ return (LootableInventory) entity.getBukkitEntity();
+ }
+
+ @Override
+ public World getNMSWorld() {
+ return entity.world;
+ }
+}
diff --git a/src/main/java/com/destroystokyo/paper/loottable/PaperTileEntityLootableInventory.java b/src/main/java/com/destroystokyo/paper/loottable/PaperTileEntityLootableInventory.java
new file mode 100644
2018-12-13 01:40:29 +01:00
index 000000000..d50410532
2018-08-26 20:11:49 +02:00
--- /dev/null
+++ b/src/main/java/com/destroystokyo/paper/loottable/PaperTileEntityLootableInventory.java
@@ -0,0 +1,67 @@
+package com.destroystokyo.paper.loottable;
+
+import net.minecraft.server.MCUtil;
+import net.minecraft.server.MinecraftKey;
+import net.minecraft.server.TileEntityLootable;
+import net.minecraft.server.World;
+import org.bukkit.Bukkit;
+import org.bukkit.craftbukkit.util.CraftNamespacedKey;
+
+public class PaperTileEntityLootableInventory implements PaperLootableBlockInventory {
+ private TileEntityLootable tileEntityLootable;
+
+ public PaperTileEntityLootableInventory(TileEntityLootable tileEntityLootable) {
+ this.tileEntityLootable = tileEntityLootable;
+ }
+
+ @Override
+ public org.bukkit.loot.LootTable getLootTable() {
+ return tileEntityLootable.getLootTableKey() != null ? Bukkit.getLootTable(CraftNamespacedKey.fromMinecraft(tileEntityLootable.getLootTableKey())) : null;
+ }
+
+ @Override
+ public void setLootTable(org.bukkit.loot.LootTable table, long seed) {
+ setLootTable(table);
+ setSeed(seed);
+ }
+
+ @Override
+ public void setLootTable(org.bukkit.loot.LootTable table) {
+ MinecraftKey newKey = (table == null) ? null : CraftNamespacedKey.toMinecraft(table.getKey());
+ tileEntityLootable.setLootTable(newKey);
+ }
+
+ @Override
+ public void setSeed(long seed) {
+ tileEntityLootable.setSeed(seed);
+ }
+
+ @Override
+ public long getSeed() {
+ return tileEntityLootable.getSeed();
+ }
+
+ @Override
+ public PaperLootableInventoryData getLootableData() {
+ return tileEntityLootable.lootableData;
+ }
+
+ @Override
+ public TileEntityLootable getTileEntity() {
+ return tileEntityLootable;
+ }
+
+ @Override
+ public LootableInventory getAPILootableInventory() {
+ World world = tileEntityLootable.getWorld();
+ if (world == null) {
+ return null;
+ }
+ return (LootableInventory) getBukkitWorld().getBlockAt(MCUtil.toLocation(world, tileEntityLootable.getPosition())).getState();
+ }
+
+ @Override
+ public World getNMSWorld() {
+ return tileEntityLootable.getWorld();
+ }
+}
diff --git a/src/main/java/net/minecraft/server/Entity.java b/src/main/java/net/minecraft/server/Entity.java
2018-12-23 18:04:13 +01:00
index b39e3ef13..1338eff40 100644
2018-08-26 20:11:49 +02:00
--- a/src/main/java/net/minecraft/server/Entity.java
+++ b/src/main/java/net/minecraft/server/Entity.java
@@ -69,6 +69,7 @@ public abstract class Entity implements INamableTileEntity, ICommandListener, Ke
return tag.hasKey("Bukkit.updateLevel") && tag.getInt("Bukkit.updateLevel") >= level;
}
2016-05-02 05:54:08 +02:00
2018-08-26 20:11:49 +02:00
+ public com.destroystokyo.paper.loottable.PaperLootableInventoryData lootableData; // Paper
protected CraftEntity bukkitEntity;
public CraftEntity getBukkitEntity() {
diff --git a/src/main/java/net/minecraft/server/EntityMinecartContainer.java b/src/main/java/net/minecraft/server/EntityMinecartContainer.java
2018-12-23 18:04:13 +01:00
index 520cca48c..e228fc853 100644
2018-08-26 20:11:49 +02:00
--- a/src/main/java/net/minecraft/server/EntityMinecartContainer.java
+++ b/src/main/java/net/minecraft/server/EntityMinecartContainer.java
@@ -15,10 +15,11 @@ public abstract class EntityMinecartContainer extends EntityMinecartAbstract imp
2016-05-02 05:54:08 +02:00
2016-11-17 03:23:38 +01:00
private NonNullList<ItemStack> items;
private boolean b;
2018-08-12 19:11:08 +02:00
- private MinecraftKey c;
2018-08-26 20:11:49 +02:00
+ private MinecraftKey c; public MinecraftKey getLootTableKey() { return c; } public void setLootTable(MinecraftKey key) { c = key; } // Paper - OBFHELPER
public long lootTableSeed;
2016-05-02 05:54:08 +02:00
// CraftBukkit start
2018-08-26 20:11:49 +02:00
+ { lootableData = new com.destroystokyo.paper.loottable.PaperLootableInventoryData(new com.destroystokyo.paper.loottable.PaperMinecartLootableInventory(this)); } // Paper
2016-05-02 05:54:08 +02:00
public List<HumanEntity> transaction = new java.util.ArrayList<HumanEntity>();
2018-08-26 20:11:49 +02:00
private int maxStack = MAX_STACK;
@@ -168,12 +169,13 @@ public abstract class EntityMinecartContainer extends EntityMinecartAbstract imp
2016-05-02 05:54:08 +02:00
protected void b(NBTTagCompound nbttagcompound) {
super.b(nbttagcompound);
+ lootableData.saveNbt(nbttagcompound); // Paper
if (this.c != null) {
nbttagcompound.setString("LootTable", this.c.toString());
2018-08-26 20:11:49 +02:00
if (this.lootTableSeed != 0L) {
nbttagcompound.setLong("LootTableSeed", this.lootTableSeed);
2016-06-07 01:56:51 +02:00
}
- } else {
+ } if (true) { // Paper - Always save the items, Table may stick around
2016-11-17 03:23:38 +01:00
ContainerUtil.a(nbttagcompound, this.items);
}
2016-06-07 01:56:51 +02:00
2018-08-26 20:11:49 +02:00
@@ -181,11 +183,12 @@ public abstract class EntityMinecartContainer extends EntityMinecartAbstract imp
2017-06-21 00:59:18 +02:00
protected void a(NBTTagCompound nbttagcompound) {
super.a(nbttagcompound);
+ lootableData.loadNbt(nbttagcompound); // Paper
this.items = NonNullList.a(this.getSize(), ItemStack.a);
2016-05-02 05:54:08 +02:00
if (nbttagcompound.hasKeyOfType("LootTable", 8)) {
this.c = new MinecraftKey(nbttagcompound.getString("LootTable"));
2018-08-26 20:11:49 +02:00
this.lootTableSeed = nbttagcompound.getLong("LootTableSeed");
2016-06-07 01:56:51 +02:00
- } else {
+ } if (true) { // Paper - always load the items, table may still remain
2016-11-17 03:23:38 +01:00
ContainerUtil.b(nbttagcompound, this.items);
}
2016-06-07 01:56:51 +02:00
2018-08-26 20:11:49 +02:00
@@ -234,10 +237,10 @@ public abstract class EntityMinecartContainer extends EntityMinecartAbstract imp
2016-05-02 05:54:08 +02:00
}
2016-05-12 04:07:46 +02:00
public void f(@Nullable EntityHuman entityhuman) {
2018-07-16 17:34:55 +02:00
- if (this.c != null && this.world.getMinecraftServer() != null) {
+ if (lootableData.shouldReplenish(entityhuman) && this.world.getMinecraftServer() != null) { // Paper
2018-08-26 20:11:49 +02:00
LootTable loottable = this.world.getMinecraftServer().getLootTableRegistry().getLootTable(this.c);
2016-05-02 05:54:08 +02:00
- this.c = null;
+ lootableData.processRefill(entityhuman); // Paper
Random random;
2018-08-26 20:11:49 +02:00
if (this.lootTableSeed == 0L) {
2016-05-02 05:54:08 +02:00
diff --git a/src/main/java/net/minecraft/server/TileEntityLootable.java b/src/main/java/net/minecraft/server/TileEntityLootable.java
2018-12-23 18:04:13 +01:00
index 7d066a18d..c9c29528a 100644
2016-05-02 05:54:08 +02:00
--- a/src/main/java/net/minecraft/server/TileEntityLootable.java
+++ b/src/main/java/net/minecraft/server/TileEntityLootable.java
2018-09-01 00:56:57 +02:00
@@ -4,9 +4,10 @@ import java.util.Random;
import javax.annotation.Nullable;
2016-05-02 05:54:08 +02:00
2018-08-26 20:11:49 +02:00
public abstract class TileEntityLootable extends TileEntityContainer implements ILootable {
2018-08-12 19:11:08 +02:00
- protected MinecraftKey g;
2018-07-16 17:34:55 +02:00
- protected long h;
2018-08-26 20:11:49 +02:00
+ protected MinecraftKey g; public MinecraftKey getLootTableKey() { return g; } public void setLootTable(MinecraftKey key) { g = key; } // Paper - OBFHELPER
2018-08-12 19:11:08 +02:00
+ protected long h; public long getSeed() { return h; } public void setSeed(long seed) { h = seed; } // Paper - OBFHELPER
2018-07-16 17:34:55 +02:00
protected IChatBaseComponent i;
2018-08-26 20:11:49 +02:00
+ public final com.destroystokyo.paper.loottable.PaperLootableInventoryData lootableData = new com.destroystokyo.paper.loottable.PaperLootableInventoryData(new com.destroystokyo.paper.loottable.PaperTileEntityLootableInventory(this)); // Paper
2016-05-02 05:54:08 +02:00
2018-07-16 17:34:55 +02:00
protected TileEntityLootable(TileEntityTypes<?> tileentitytypes) {
2018-08-26 20:11:49 +02:00
super(tileentitytypes);
2018-09-01 00:56:57 +02:00
@@ -21,16 +22,18 @@ public abstract class TileEntityLootable extends TileEntityContainer implements
2018-07-16 17:34:55 +02:00
}
2016-05-02 05:54:08 +02:00
2018-07-16 17:34:55 +02:00
protected boolean d(NBTTagCompound nbttagcompound) {
2016-05-02 05:54:08 +02:00
+ lootableData.loadNbt(nbttagcompound); // Paper
if (nbttagcompound.hasKeyOfType("LootTable", 8)) {
2018-07-16 17:34:55 +02:00
this.g = new MinecraftKey(nbttagcompound.getString("LootTable"));
this.h = nbttagcompound.getLong("LootTableSeed");
2016-06-07 09:03:51 +02:00
- return true;
+ return false; // Paper - always load the items, table may still remain
2016-06-07 01:56:51 +02:00
} else {
2016-06-07 09:03:51 +02:00
return false;
2016-06-07 01:56:51 +02:00
}
2016-05-02 05:54:08 +02:00
}
2018-07-16 17:34:55 +02:00
protected boolean e(NBTTagCompound nbttagcompound) {
2016-05-02 05:54:08 +02:00
+ lootableData.saveNbt(nbttagcompound); // Paper
2018-07-16 17:34:55 +02:00
if (this.g == null) {
return false;
} else {
2018-09-01 00:56:57 +02:00
@@ -39,14 +42,14 @@ public abstract class TileEntityLootable extends TileEntityContainer implements
2018-07-16 17:34:55 +02:00
nbttagcompound.setLong("LootTableSeed", this.h);
2016-06-07 09:03:51 +02:00
}
2016-06-07 01:56:51 +02:00
2016-06-07 09:03:51 +02:00
- return true;
+ return false; // Paper - always save the items, table may still remain
2016-06-07 01:56:51 +02:00
}
2016-05-02 05:54:08 +02:00
}
2016-11-17 03:23:38 +01:00
public void d(@Nullable EntityHuman entityhuman) {
2018-07-16 17:34:55 +02:00
- if (this.g != null && this.world.getMinecraftServer() != null) {
+ if (lootableData.shouldReplenish(entityhuman) && this.world.getMinecraftServer() != null) { // Paper
2018-08-26 20:11:49 +02:00
LootTable loottable = this.world.getMinecraftServer().getLootTableRegistry().getLootTable(this.g);
2018-07-16 17:34:55 +02:00
- this.g = null;
2016-05-02 05:54:08 +02:00
+ lootableData.processRefill(entityhuman); // Paper
Random random;
2018-07-16 17:34:55 +02:00
if (this.h == 0L) {
2018-09-01 00:56:57 +02:00
random = new Random();
2017-08-06 00:36:47 +02:00
diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockEntityState.java b/src/main/java/org/bukkit/craftbukkit/block/CraftBlockEntityState.java
2018-12-23 18:04:13 +01:00
index 8617fac6b..4f4121adc 100644
2017-08-06 00:36:47 +02:00
--- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlockEntityState.java
+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlockEntityState.java
2018-07-16 17:34:55 +02:00
@@ -61,7 +61,7 @@ public class CraftBlockEntityState<T extends TileEntity> extends CraftBlockState
2017-08-06 00:36:47 +02:00
}
// gets the wrapped TileEntity
- protected T getTileEntity() {
+ public T getTileEntity() { // Paper - protected -> public
return tileEntity;
}
2016-05-02 05:54:08 +02:00
diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftChest.java b/src/main/java/org/bukkit/craftbukkit/block/CraftChest.java
2018-12-23 18:04:13 +01:00
index fa03d17a4..14b5be75f 100644
2016-05-02 05:54:08 +02:00
--- a/src/main/java/org/bukkit/craftbukkit/block/CraftChest.java
+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftChest.java
2018-12-23 18:04:13 +01:00
@@ -13,8 +13,9 @@ import org.bukkit.craftbukkit.CraftWorld;
import org.bukkit.craftbukkit.inventory.CraftInventory;
2016-05-02 05:54:08 +02:00
import org.bukkit.craftbukkit.inventory.CraftInventoryDoubleChest;
import org.bukkit.inventory.Inventory;
2018-12-23 18:04:13 +01:00
+import com.destroystokyo.paper.loottable.PaperLootableBlockInventory; // Paper
2016-05-02 05:54:08 +02:00
2017-08-06 00:36:47 +02:00
-public class CraftChest extends CraftLootable<TileEntityChest> implements Chest {
2018-08-26 20:11:49 +02:00
+public class CraftChest extends CraftLootable<TileEntityChest> implements Chest, PaperLootableBlockInventory { // Paper
2016-05-02 05:54:08 +02:00
2017-08-06 00:36:47 +02:00
public CraftChest(final Block block) {
super(block, TileEntityChest.class);
2018-08-12 19:11:08 +02:00
diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftLootable.java b/src/main/java/org/bukkit/craftbukkit/block/CraftLootable.java
2018-12-13 01:40:29 +01:00
index 7ef68bb62..daf183fb1 100644
2018-08-12 19:11:08 +02:00
--- a/src/main/java/org/bukkit/craftbukkit/block/CraftLootable.java
+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftLootable.java
2016-11-19 18:31:01 +01:00
@@ -1,5 +1,6 @@
package org.bukkit.craftbukkit.block;
2018-08-26 20:11:49 +02:00
+import com.destroystokyo.paper.loottable.PaperLootableBlockInventory;
2018-08-12 19:11:08 +02:00
import net.minecraft.server.MinecraftKey;
import net.minecraft.server.TileEntityLootable;
import org.bukkit.Bukkit;
@@ -11,7 +12,7 @@ import org.bukkit.craftbukkit.util.CraftNamespacedKey;
import org.bukkit.loot.LootTable;
import org.bukkit.loot.Lootable;
-public abstract class CraftLootable<T extends TileEntityLootable> extends CraftContainer<T> implements Nameable, Lootable {
2018-08-26 20:11:49 +02:00
+public abstract class CraftLootable<T extends TileEntityLootable> extends CraftContainer<T> implements Nameable, Lootable, PaperLootableBlockInventory { // Paper
2018-08-12 19:11:08 +02:00
public CraftLootable(Block block, Class<T> tileEntityClass) {
super(block, tileEntityClass);
@@ -69,7 +70,7 @@ public abstract class CraftLootable<T extends TileEntityLootable> extends CraftC
setLootTable(getLootTable(), seed);
}
2016-11-19 18:31:01 +01:00
2018-08-12 19:11:08 +02:00
- private void setLootTable(LootTable table, long seed) {
+ public void setLootTable(LootTable table, long seed) { // Paper - public
MinecraftKey key = (table == null) ? null : CraftNamespacedKey.toMinecraft(table.getKey());
2018-08-26 20:11:49 +02:00
getSnapshot().setLootTable(key, seed);
2018-08-12 19:11:08 +02:00
}
2016-05-02 05:54:08 +02:00
diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartChest.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartChest.java
2018-12-13 01:40:29 +01:00
index 1b5b266c0..e0b99207b 100644
2016-05-02 05:54:08 +02:00
--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartChest.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartChest.java
@@ -1,5 +1,6 @@
package org.bukkit.craftbukkit.entity;
2018-08-26 20:11:49 +02:00
+import com.destroystokyo.paper.loottable.PaperLootableEntityInventory; // Paper
2016-05-02 05:54:08 +02:00
import net.minecraft.server.EntityMinecartChest;
import org.bukkit.craftbukkit.CraftServer;
2016-11-17 03:23:38 +01:00
@@ -9,7 +10,7 @@ import org.bukkit.entity.minecart.StorageMinecart;
2016-05-02 05:54:08 +02:00
import org.bukkit.inventory.Inventory;
@SuppressWarnings("deprecation")
2018-08-12 19:11:08 +02:00
-public class CraftMinecartChest extends CraftMinecartContainer implements StorageMinecart {
2018-08-26 20:11:49 +02:00
+public class CraftMinecartChest extends CraftMinecartContainer implements StorageMinecart, PaperLootableEntityInventory { // Paper
2016-05-02 05:54:08 +02:00
private final CraftInventory inventory;
public CraftMinecartChest(CraftServer server, EntityMinecartChest entity) {
2018-08-12 19:11:08 +02:00
diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartContainer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartContainer.java
2018-12-13 01:40:29 +01:00
index 87303ecd1..6790fa2fe 100644
2018-08-12 19:11:08 +02:00
--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartContainer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartContainer.java
@@ -47,7 +47,7 @@ public abstract class CraftMinecartContainer extends CraftMinecart implements Lo
2018-08-26 20:11:49 +02:00
return getHandle().lootTableSeed;
2018-08-12 19:11:08 +02:00
}
- private void setLootTable(LootTable table, long seed) {
2018-08-26 20:11:49 +02:00
+ public void setLootTable(LootTable table, long seed) { // Paper
2018-08-12 19:11:08 +02:00
MinecraftKey newKey = (table == null) ? null : CraftNamespacedKey.toMinecraft(table.getKey());
getHandle().a(newKey, seed);
}
2016-05-02 05:54:08 +02:00
diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartHopper.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartHopper.java
2018-12-13 01:40:29 +01:00
index f29365c94..1937f7b9a 100644
2016-05-02 05:54:08 +02:00
--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartHopper.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftMinecartHopper.java
@@ -1,5 +1,6 @@
package org.bukkit.craftbukkit.entity;
2018-08-26 20:11:49 +02:00
+import com.destroystokyo.paper.loottable.PaperLootableEntityInventory; // Paper
2016-05-02 05:54:08 +02:00
import net.minecraft.server.EntityMinecartHopper;
import org.bukkit.craftbukkit.CraftServer;
@@ -8,7 +9,7 @@ import org.bukkit.entity.EntityType;
import org.bukkit.entity.minecart.HopperMinecart;
import org.bukkit.inventory.Inventory;
2018-08-12 19:11:08 +02:00
-public final class CraftMinecartHopper extends CraftMinecartContainer implements HopperMinecart {
2018-08-26 20:11:49 +02:00
+public final class CraftMinecartHopper extends CraftMinecartContainer implements HopperMinecart, PaperLootableEntityInventory { // Paper
2016-05-02 05:54:08 +02:00
private final CraftInventory inventory;
2018-08-12 19:11:08 +02:00
public CraftMinecartHopper(CraftServer server, EntityMinecartHopper entity) {
2016-05-02 05:54:08 +02:00
--
2018-12-23 18:04:13 +01:00
2.20.1
2016-05-02 05:54:08 +02:00