Add golem support

Golems can now no longer access protections, unless [Golem] or [Everyone] is on the sign.

Author: rutgerkok

pom.xml

@@ -4,18 +4,19 @@
     <modelVersion>4.0.0</modelVersion>
     <groupId>nl.rutgerkok</groupId>
     <artifactId>blocklocker</artifactId>
-    <version>1.13</version>
+    <version>1.14-SNAPSHOT</version>
     <packaging>jar</packaging>
     <name>BlockLocker</name>
     <url>https://github.com/rutgerkok/BlockLocker</url>
     <properties>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
         <junit.jupiter.version>5.3.1</junit.jupiter.version>
+        <maven.compiler.release>21</maven.compiler.release>
     </properties>
     <repositories>
         <repository>
-            <id>spigot-repo</id>
-            <url>https://hub.spigotmc.org/nexus/content/groups/public/</url>
+            <id>papermc</id>
+            <url>https://repo.papermc.io/repository/maven-public/</url>
         </repository>
         <repository>
             <id>rutger-repo</id>
@@ -28,17 +29,10 @@
     </repositories>
     <dependencies>
         <dependency>
-            <groupId>org.spigotmc</groupId>
-            <artifactId>spigot-api</artifactId>
-            <version>1.20-R0.1-SNAPSHOT</version>
+            <groupId>io.papermc.paper</groupId>
+            <artifactId>paper-api</artifactId>
+            <version>1.21.10-R0.1-SNAPSHOT</version>
             <scope>provided</scope>
-            <exclusions>
-                <exclusion>
-                    <!-- Don't pull in an outdated version of JUnit -->
-                    <groupId>junit</groupId>
-                    <artifactId>junit</artifactId>
-                </exclusion>
-            </exclusions>
         </dependency>
         <!-- Third party plugins -->
         <dependency>
@@ -110,14 +104,22 @@
                 </includes>
             </resource>
         </resources>
+        <!-- Make sure our plugin is not remapped -->
         <plugins>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.7.0</version>
+                <artifactId>maven-jar-plugin</artifactId>
+                <version>3.4.2</version>
                 <configuration>
-                    <source>17</source>
-                    <target>17</target>
+                    <archive>
+                        <index>true</index>
+                        <manifest>
+                            <addClasspath>true</addClasspath>
+                        </manifest>
+                        <manifestEntries>
+                            <paperweight-mappings-namespace>mojang</paperweight-mappings-namespace>
+                        </manifestEntries>
+                    </archive>
                 </configuration>
             </plugin>
         </plugins>

src/main/java/nl/rutgerkok/blocklocker/AttackType.java

