progress

patches/api/0202-Add-villager-reputation-API.patch

@@ -0,0 +1,177 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Mariell Hoversholm <proximyst@proximyst.com>
+Date: Wed, 22 Apr 2020 23:13:49 +0200
+Subject: [PATCH] Add villager reputation API
+
+
+diff --git a/src/main/java/com/destroystokyo/paper/entity/villager/Reputation.java b/src/main/java/com/destroystokyo/paper/entity/villager/Reputation.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..1cc9ef255df888cb7dd7f7f2c5014e818d1be613
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/entity/villager/Reputation.java
+@@ -0,0 +1,54 @@
++package com.destroystokyo.paper.entity.villager;
++
++import com.google.common.base.Preconditions;
++import java.util.Map;
++import org.jetbrains.annotations.NotNull;
++
++/**
++ * A reputation score for a player on a villager.
++ */
++public final class Reputation {
++    private static final ReputationType[] REPUTATION_TYPES = ReputationType.values(); // Avoid allocation
++    @NotNull
++    private final int[] reputation;
++
++    public Reputation() {
++        this(new int[REPUTATION_TYPES.length]);
++    }
++
++    // Package level to avoid plugins creating reputations with "magic values".
++    Reputation(@NotNull int[] reputation) {
++        this.reputation = reputation;
++    }
++
++    public Reputation(@NotNull final Map<ReputationType, Integer> reputation) {
++        this();
++        Preconditions.checkNotNull(reputation, "reputation cannot be null");
++
++        for (Map.Entry<ReputationType, Integer> entry : reputation.entrySet()) {
++            setReputation(entry.getKey(), entry.getValue());
++        }
++    }
++
++    /**
++     * Gets the reputation value for a specific {@link ReputationType}.
++     *
++     * @param type The {@link ReputationType type} of reputation to get.
++     * @return The value of the {@link ReputationType type}.
++     */
++    public int getReputation(@NotNull ReputationType type) {
++        Preconditions.checkNotNull(type, "the reputation type cannot be null");
++        return reputation[type.ordinal()];
++    }
++
++    /**
++     * Sets the reputation value for a specific {@link ReputationType}.
++     *
++     * @param type The {@link ReputationType type} of reputation to set.
++     * @param value The value of the {@link ReputationType type}.
++     */
++    public void setReputation(@NotNull ReputationType type, int value) {
++        Preconditions.checkNotNull(type, "the reputation type cannot be null");
++        reputation[type.ordinal()] = value;
++    }
++}
+diff --git a/src/main/java/com/destroystokyo/paper/entity/villager/ReputationType.java b/src/main/java/com/destroystokyo/paper/entity/villager/ReputationType.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..5600fcdc9795a9f49091db48d73bbd4964b8b737
+--- /dev/null
++++ b/src/main/java/com/destroystokyo/paper/entity/villager/ReputationType.java
+@@ -0,0 +1,36 @@
++package com.destroystokyo.paper.entity.villager;
++
++/**
++ * A type of reputation gained with a {@link org.bukkit.entity.Villager Villager}.
++ * <p>
++ * All types but {@link #MAJOR_POSITIVE} are shared to other villagers.
++ */
++public enum ReputationType {
++    /**
++     * A gossip with a majorly negative effect. This is only gained through killing a nearby
++     * villager.
++     */
++    MAJOR_NEGATIVE,
++
++    /**
++     * A gossip with a minor negative effect. This is only gained through damaging a villager.
++     */
++    MINOR_NEGATIVE,
++
++    /**
++     * A gossip with a minor positive effect. This is only gained through curing a zombie
++     * villager.
++     */
++    MINOR_POSITIVE,
++
++    /**
++     * A gossip with a major positive effect. This is only gained through curing a zombie
++     * villager.
++     */
++    MAJOR_POSITIVE,
++
++    /**
++     * A gossip with a minor positive effect. This is only gained through trading with a villager.
++     */
++    TRADING,
++}
+diff --git a/src/main/java/org/bukkit/entity/Villager.java b/src/main/java/org/bukkit/entity/Villager.java
+index d1579153092c1b80350155110f1b9926b1a1ef57..c8777a476e38ef5e72b6709761990a339eb43d2b 100644
+--- a/src/main/java/org/bukkit/entity/Villager.java
++++ b/src/main/java/org/bukkit/entity/Villager.java
+@@ -1,10 +1,13 @@
+ package org.bukkit.entity;
+ 
+ import java.util.Locale;
++import java.util.Map; // Paper
++import java.util.UUID; // Paper
+ import org.bukkit.Keyed;
+ import org.bukkit.Location;
+ import org.bukkit.NamespacedKey;
+ import org.jetbrains.annotations.NotNull;
++import org.jetbrains.annotations.Nullable; // Paper
+ 
+ /**
+  * Represents a villager NPC
+@@ -224,4 +227,50 @@ public interface Villager extends AbstractVillager {
+             return key;
+         }
+     }
++
++    // Paper start - Add villager reputation API
++    /**
++     * Get the {@link com.destroystokyo.paper.entity.villager.Reputation reputation}
++     * for a specific player by {@link UUID}.
++     *
++     * @param uniqueId The {@link UUID} of the player to get the reputation of.
++     * @return The player's copied reputation with this villager.
++     */
++    @Nullable
++    public com.destroystokyo.paper.entity.villager.Reputation getReputation(@NotNull UUID uniqueId);
++
++    /**
++     * Get all {@link com.destroystokyo.paper.entity.villager.Reputation reputations}
++     * for all players mapped by their {@link UUID unique IDs}.
++     *
++     * @return All {@link com.destroystokyo.paper.entity.villager.Reputation reputations} for all players
++     * in a copied map.
++     */
++    @NotNull
++    public Map<UUID, com.destroystokyo.paper.entity.villager.Reputation> getReputations();
++
++    /**
++     * Set the {@link com.destroystokyo.paper.entity.villager.Reputation reputation}
++     * for a specific player by {@link UUID}.
++     *
++     * @param uniqueId The {@link UUID} of the player to set the reputation of.
++     * @param reputation The {@link com.destroystokyo.paper.entity.villager.Reputation reputation} to set.
++     */
++    public void setReputation(@NotNull UUID uniqueId, @NotNull com.destroystokyo.paper.entity.villager.Reputation reputation);
++
++    /**
++     * Set all {@link com.destroystokyo.paper.entity.villager.Reputation reputations}
++     * for all players mapped by their {@link UUID unique IDs}.
++     *
++     * @param reputations All {@link com.destroystokyo.paper.entity.villager.Reputation reputations}
++     * for all players mapped by their {@link UUID unique IDs}.
++     */
++    public void setReputations(@NotNull Map<UUID, com.destroystokyo.paper.entity.villager.Reputation> reputations);
++
++    /**
++     * Clear all reputations from this villager. This removes every single
++     * reputation regardless of its impact and the player associated.
++     */
++    public void clearReputations();
++    // Paper end
+ }

