Merge 162c4a80bb into f3c631bbf5

build.gradle

@@ -2,7 +2,7 @@ import org.apache.tools.ant.filters.ReplaceTokens
 
 plugins {
     id 'java'
-    id 'com.github.johnrengelman.shadow' version '7.1.2'
+    id 'com.github.johnrengelman.shadow' version '8.1.1'
     id 'com.palantir.git-version' version '0.13.0'
 }
 
@@ -23,17 +23,15 @@ if (System.getenv("BUILD_NUMBER") != null) {
 logger.info("Building version $version")
 
 repositories {
-    jcenter()
     maven { url = 'https://hub.spigotmc.org/nexus/content/groups/public/' }
-    maven { url = 'https://papermc.io/repo/repository/maven-public/' }
+    maven { url = 'https://repo.papermc.io/repository/maven-public/' }
     maven { url = 'https://repo.codemc.org/repository/maven-public/' }
-    maven { url = 'https://maven.enginehub.org/repo/' }
 }
 
 dependencies {
-    compileOnly('com.sk89q.worldedit:worldedit-bukkit:7.0.0-SNAPSHOT') {
-        exclude group: 'org.bukkit'
-    }
+    implementation(platform("com.intellectualsites.bom:bom-newest:1.44")) // Ref: https://github.com/IntellectualSites/bom
+    compileOnly("com.fastasyncworldedit:FastAsyncWorldEdit-Core")
+    compileOnly("com.fastasyncworldedit:FastAsyncWorldEdit-Bukkit")
     compileOnly 'io.papermc.paper:paper-api:1.20.4-R0.1-SNAPSHOT'
     implementation 'org.bstats:bstats-bukkit-lite:1.8'
     implementation 'com.zaxxer:HikariCP:5.0.1'

docs/api/version/v10.md

@@ -0,0 +1,526 @@
+# API Version 10
+
+The CoreProtect API enables you to log your own block changes, perform lookups, rollbacks, restores, and more. 
+
+| API Details |  |
+| --- | --- |
+| **API Version:** | 10 |
+| **Plugin Version:** | v23.0+ |
+| **Maven:** | [maven.playpro.com](https://maven.playpro.com) |
+
+---
+
+## Upgrading from API v9
+
+The changes from the previous API version are as follows:
+
+- The following methods have been added:
+```java
+logPlacement(String user, BlockState blockState)
+
+logRemoval(String user, BlockState blockState)
+``` 
+  
+---
+
+## Getting Started
+
+Ensure you're using CoreProtect 21.0 or higher. Add it as an external jar to your plugin in your IDE.  
+Alternatively, if using Maven, you can add it via the repository [https://maven.playpro.com](https://maven.playpro.com) (net.coreprotect, 21.0).
+
+The first thing you need to do is get access to CoreProtect. You can do this by using code similar to the following:
+
+```java
+import net.coreprotect.CoreProtect;
+import net.coreprotect.CoreProtectAPI;
+
+private CoreProtectAPI getCoreProtect() {
+        Plugin plugin = getServer().getPluginManager().getPlugin("CoreProtect");
+     
+        // Check that CoreProtect is loaded
+        if (plugin == null || !(plugin instanceof CoreProtect)) {
+            return null;
+        }
+
+        // Check that the API is enabled
+        CoreProtectAPI CoreProtect = ((CoreProtect) plugin).getAPI();
+        if (CoreProtect.isEnabled() == false) {
+            return null;
+        }
+
+        // Check that a compatible version of the API is loaded
+        if (CoreProtect.APIVersion() < 9) {
+            return null;
+        }
+
+        return CoreProtect;
+}
+``` 
+
+With this code, you can then access the API with a call like the following:
+
+```java
+CoreProtectAPI api = getCoreProtect();
+if (api != null){ // Ensure we have access to the API
+  api.testAPI(); // Will print out "[CoreProtect] API test successful." in the console.
+}
+``` 
+
+Yay, you're now using the CoreProtect API!
+
+---
+
+## API Overview
+
+### Available Methods
+
+```java
+boolean isEnabled()
+
+void testAPI()
+
+List<String[]> performLookup(int time, List<String> restrict_users, List<String> exclude_users, List<Object> restrict_blocks, List<Object> exclude_blocks, List<Integer> action_list, int radius, Location radius_location)
+    
+List<String[]> performRollback(int time, List<String> restrict_users, List<String> exclude_users, List<Object> restrict_blocks, List<Object> exclude_blocks, List<Integer> action_list, int radius, Location radius_location)
+    
+List<String[]> performRestore(int time, List<String> restrict_users, List<String> exclude_users, List<Object> restrict_blocks, List<Object> exclude_blocks, List<Integer> action_list, int radius, Location radius_location)
+
+List<String[]> blockLookup(Block block, int time)
+
+List<String[]> sessionLookup(String user, int time)
+
+List<String[]> queueLookup(Block block)
+
+ParseResult parseResult(String[] result)
+
+boolean logChat(Player player, String message)
+
+boolean logCommand(Player player, String command)
+
+boolean logPlacement(String user, BlockState blockState)
+
+boolean logPlacement(String user, Location location, Material type, BlockData blockData)
+
+boolean logRemoval(String user, BlockState blockState)
+
+boolean logRemoval(String user, Location location, Material type, BlockData blockData)
+
+boolean logContainerTransaction(String user, Location location)
+
+boolean logInteraction(String user, Location location)
+
+boolean hasPlaced(String user, Block block, int time, int offset)
+
+boolean hasRemoved(String user, Block block, int time, int offset)
+
+void performPurge(int time)
+``` 
+
+---
+
+### Available Events
+
+*The following events are emitted by CoreProtect.*
+
+#### CoreProtectPreLogEvent
+
+Fired when a CoreProtect logger is about to log an action. Cancellable.
+
+| Property | Description | Mutable |
+| --- | --- | --- |
+| User | The name of the user under which this action will be logged. | Yes |
+| Cancelled | If cancelled, the action won't be logged to the database. | Yes |
+
+---
+
+### Method Usage
+
+*Detailed method information is listed below.*
+
+#### `isEnabled()`
+
+Calling this will return true if the server has the CoreProtect API enabled, and false if it does not.
+
+---
+
+#### `testAPI()`
+
+Running this will print out "[CoreProtect] API Test Successful." in the server console.
+
+---
+
+#### `performLookup(int time, List<String> restrict_users, List<String> exclude_users, List<Object> restrict_blocks, List<Object> exclude_blocks, List<Integer> action_list, int radius, Location radius_location)`
+
+This will perform a lookup.
+
+* **time:** Specify the amount of time to search back. "5" would return results from the last 5 seconds.
+* **restrict_users:** Specify any usernames to perform the lookup on. Can be set to "null" if both a radius and a location are specified.
+* **exclude_users:** Specify any usernames to exclude from the lookup. Can be set to "null".
+* **restrict_blocks:** Specify a list of EntityType's or Material's to restrict the search to. Can be set to "null".
+* **exclude_blocks:** Specify a list of EntityType's or Material's to exclude from the search. Can be set to "null".
+* **action_list:** Specify a list of action types to restrict the search to. Can be set to "null"
+* **radius:** Specify a radius to restrict the search to. A location must be specified if using this. Set to "0" to disable.
+* **radius_location:** Specify a location to search around. Can be set to "null" if no radius is specified, and a user is specified.
+
+---
+
+#### `performRollback(int time, List<String> restrict_users, List<String> exclude_users, List<Object> restrict_blocks, List<Object> exclude_blocks, List<Integer> action_list, int radius, Location radius_location)`
+
+This will perform a rollback. Method must be called async.
+
+* **time:** Specify the amount of time to rollback. "5" would return results from the last 5 seconds.
+* **restrict_users:** Specify any usernames to perform the rollback on. Can be set to "null" if both a radius and a location are specified.
+* **exclude_users:** Specify any usernames to exclude from the rollback. Can be set to "null".
+* **restrict_blocks:** Specify a list of EntityType's or Material's to restrict the rollback to. Can be set to "null".
+* **exclude_blocks:** Specify a list of EntityType's or Material's to exclude from the rollback. Can be set to "null".
+* **action_list:** Specify a list of action types to restrict the rollback to. Can be set to "null"
+* **radius:** Specify a radius to restrict the rollback to. A location must be specified if using this. Set to "0" to disable.
+* **radius_location:** Specify a location to rollback around. Can be set to "null" if no radius is specified, and a user is specified.
+
+---
+
+#### `performRestore(int time, List<String> restrict_users, List<String> exclude_users, List<Object> restrict_blocks, List<Object> exclude_blocks, List<Integer> action_list, int radius, Location radius_location)`
+
+This will perform a restore.
+
+* **time:** Specify the amount of time to restore. "5" would return results from the last 5 seconds.
+* **restrict_users:** Specify any usernames to perform the restore on. Can be set to "null" if both a radius and a location are specified.
+* **exclude_users:** Specify any usernames to exclude from the restore. Can be set to "null".
+* **restrict_blocks:** Specify a list of EntityType's or Material's to restrict the restore to. Can be set to "null".
+* **exclude_blocks:** Specify a list of EntityType's or Material's to exclude from the restore. Can be set to "null".
+* **action_list:** Specify a list of action types to restrict the restore to. Can be set to "null"
+* **radius:** Specify a radius to restrict the restore to. A location must be specified if using this. Set to "0" to disable.
+* **radius_location:** Specify a location to restore around. Can be set to "null" if no radius is specified, and a user is specified.
+
+---
+
+#### `blockLookup(Block block, int time)`
+
+This will perform a full lookup on a single block.
+
+* **block:** The block to perform the lookup on.
+* **time:** Specify the amount of time to lookup. "5" would return results from the last 5 seconds.
+
+---
+
+#### `queueLookup(Block block)`
+
+This will search the consumer queue for changes on a block not yet saved in the database.
+
+* **block:** The block to perform the lookup on.
+
+---
+
+#### `sessionLookup(String user, int time)`
+
+This will perform a session lookup on a single player.
+
+* **user:** The username to perform the lookup on.
+* **time:** Specify the amount of time to lookup. "5" would return results from the last 5 seconds.
+
+---
+
+#### `ParseResult parseResult(String[] result)`
+
+This will parse results from a lookup. You'll then be able to view the following:
+
+* **getX():** Get the X coordinate of the block.
+* **getY():** Get the Y coordinate of the block.
+* **getZ():** Get the Z coordinate of the block.
+* **getType():** Get the Material of the block.
+* **getBlockData():** Get the BlockData of the block.
+* **getPlayer():** Get the username as a string.
+* **getTimestamp():** Get the time of the action.
+* **getActionId():** Get the action ID. (0=removed, 1=placed, 2=interaction)
+* **getActionString():** Get the action as a string. (Removal, Placement, Interaction)
+* **isRolledBack():** If the block is currently rolled back or not.
+* **worldName():** The name of the world the block is located in.
+
+---
+
+#### `logPlacement(String user, BlockState blockState)`
+
+This will log a block as being placed. *(Thread safe)*
+
+* **user:** Specify the username to log as having placed the block.
+* **blockState:** Specify the BlockState of the block you're logging.
+
+---
+
+#### `logPlacement(String user, Location location, Material type, BlockData blockData)`
+
+This will log a block as being placed.
+
+* **user:** Specify the username to log as having placed the block.
+* **location:** Specify the location of the block you're logging.
+* **type:** Specify the Material of the block you're logging.
+* **blockData:** Specify the BlockData of the block you're logging. Can be set to "null".
+
+---
+
+#### `logRemoval(String user, BlockState blockState)`
+
+This will log a block as being removed/broken. *(Thread safe)*
+
+* **user:** Specify the username to log as having removed the block.
+* **blockState:** Specify the BlockState of the block you're logging.
+
+---
+
+#### `logRemoval(String user, Location location, Material type, BlockData blockData)`
+
+This will log a block as being removed/broken, and will log the block's inventory (if applicable).
+
+* **user:** Specify the username to log as having removed the block.
+* **location:** Specify the location of the block you're logging.
+* **type:** Specify the Material of the block you're logging.
+* **blockData:** Specify the BlockData of the block you're logging. Can be set to "null".
+
+---
+
+#### `logContainerTransaction(String user, Location location)`
+
+This will log any transactions made to a block's inventory immediately after calling the method.
+
+* **user:** Specify the username to log as having added/removed the items.
+* **location:** Specify the location of the block inventory you're logging.
+
+---
+
+#### `logInteraction(String user, Location location)`
+
+This will log a block as having been interacted with.
+
+* **user:** Specify the username to log as having caused the interaction.
+* **location:** Specify the location of the interaction you're logging.
+
+---
+
+#### `hasPlaced(String user, Block block, int time, int offset)`
+
+This will return true if a user has already placed a block at the location within the specified time limit.
+
+* **user:** The username you're checking to see if they've placed a block already.
+* **block:** The block you're checking.
+* **time:** How far back to check. "5" would only check through the last 5 seconds of logged blocks.
+* **offset:** A time offset. "2" would ignore the last 2 seconds of most recently ignored data. (0 = no offset)
+
+---
+
+#### `hasRemoved(String user, Block block, int time, int offset)`
+
+This will return true if a user has already removed a block at the location within the specified time limit.
+
+* **user:** The username you're checking to see if they've removed a block already.
+* **block:** The block you're checking.
+* **time:** How far back to check. "5" would only check through the last 5 seconds of logged blocks.
+* **offset:** A time offset. "2" would ignore the last 2 seconds of most recently ignored data. (0 = no offset)
+
+---
+
+#### `performPurge(int time)`
+
+This will perform a purge on the CoreProtect database.
+
+* **time:** Purge any data earlier than this. "120" would purge any data older than 120 seconds (2 minutes).
+
+---
+
+
+### Examples
+
+- Get the last 60 seconds of block data for the user "Notch".
+```java
+CoreProtectAPI CoreProtect = getCoreProtect();
+if (CoreProtect != null){ // Ensure we have access to the API
+  List<String[]> lookup = CoreProtect.performLookup(60, Arrays.asList("Notch"), null, null, null, null, 0, null);
+  if (lookup != null){
+    for (String[] result : lookup){
+      ParseResult parseResult = CoreProtect.parseResult(result);
+      int x = parseResult.getX();
+      int y = parseResult.getY();
+      int z = parseResult.getZ();
+      // ...
+    }
+  }
+}
+``` 
+
+---
+
+- Get the last 60 seconds of block data for the user "Notch", excluding dirt and grass blocks.
+```java
+CoreProtectAPI CoreProtect = getCoreProtect();
+if (CoreProtect != null){ // Ensure we have access to the API
+  List<Object> exclude = Arrays.asList(Material.DIRT, Material.GRASS);
+  List<String[]> lookup = CoreProtect.performLookup(60, Arrays.asList("Notch"), null, null, exclude, null, 0, null);
+  if (lookup != null){
+    for (String[] value : lookup){
+      ParseResult result = CoreProtect.parseResult(value);
+      int x = result.getX();
+      int y = result.getY();
+      int z = result.getZ();
+      // ...
+    }
+  }
+}
+``` 
+
+---
+
+- Get the last 60 seconds of block data within 5 blocks of a location.
+```java
+CoreProtectAPI CoreProtect = getCoreProtect();
+if (CoreProtect != null){ // Ensure we have access to the API
+  List<String[]> lookup = CoreProtect.performLookup(60, null, null, null, null, null, 5, location);
+  if (lookup != null){
+    for (String[] value : lookup){
+      ParseResult result = CoreProtect.parseResult(value);
+      int x = result.getX();
+      int y = result.getY();
+      int z = result.getZ();
+      // ...
+    }
+  }
+}
+``` 
+
+---
+
+- Rollbacks / restores use the same code structure as the above examples. For example:
+```java
+class BasicThread implements Runnable {
+@Override
+public void run() {
+  try {
+    CoreProtectAPI CoreProtect = getCoreProtect();
+    if (CoreProtect != null){ // Ensure we have access to the API
+      List<String[]> lookup = CoreProtect.performRollback(60, Arrays.asList("Notch"), null, null, null, null, 0, null);
+      if (lookup != null){
+        for (String[] value : lookup){
+          ParseResult result = CoreProtect.parseResult(value);
+          int x = result.getX();
+          int y = result.getY();
+          int z = result.getZ();
+          // ...
+        }
+      }
+    }
+  }
+  catch (Exception e){
+    e.printStackTrace(); 
+  }
+}
+}
+Runnable runnable = new BasicThread();
+Thread thread = new Thread(runnable);
+thread.start();
+``` 
+
+---
+
+- Check if the user "Notch" has already placed a block at a location within the last 60 seconds.
+```java
+CoreProtectAPI CoreProtect = getCoreProtect();
+if (CoreProtect != null){ // Ensure we have access to the API
+  boolean hasPlaced = CoreProtect.hasPlaced("Notch", block, 60, 0);
+  
+  // Search queue for pending changes
+  if (!hasPlaced){
+    List<String[]> lookup = CoreProtect.queueLookup(block);
+    for (String[] result : lookup){
+      ParseResult parseResult = CoreProtect.parseResult(result);
+      if (parseResult.getActionId()==1 && parseResult.getPlayer().equals("Notch")){
+        hasPlaced = true;
+        break;
+      }
+    }
+  }
+}
+``` 
+
+---
+
+- Get the last 60 seconds of block data for a specific block.
+```java
+CoreProtectAPI CoreProtect = getCoreProtect();
+if (CoreProtect != null){ // Ensure we have access to the API
+  List<String[]> lookup = CoreProtect.blockLookup(block, 60);
+  if (lookup != null){
+    for (String[] result : lookup){
+      ParseResult parseResult = CoreProtect.parseResult(result);
+      int x = parseResult.getX();
+      int y = parseResult.getY();
+      int z = parseResult.getZ();
+      // ...
+    }
+  }
+}
+``` 
+
+---
+
+- Get the last 1 day of session data for the user "Notch".
+```java
+CoreProtectAPI CoreProtect = getCoreProtect();
+if (CoreProtect != null){ // Ensure we have access to the API
+  List<String[]> lookup = CoreProtect.sessionLookup("Notch", (24 * 60 * 60));
+  if (lookup != null){
+    for (String[] result : lookup){
+      ParseResult parseResult = CoreProtect.parseResult(result);
+      int x = parseResult.getX();
+      int y = parseResult.getY();
+      int z = parseResult.getZ();
+      int action = parseResult.getActionId(); // 0 = logout, 1 = login
+      // ...
+    }
+  }
+}
+``` 
+
+---
+
+- Log the placement of a block at a location by the user "Notch".
+```java
+CoreProtectAPI CoreProtect = getCoreProtect();
+if (CoreProtect != null){ // Ensure we have access to the API
+  boolean success = CoreProtect.logPlacement("Notch", block.getLocation(), block.getType(), block.getData());
+}
+``` 
+
+---
+
+- Log adding/remove items in a chest (or some other block inventory).
+```java
+CoreProtectAPI CoreProtect = getCoreProtect();
+if (CoreProtect != null){ // Ensure we have access to the API
+  boolean success = CoreProtect.logContainerTransaction("Notch", inventory.getLocation());
+  // modify your container contents immediately after (e.g. [i]inventory.addItem(itemStack);[/i])
+}
+``` 
+
+---
+
+- Perform a multi-threaded placement check to see if the user "Notch" has already placed a block at a location within the last 60 seconds. This ignores the most recent 1 second of logged data, to account for the fact that that new block data may have already been logged, depending on your code.
+```java
+final Block block = null; //Should be an actual block
+class BasicThread implements Runnable {
+  @Override
+  public void run() {
+    try {
+      CoreProtectAPI CoreProtect = getCoreProtect();
+      if (CoreProtect != null){ // Ensure we have access to the API
+        boolean hasPlaced = CoreProtect.hasPlaced("Notch", block, 60, 1);
+      }
+    }
+    catch (Exception e){
+      e.printStackTrace(); 
+    }
+  }
+}
+Runnable runnable = new BasicThread();
+Thread thread = new Thread(runnable);
+thread.start();
+``` 
+
+---

pom.xml

@@ -88,11 +88,18 @@
       <id>codemc-repo</id>
       <url>https://repo.codemc.org/repository/maven-public/</url>
     </repository>
-    <repository>
-      <id>enginehub-repo</id>
-      <url>https://maven.enginehub.org/repo/</url>
-    </repository>
   </repositories>
+  <dependencyManagement>
+    <dependencies>
+      <dependency>
+        <groupId>com.intellectualsites.bom</groupId>
+        <artifactId>bom-newest</artifactId> <!--  Ref: https://github.com/IntellectualSites/bom -->
+        <version>1.44</version>
+        <scope>import</scope>
+        <type>pom</type>
+      </dependency>
+    </dependencies>
+  </dependencyManagement>
   <dependencies>
     <!--
     paper-api: io.papermc.paper
@@ -113,14 +120,18 @@
       <scope>compile</scope>
     </dependency>
     <dependency>
-      <groupId>com.sk89q.worldedit</groupId>
-      <artifactId>worldedit-bukkit</artifactId>
-      <version>7.0.0-SNAPSHOT</version>
+      <groupId>com.fastasyncworldedit</groupId>
+      <artifactId>FastAsyncWorldEdit-Core</artifactId>
+      <scope>provided</scope>
+    </dependency>
+    <dependency>
+      <groupId>com.fastasyncworldedit</groupId>
+      <artifactId>FastAsyncWorldEdit-Bukkit</artifactId>
       <scope>provided</scope>
       <exclusions>
         <exclusion>
-          <groupId>org.bukkit</groupId>
-          <artifactId>bukkit</artifactId>
+          <artifactId>FastAsyncWorldEdit-Core</artifactId>
+          <groupId>*</groupId>
         </exclusion>
       </exclusions>
     </dependency>

src/main/java/net/coreprotect/CoreProtectAPI.java

@@ -168,7 +168,7 @@ public class CoreProtectAPI extends Queue {
     }
 
     public int APIVersion() {
-        return 9;
+        return 10;
     }
 
     public List<String[]> blockLookup(Block block, int time) {
@@ -282,6 +282,19 @@ public class CoreProtectAPI extends Queue {
         return false;
     }
 
+    public boolean logPlacement(String user, BlockState blockState) {
+        if (!Config.getGlobal().API_ENABLED) {
+            return false;
+        }
+
+        if (blockState == null || user == null || user.length() == 0) {
+            return false;
+        }
+
+        Queue.queueBlockPlace(user, blockState, blockState.getType(), null, blockState.getType(), -1, 0, blockState.getBlockData().getAsString());
+        return true;
+    }
+
     public boolean logPlacement(String user, Location location, Material type, BlockData blockData) {
         if (Config.getGlobal().API_ENABLED) {
             if (user != null && location != null) {
@@ -316,6 +329,19 @@ public class CoreProtectAPI extends Queue {
         return false;
     }
 
+    public boolean logRemoval(String user, BlockState blockState) {
+        if (!Config.getGlobal().API_ENABLED) {
+            return false;
+        }
+
+        if (blockState == null || user == null || user.length() == 0) {
+            return false;
+        }
+
+        Queue.queueBlockBreak(user, blockState, blockState.getType(), blockState.getBlockData().getAsString(), 0);
+        return true;
+    }
+
     public boolean logRemoval(String user, Location location, Material type, BlockData blockData) {
         if (Config.getGlobal().API_ENABLED) {
             if (user != null && location != null) {

src/main/java/net/coreprotect/config/Config.java

@@ -41,7 +41,6 @@ public class Config extends Language {
     public String MYSQL_USERNAME;
     public String MYSQL_PASSWORD;
     public String LANGUAGE;
-    public boolean ENABLE_AWE;
     public boolean ENABLE_SSL;
     public boolean DISABLE_WAL;
     public boolean HOVER_EVENTS;
@@ -189,7 +188,6 @@ public class Config extends Language {
     }
 
     private void readValues() {
-        this.ENABLE_AWE = this.getBoolean("enable-awe", false);
         this.ENABLE_SSL = this.getBoolean("enable-ssl", false);
         this.DISABLE_WAL = this.getBoolean("disable-wal", false);
         this.HOVER_EVENTS = this.getBoolean("hover-events", true);

src/main/java/net/coreprotect/worldedit/CoreProtectEditSessionEvent.java

@@ -1,90 +1,99 @@
 package net.coreprotect.worldedit;
 
-import org.bukkit.Bukkit;
-
 import com.sk89q.worldedit.EditSession.Stage;
 import com.sk89q.worldedit.WorldEdit;
 import com.sk89q.worldedit.event.extent.EditSessionEvent;
-import com.sk89q.worldedit.extension.platform.Actor;
 import com.sk89q.worldedit.util.eventbus.Subscribe;
-import com.sk89q.worldedit.world.World;
-
 import net.coreprotect.CoreProtect;
-import net.coreprotect.config.Config;
 import net.coreprotect.config.ConfigHandler;
 import net.coreprotect.language.Phrase;
 import net.coreprotect.language.Selector;
 import net.coreprotect.thread.Scheduler;
 import net.coreprotect.utility.Chat;
+import org.bukkit.Bukkit;
 
-public class CoreProtectEditSessionEvent {
-
+public class CoreProtectEditSessionEvent
+{
     private static boolean initialized = false;
     private static boolean isFAWE = false;
     private static CoreProtectEditSessionEvent event = new CoreProtectEditSessionEvent();
 
-    public static boolean isInitialized() {
+    public static boolean isInitialized()
+    {
         return initialized;
     }
 
-    public static boolean isFAWE() {
+    public static boolean isFAWE()
+    {
         return isFAWE;
     }
 
-    public static void register() {
-        if (isInitialized()) {
+    public static void register()
+    {
+        if (isInitialized())
+        {
             return;
         }
 
-        try {
-            if (Bukkit.getServer().getPluginManager().getPlugin("AsyncWorldEdit") == null || Config.getGlobal().ENABLE_AWE) {
-                WorldEdit.getInstance().getEventBus().register(event);
-                initialized = true;
-                ConfigHandler.worldeditEnabled = true;
-                isFAWE = (Bukkit.getServer().getPluginManager().getPlugin("FastAsyncWorldEdit") != null);
-            }
+        try
+        {
+            WorldEdit.getInstance().getEventBus().register(new Object()
+            {
+                @Subscribe
+                public void onEditSessionEvent(EditSessionEvent event)
+                {
+                    if (event.getActor() != null && event.getStage() == Stage.BEFORE_CHANGE)
+                    {
+                        event.setExtent(new CoreProtectLogger(event.getActor(), event.getWorld(), event.getExtent()));
+                    }
+                }
+            });
+            initialized = true;
+            ConfigHandler.worldeditEnabled = true;
+            isFAWE = (Bukkit.getServer().getPluginManager().getPlugin("FastAsyncWorldEdit") != null);
         }
-        catch (Exception e) {
+        catch (Exception e)
+        {
             // Failed to initialize WorldEdit logging
         }
 
-        Scheduler.runTask(CoreProtect.getInstance(), () -> {
-            try {
-                if (isInitialized()) {
-                    Chat.console(Phrase.build(Phrase.INTEGRATION_SUCCESS, "WorldEdit", Selector.FIRST));
+        Scheduler.runTask(CoreProtect.getInstance(), () ->
+        {
+            try
+            {
+                if (isInitialized())
+                {
+                    Chat.console(Phrase.build(Phrase.INTEGRATION_SUCCESS, isFAWE() ? "FastAsyncWorldEdit" : "WorldEdit", Selector.FIRST));
                 }
-                else {
-                    Chat.console(Phrase.build(Phrase.INTEGRATION_ERROR, "WorldEdit", Selector.FIRST));
+                else
+                {
+                    Chat.console(Phrase.build(Phrase.INTEGRATION_ERROR, isFAWE() ? "FastAsyncWorldEdit" : "WorldEdit", Selector.FIRST));
                 }
             }
-            catch (Exception e) {
+            catch (Exception e)
+            {
                 e.printStackTrace();
             }
         });
     }
 
-    public static void unregister() {
-        if (!isInitialized()) {
+    public static void unregister()
+    {
+        if (!isInitialized())
+        {
             return;
         }
 
-        try {
+        try
+        {
             WorldEdit.getInstance().getEventBus().unregister(event);
             initialized = false;
             ConfigHandler.worldeditEnabled = false;
-            Chat.console(Phrase.build(Phrase.INTEGRATION_SUCCESS, "WorldEdit", Selector.SECOND));
+            Chat.console(Phrase.build(Phrase.INTEGRATION_SUCCESS, isFAWE() ? "FastAsyncWorldEdit" : "WorldEdit", Selector.SECOND));
         }
-        catch (Exception e) {
-            Chat.console(Phrase.build(Phrase.INTEGRATION_ERROR, "WorldEdit", Selector.SECOND));
-        }
-    }
-
-    @Subscribe
-    public void wrapForLogging(EditSessionEvent event) {
-        Actor actor = event.getActor();
-        World world = event.getWorld();
-        if (actor != null && event.getStage() == (isFAWE ? Stage.BEFORE_HISTORY : Stage.BEFORE_CHANGE)) {
-            event.setExtent(new CoreProtectLogger(actor, world, event.getExtent()));
+        catch (Exception e)
+        {
+            Chat.console(Phrase.build(Phrase.INTEGRATION_ERROR, isFAWE() ? "FastAsyncWorldEdit" : "WorldEdit", Selector.SECOND));
         }
     }
 }

src/main/java/net/coreprotect/worldedit/CoreProtectLogger.java

@@ -1,30 +1,33 @@
 package net.coreprotect.worldedit;
 
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.inventory.ItemStack;
-
+import com.sk89q.worldedit.MaxChangedBlocksException;
 import com.sk89q.worldedit.WorldEditException;
 import com.sk89q.worldedit.bukkit.BukkitAdapter;
 import com.sk89q.worldedit.extension.platform.Actor;
 import com.sk89q.worldedit.extent.AbstractDelegateExtent;
 import com.sk89q.worldedit.extent.Extent;
+import com.sk89q.worldedit.function.mask.Mask;
+import com.sk89q.worldedit.function.pattern.Pattern;
 import com.sk89q.worldedit.math.BlockVector3;
+import com.sk89q.worldedit.regions.Region;
 import com.sk89q.worldedit.world.World;
 import com.sk89q.worldedit.world.block.BaseBlock;
 import com.sk89q.worldedit.world.block.BlockState;
 import com.sk89q.worldedit.world.block.BlockStateHolder;
-
 import net.coreprotect.config.Config;
 import net.coreprotect.utility.Util;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
 
-public class CoreProtectLogger extends AbstractDelegateExtent {
-
+public class CoreProtectLogger extends AbstractDelegateExtent
+{
     private final Actor eventActor;
     private final World eventWorld;
     private final Extent eventExtent;
 
-    protected CoreProtectLogger(Actor actor, World world, Extent extent) {
+    protected CoreProtectLogger(Actor actor, World world, Extent extent)
+    {
         super(extent);
         this.eventActor = actor;
         this.eventWorld = world;
@@ -32,10 +35,19 @@ public class CoreProtectLogger extends AbstractDelegateExtent {
     }
 
     @Override
-    public <T extends BlockStateHolder<T>> boolean setBlock(BlockVector3 position, T block) throws WorldEditException {
+    public <T extends BlockStateHolder<T>> boolean setBlock(BlockVector3 position, T block) throws WorldEditException
+    {
         org.bukkit.World world = BukkitAdapter.adapt(eventWorld);
-        if (!Config.getConfig(world).WORLDEDIT) {
-            return eventExtent.setBlock(position, block);
+        if (!Config.getConfig(world).WORLDEDIT)
+        {
+            if (CoreProtectEditSessionEvent.isFAWE())
+            {
+                return eventExtent.setBlock(position.getX(), position.getY(), position.getZ(), block);
+            }
+            else
+            {
+                return eventExtent.setBlock(position, block);
+            }
         }
 
         BlockState oldBlock = eventExtent.getBlock(position);
@@ -48,16 +60,70 @@ public class CoreProtectLogger extends AbstractDelegateExtent {
         // e.g. BaseBlock block = eventWorld.getBlock(position);
         ItemStack[] containerData = CoreProtectEditSessionEvent.isFAWE() ? null : Util.getContainerContents(oldType, null, location);
 
-        if (eventExtent.setBlock(position, block)) {
-            WorldEditLogger.postProcess(eventExtent, eventActor, position, location, block, baseBlock, oldType, oldBlock, containerData);
-            return true;
+        if (CoreProtectEditSessionEvent.isFAWE())
+        {
+            if (eventExtent.setBlock(position.getX(), position.getY(), position.getZ(), block))
+            {
+                WorldEditLogger.postProcess(eventExtent, eventActor, position, location, block, baseBlock, oldType, oldBlock, containerData);
+                return true;
+            }
+        }
+        else
+        {
+            if (eventExtent.setBlock(position, block))
+            {
+                WorldEditLogger.postProcess(eventExtent, eventActor, position, location, block, baseBlock, oldType, oldBlock, containerData);
+                return true;
+            }
         }
 
         return false;
     }
 
-    public <T extends BlockStateHolder<T>> boolean setBlock(int x, int y, int z, T block) throws WorldEditException {
-        return setBlock(BlockVector3.at(x,y,z), block);
+    @Override
+    public <T extends BlockStateHolder<T>> boolean setBlock(int x, int y, int z, T block) throws WorldEditException
+    {
+        return this.setBlock(BlockVector3.at(x, y, z), block);
     }
 
-}
+    @Override
+    public int replaceBlocks(final Region region, final Mask mask, final Pattern pattern) throws MaxChangedBlocksException
+    {
+        org.bukkit.World world = BukkitAdapter.adapt(eventWorld);
+        if (!Config.getConfig(world).WORLDEDIT)
+        {
+            return eventExtent.replaceBlocks(region, mask, pattern);
+        }
+        processPatternToBlocks(world, region, pattern);
+        return eventExtent.replaceBlocks(region, mask, pattern);
+    }
+
+    @Override
+    public int setBlocks(Region region, Pattern pattern) throws MaxChangedBlocksException
+    {
+        org.bukkit.World world = BukkitAdapter.adapt(eventWorld);
+        if (!Config.getConfig(world).WORLDEDIT)
+        {
+            return eventExtent.setBlocks(region, pattern);
+        }
+        processPatternToBlocks(world, region, pattern);
+        return eventExtent.setBlocks(region, pattern);
+    }
+
+    private void processPatternToBlocks(org.bukkit.World world, Region region, Pattern pattern)
+    {
+        for (BlockVector3 position : region.clone())
+        {
+            BlockState oldBlock = eventExtent.getBlock(position);
+            Material oldType = BukkitAdapter.adapt(oldBlock.getBlockType());
+            Location location = new Location(world, position.getBlockX(), position.getBlockY(), position.getBlockZ());
+            BaseBlock baseBlock = WorldEditLogger.getBaseBlock(eventExtent, position, location, oldType, oldBlock);
+
+            // No clear way to get container content data from within the WorldEdit API
+            // Data may be available by converting oldBlock.toBaseBlock().getNbtData()
+            // e.g. BaseBlock block = eventWorld.getBlock(position);
+            ItemStack[] containerData = CoreProtectEditSessionEvent.isFAWE() ? null : Util.getContainerContents(oldType, null, location);
+            WorldEditLogger.postProcess(eventExtent, eventActor, position, location, pattern.applyBlock(position), baseBlock, oldType, oldBlock, containerData);
+        }
+    }
+}