@@ -13,6 +13,7 @@ public enum AttackType {
     ENDERMAN,
     BLOCK_EXPLOSION,
     FIRE,
+    GOLEM,
     GHAST,
     PISTON,
     SAPLING,

src/main/java/nl/rutgerkok/blocklocker/BlockLockerPlugin.java

@@ -45,7 +45,7 @@ public interface BlockLockerPlugin {
      * Gets the cache that stores whether a block is protected or not.
      * @return The cache.
      */
-    HopperCache getHopperCache();
+    ProtectionCache getProtectionCache();
 
     /**
      * Gets the location checkers, which are used to prevent players from placing chests in the wilderness.

src/main/java/nl/rutgerkok/blocklocker/HopperCache.java

@@ -46,4 +46,11 @@ public interface ProfileFactory {
      * @return The profile.
      */
     Profile fromRedstone();
+
+    /**
+     * Gets the profile for golems.
+     *
+     * @return The profile.
+     */
+    Profile fromGolem();
 }

src/main/java/nl/rutgerkok/blocklocker/ProfileFactory.java

@@ -0,0 +1,57 @@
+package nl.rutgerkok.blocklocker;
+
+import org.bukkit.block.Block;
+
+/**
+ * A simple cache that stores whether a block is protected. Entries expire after
+ * a few seconds. Used for hoppers and copper golems, which do <em>a lot</em> of successive
+ * checks.
+ */
+public interface ProtectionCache {
+
+    enum CacheFlag {
+        /**
+         * Block is certainly protected.
+         */
+        NOT_ALLOWED,
+        /**
+         * Block is not protected.
+         */
+        ALLOWED,
+        /**
+         * Not cached; we don't know whether the block is protected or not.
+         */
+        MISS_CACHE
+    }
+
+    enum CacheType {
+        /**
+         * Checks whether redstone is allowed.
+         */
+        REDSTONE,
+        /**
+         * Checks whether golems are allowed.
+         */
+        GOLEM
+    }
+
+    /**
+     * Gets whether redstone/golems are allowed at the given block.
+     *
+     * @param cacheType Golems or redstone.
+     * @param block     The block.
+     * @return Whether the given block is locked.
+     */
+    CacheFlag getAllowed(Block block, CacheType cacheType);
+
+    /**
+     * Sets whether the given block is locked for redstone.
+     *
+     * @param cacheType Golems or redstone.
+     * @param block     The block.
+     * @param allowed   True if redstone/golems are allowed. Always true if there's no protection at the location.
+     */
+    void setAllowed(Block block, CacheType cacheType, boolean allowed);
+
+
+}

src/main/java/nl/rutgerkok/blocklocker/ProtectionCache.java

@@ -12,6 +12,10 @@
  * </ul>
  */
 public enum SearchMode {
+    /**
+     * Ignores both {@link #NO_SIGNS signs} and {@link #NO_SUPPORTING_BLOCKS supporting blocks}.
+     */
+    MAIN_BLOCKS_ONLY,
     /**
      * Ignores blocks that are solely part of the protection because they are
      * supporting another block.
@@ -36,7 +40,7 @@ public enum SearchMode {
      *         otherwise.
      */
     public boolean searchForSupportingBlocks() {
-        return this != NO_SUPPORTING_BLOCKS;
+        return this != NO_SUPPORTING_BLOCKS && this != MAIN_BLOCKS_ONLY;
     }
 
     /**
@@ -47,6 +51,6 @@ public boolean searchForSupportingBlocks() {
      *         otherwise.
      */
     public boolean searchForSigns() {
-        return this != NO_SIGNS;
+        return this != NO_SIGNS && this != MAIN_BLOCKS_ONLY;
     }
 }

src/main/java/nl/rutgerkok/blocklocker/SearchMode.java

@@ -38,6 +38,7 @@ public enum Translation {
         TAG_MORE_USERS,
         TAG_PRIVATE,
         TAG_REDSTONE,
+        TAG_GOLEM,
         TAG_TIMER,
         UPDATER_MORE_INFORMATION,
         UPDATER_UNSUPPORTED_SERVER,

src/main/java/nl/rutgerkok/blocklocker/Translator.java

@@ -11,6 +11,7 @@
 import java.util.function.Consumer;
 import java.util.logging.Level;
 
+import nl.rutgerkok.blocklocker.impl.event.*;
 import org.bukkit.Bukkit;
 import org.bukkit.block.Block;
 import org.bukkit.configuration.Configuration;
@@ -25,7 +26,7 @@
 
 import nl.rutgerkok.blocklocker.BlockLockerPlugin;
 import nl.rutgerkok.blocklocker.ChestSettings;
-import nl.rutgerkok.blocklocker.HopperCache;
+import nl.rutgerkok.blocklocker.ProtectionCache;
 import nl.rutgerkok.blocklocker.ProfileFactory;
 import nl.rutgerkok.blocklocker.ProtectableBlocksSettings;
 import nl.rutgerkok.blocklocker.ProtectionFinder;
@@ -35,11 +36,6 @@
 import nl.rutgerkok.blocklocker.group.CombinedGroupSystem;
 import nl.rutgerkok.blocklocker.group.GroupSystem;
 import nl.rutgerkok.blocklocker.impl.blockfinder.BlockFinder;
-import nl.rutgerkok.blocklocker.impl.event.BlockDestroyListener;
-import nl.rutgerkok.blocklocker.impl.event.BlockLockerCommand;
-import nl.rutgerkok.blocklocker.impl.event.BlockPlaceListener;
-import nl.rutgerkok.blocklocker.impl.event.InteractListener;
-import nl.rutgerkok.blocklocker.impl.event.SignChangeListener;
 import nl.rutgerkok.blocklocker.impl.group.FactionsGroupSystem;
 import nl.rutgerkok.blocklocker.impl.group.GuildsGroupSystem;
 import nl.rutgerkok.blocklocker.impl.group.PermissionsGroupSystem;
@@ -65,7 +61,7 @@ public class BlockLockerPluginImpl extends JavaPlugin implements BlockLockerPlug
     private Translator translator;
     private CombinedLocationChecker combinedLocationChecker;
     private SchedulerSupport schedulerSupport;
-    private HopperCache redstoneProtectCache;
+    private ProtectionCache protectionCache;
 
     @Override
     public <E extends Event> E callEvent(E event) {
@@ -85,8 +81,8 @@ public CombinedGroupSystem getGroupSystems() {
     }
 
     @Override
-    public HopperCache getHopperCache() {
-        return redstoneProtectCache;
+    public ProtectionCache getProtectionCache() {
+        return protectionCache;
     }
 
     /**
@@ -204,7 +200,7 @@ private void loadServices() {
         BlockFinder blockFinder = BlockFinder.create(signParser, config.getConnectContainers());
         protectionFinder = new ProtectionFinderImpl(blockFinder, chestSettings);
         protectionUpdater = new ProtectionUpdaterImpl(getServer(), signParser, profileFactory);
-        redstoneProtectCache = new HopperCacheImpl(this);
+        protectionCache = new HopperCacheImpl();
     }
 
     private Translator loadTranslations(String fileName) {
@@ -250,6 +246,7 @@ private void registerEvents() {
         plugins.registerEvents(new BlockDestroyListener(this), this);
         plugins.registerEvents(new BlockPlaceListener(this), this);
         plugins.registerEvents(new InteractListener(this), this);
+        plugins.registerEvents(new GolemListener(this), this);
         plugins.registerEvents(new SignChangeListener(this), this);
         getCommand(getName().toLowerCase(Locale.ROOT)).setExecutor(new BlockLockerCommand(this));
     }

src/main/java/nl/rutgerkok/blocklocker/impl/BlockLockerPluginImpl.java

@@ -3,41 +3,52 @@
 import java.util.concurrent.TimeUnit;
 
 import org.bukkit.block.Block;
-import org.bukkit.plugin.Plugin;
 
 import com.google.common.cache.Cache;
 import com.google.common.cache.CacheBuilder;
 
-import nl.rutgerkok.blocklocker.HopperCache;
+import nl.rutgerkok.blocklocker.ProtectionCache;
 
-final class HopperCacheImpl implements HopperCache {
+final class HopperCacheImpl implements ProtectionCache {
 
     private static final long EXPIRE_TIME_SECONDS = 10;
-    private Cache<Block, Boolean> accessCaching;
+    private final Cache<Block, Boolean> redstoneCache;
+    private final Cache<Block, Boolean> golemCache;
 
-    HopperCacheImpl(Plugin plugin) {
-        accessCaching = CacheBuilder.newBuilder().initialCapacity(1000)
+    HopperCacheImpl() {
+        redstoneCache = CacheBuilder.newBuilder().initialCapacity(1000)
                 .maximumSize(5000)
                 .expireAfterWrite(EXPIRE_TIME_SECONDS, TimeUnit.SECONDS)
                 .build();
+        golemCache = CacheBuilder.newBuilder().initialCapacity(1000)
+                .maximumSize(5000)
+                .expireAfterWrite(EXPIRE_TIME_SECONDS, TimeUnit.SECONDS)
+                .build();
+    }
+
+    private Cache<Block, Boolean> getCache(CacheType cacheType) {
+        return switch (cacheType) {
+            case REDSTONE -> this.redstoneCache;
+            case GOLEM -> this.golemCache;
+        };
     }
 
     @Override
-    public CacheFlag getIsRedstoneAllowed(Block block) {
-        Boolean isLocked = accessCaching.getIfPresent(block);
+    public CacheFlag getAllowed(Block block, CacheType cacheType) {
+        Boolean isAllowed = getCache(cacheType).getIfPresent(block);
 
-        if (isLocked == null) {
+        if (isAllowed == null) {
             return CacheFlag.MISS_CACHE;
         }
-        if (isLocked == true) {
-            return CacheFlag.PROTECTED;
+        if (isAllowed) {
+            return CacheFlag.ALLOWED;
         } else {
-            return CacheFlag.NOT_PROTECTED;
+            return CacheFlag.NOT_ALLOWED;
         }
     }
 
     @Override
-    public void setIsRedstoneAllowed(Block block, boolean locked) {
-        accessCaching.put(block, locked);
+    public void setAllowed(Block block, CacheType cacheType, boolean allowed) {
+        getCache(cacheType).put(block, allowed);
     }
 }