patches/api/0204-Spawn-Reason-API.patch

@@ -0,0 +1,62 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aikar <aikar@aikar.co>
+Date: Thu, 10 Apr 2014 23:18:28 -0400
+Subject: [PATCH] Spawn Reason API
+
+
+diff --git a/src/main/java/org/bukkit/World.java b/src/main/java/org/bukkit/World.java
+index cd96c851d00185e7ee3ec6682b166fc1d06b6a73..10c22809535b6151b45aa18a02b80b8f2e3e6dff 100644
+--- a/src/main/java/org/bukkit/World.java
++++ b/src/main/java/org/bukkit/World.java
+@@ -1,6 +1,8 @@
+ package org.bukkit;
+ 
+ import java.io.File;
++
++import org.bukkit.event.entity.CreatureSpawnEvent;
+ import org.bukkit.generator.ChunkGenerator;
+ 
+ import java.util.ArrayList;
+@@ -2249,6 +2251,12 @@ public interface World extends PluginMessageRecipient, Metadatable, net.kyori.ad
+     @NotNull
+     public <T extends Entity> T spawn(@NotNull Location location, @NotNull Class<T> clazz) throws IllegalArgumentException;
+ 
++    // Paper start
++    @NotNull
++    public default <T extends Entity> T spawn(@NotNull Location location, @NotNull Class<T> clazz, @NotNull CreatureSpawnEvent.SpawnReason reason) throws IllegalArgumentException {
++        return spawn(location, clazz, reason, null);
++    }
++
+     /**
+      * Spawn an entity of a specific class at the given {@link Location}, with
+      * the supplied function run before the entity is added to the world.
+@@ -2266,7 +2274,28 @@ public interface World extends PluginMessageRecipient, Metadatable, net.kyori.ad
+      *     {@link Entity} requested cannot be spawned
+      */
+     @NotNull
+-    public <T extends Entity> T spawn(@NotNull Location location, @NotNull Class<T> clazz, @Nullable Consumer<T> function) throws IllegalArgumentException;
++    public default <T extends Entity> T spawn(@NotNull Location location, @NotNull Class<T> clazz, @Nullable Consumer<T> function) throws IllegalArgumentException {
++        return spawn(location, clazz, CreatureSpawnEvent.SpawnReason.CUSTOM, function);
++    }
++
++    @NotNull
++    public default <T extends Entity> T spawn(@NotNull Location location, @NotNull Class<T> clazz, @NotNull CreatureSpawnEvent.SpawnReason reason, @Nullable Consumer<T> function) throws IllegalArgumentException {
++        return spawn(location, clazz, function, reason);
++    }
++
++    @NotNull
++    public default Entity spawnEntity(@NotNull Location loc, @NotNull EntityType type, @NotNull CreatureSpawnEvent.SpawnReason reason) {
++        return spawn(loc, (Class<Entity>) type.getEntityClass(), reason, null);
++    }
++
++    @NotNull
++    public default Entity spawnEntity(@NotNull Location loc, @NotNull EntityType type, @NotNull CreatureSpawnEvent.SpawnReason reason, @Nullable Consumer<Entity> function) {
++        return spawn(loc, (Class<Entity>) type.getEntityClass(), reason, function);
++    }
++
++    @NotNull
++    public <T extends Entity> T spawn(@NotNull Location location, @NotNull Class<T> clazz, @Nullable Consumer<T> function, @NotNull CreatureSpawnEvent.SpawnReason reason) throws IllegalArgumentException;
++    // Paper end
+ 
+     /**
+      * Spawn a {@link FallingBlock} entity at the given {@link Location} of

patches/api/0205-Potential-bed-API.patch

@@ -0,0 +1,33 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: JRoy <joshroy126@gmail.com>
+Date: Sun, 10 May 2020 23:06:41 -0400
+Subject: [PATCH] Potential bed API
+
+Adds a new method to fetch the location of a player's bed without generating any sync loads.
+
+getPotentialBedLocation - Gets the last known location of a player's bed. This does not preform any check if the bed is still valid and does not load any chunks.
+
+diff --git a/src/main/java/org/bukkit/entity/HumanEntity.java b/src/main/java/org/bukkit/entity/HumanEntity.java
+index 66f11e9670770e05a164922cc0f2aa863c066203..c307a58b17324d6df8c21fa45f0f1e34810f1828 100644
+--- a/src/main/java/org/bukkit/entity/HumanEntity.java
++++ b/src/main/java/org/bukkit/entity/HumanEntity.java
+@@ -240,6 +240,19 @@ public interface HumanEntity extends LivingEntity, AnimalTamer, InventoryHolder
+      */
+     public int getSleepTicks();
+ 
++
++    // Paper start - Potential bed api
++    /**
++     * Gets the Location of the player's bed, null if they have not slept
++     * in one. This method will not attempt to validate if the current bed
++     * is still valid.
++     *
++     * @return Bed Location if has slept in one, otherwise null.
++     */
++    @Nullable
++    public Location getPotentialBedLocation();
++    // Paper end
++
+     /**
+      * Attempts to make the entity sleep at the given location.
+      * <br>

patches/api/0206-Prioritise-own-classes-where-possible.patch

@@ -0,0 +1,86 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Mariell Hoversholm <proximyst@proximyst.com>
+Date: Mon, 27 Apr 2020 12:31:59 +0200
+Subject: [PATCH] Prioritise own classes where possible
+
+This adds the server property `Paper.DisableClassPrioritization` to disable
+prioritization of own classes for plugins' classloaders.
+
+This value is by default not present, and this will therefore break any
+plugins which abuse behaviour related to not using their own classes
+while still loading their own. This is often an issue with failing to
+relocate or shade properly, such as when shading plugin APIs like Vault.
+
+A plugin's classloader will first look in the same jar as it is loading
+in for a requested class, then load it. It does not re-use other
+plugins' classes if it has the chance to avoid doing so.
+
+If a class is not found in the same jar as it is loading for and it does
+find it elsewhere, it will still choose the class elsewhere. This is
+intended behaviour, as it will only prioritise classes it has in its own
+jar, no other plugins' classes will be prioritised in any other order
+than the one they were registered in.
+
+The patch in general terms just loads the class in the plugin's jar
+before it starts looking elsewhere for it.
+
+diff --git a/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java b/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
+index ce751577623eaad0f31e2eb7bf0842d1ab73e845..31793f46e5623729dfb4048e901f274082f57826 100644
+--- a/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
++++ b/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
+@@ -51,6 +51,7 @@ import org.yaml.snakeyaml.error.YAMLException;
+  */
+ public final class JavaPluginLoader implements PluginLoader {
+     final Server server;
++    private static final boolean DISABLE_CLASS_PRIORITIZATION = Boolean.getBoolean("Paper.DisableClassPrioritization"); // Paper
+     private final Pattern[] fileFilters = new Pattern[]{Pattern.compile("\\.jar$")};
+     private final Map<String, java.util.concurrent.locks.ReentrantReadWriteLock> classLoadLock = new java.util.HashMap<String, java.util.concurrent.locks.ReentrantReadWriteLock>(); // Paper
+     private final Map<String, Integer> classLoadLockCount = new java.util.HashMap<String, Integer>(); // Paper
+@@ -203,6 +204,11 @@ public final class JavaPluginLoader implements PluginLoader {
+ 
+     @Nullable
+     Class<?> getClassByName(final String name, boolean resolve, PluginDescriptionFile description) {
++        // Paper start - prioritize self
++        return getClassByName(name, resolve, description, null);
++    }
++    Class<?> getClassByName(final String name, boolean resolve, PluginDescriptionFile description, PluginClassLoader requester) {
++        // Paper end
+         // Paper start - make MT safe
+         java.util.concurrent.locks.ReentrantReadWriteLock lock;
+         synchronized (classLoadLock) {
+@@ -210,6 +216,13 @@ public final class JavaPluginLoader implements PluginLoader {
+             classLoadLockCount.compute(name, (x, prev) -> prev != null ? prev + 1 : 1);
+         }
+         lock.writeLock().lock();try {
++            // Paper start - prioritize self
++            if (!DISABLE_CLASS_PRIORITIZATION && requester != null) {
++                try {
++                return requester.loadClass0(name, false, false, ((SimplePluginManager) server.getPluginManager()).isTransitiveDepend(description, requester.getDescription()));
++                } catch (ClassNotFoundException cnfe) {}
++            }
++            // Paper end
+         // Paper end
+         for (PluginClassLoader loader : loaders) {
+             try {
+diff --git a/src/main/java/org/bukkit/plugin/java/PluginClassLoader.java b/src/main/java/org/bukkit/plugin/java/PluginClassLoader.java
+index 550225f168160298f4b1bf6c361207a59cf23122..9c2bde2820b92d17bc2241957390f3fb3cc50d98 100644
+--- a/src/main/java/org/bukkit/plugin/java/PluginClassLoader.java
++++ b/src/main/java/org/bukkit/plugin/java/PluginClassLoader.java
+@@ -33,7 +33,7 @@ public final class PluginClassLoader extends URLClassLoader { // Spigot
+     public JavaPlugin getPlugin() { return plugin; } // Spigot
+     private final JavaPluginLoader loader;
+     private final Map<String, Class<?>> classes = new ConcurrentHashMap<String, Class<?>>();
+-    private final PluginDescriptionFile description;
++    private final PluginDescriptionFile description; PluginDescriptionFile getDescription() { return description; } // Paper
+     private final File dataFolder;
+     private final File file;
+     private final JarFile jar;
+@@ -118,7 +118,7 @@ public final class PluginClassLoader extends URLClassLoader { // Spigot
+ 
+         if (checkGlobal) {
+             // This ignores the libraries of other plugins, unless they are transitive dependencies.
+-            Class<?> result = loader.getClassByName(name, resolve, description);
++            Class<?> result = loader.getClassByName(name, resolve, description, this);  // Paper - prioritize self
+ 
+             if (result != null) {
+                 // If the class was loaded from a library instead of a PluginClassLoader, we can assume that its associated plugin is a transitive dependency and can therefore skip this check.

patches/api/0207-Provide-a-useful-PluginClassLoader-toString.patch

@@ -0,0 +1,30 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <theboyetronic@gmail.com>
+Date: Sun, 31 May 2020 15:26:17 +0100
+Subject: [PATCH] Provide a useful PluginClassLoader#toString
+
+There are several cases where the plugin classloader may be dumped to the logs,
+however, this provides no indication of the owner of the classloader, making
+these messages effectively useless, this patch rectifies this
+
+diff --git a/src/main/java/org/bukkit/plugin/java/PluginClassLoader.java b/src/main/java/org/bukkit/plugin/java/PluginClassLoader.java
+index 9c2bde2820b92d17bc2241957390f3fb3cc50d98..6b5d7c350c216b7a234d96ecacae1d39a1acd814 100644
+--- a/src/main/java/org/bukkit/plugin/java/PluginClassLoader.java
++++ b/src/main/java/org/bukkit/plugin/java/PluginClassLoader.java
+@@ -230,4 +230,16 @@ public final class PluginClassLoader extends URLClassLoader { // Spigot
+         javaPlugin.logger = this.logger; // Paper - set logger
+         javaPlugin.init(loader, loader.server, description, dataFolder, file, this);
+     }
++
++    // Paper start
++    @Override
++    public String toString() {
++        JavaPlugin currPlugin = plugin != null ? plugin : pluginInit;
++        return "PluginClassLoader{" +
++                   "plugin=" + currPlugin +
++                   ", pluginEnabled=" + (currPlugin == null ? "uninitialized" : currPlugin.isEnabled()) +
++                   ", url=" + file +
++                   '}';
++    }
++    // Paper end
+ }