Update to 26.2

Jenkinsfile

@@ -3,7 +3,23 @@ pipeline {
     stages {
         stage('Gradle') {
             steps {
-                sh 'bash gradlew build'
+                withCredentials([usernamePassword(credentialsId: 'alttd-snapshot-user', usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD')]) {
+                sh '''
+                  set +x
+                  chmod +x gradlew
+                  ./gradlew build -PalttdSnapshotUsername=$USERNAME -PalttdSnapshotPassword=$PASSWORD
+                '''
+                }
+            }
+        }
+        stage('Publish to Maven') {
+            steps {
+               withCredentials([usernamePassword(credentialsId: 'alttd-publish-user', usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD')]) {
+                 sh '''
+                   chmod +x gradlew
+                   ./gradlew publish -PalttdDevPublishUser=$USERNAME -PalttdDevPublishPass=$PASSWORD
+                 '''
+               }
             }
         }
         stage('Archive') {

build.gradle.kts

@@ -1,21 +1,15 @@
 plugins {
     id("java")
-    id("com.github.johnrengelman.shadow") version "7.1.1"
+    id("com.gradleup.shadow") version "9.6.1"
     id("maven-publish")
 }
 
 group = "com.alttd"
-version = "1.0.0-SNAPSHOT"
+version = System.getenv("BUILD_NUMBER") ?: "1.1-SNAPSHOT"
 description = "Altitude Villager Shop plugin."
 
 apply<JavaLibraryPlugin>()
 
-java {
-    toolchain {
-        languageVersion.set(JavaLanguageVersion.of(21))
-    }
-}
-
 publishing {
     publications {
         create<MavenPublication>("mavenJava") {
@@ -58,9 +52,7 @@ tasks {
 }
 
 dependencies {
-    compileOnly("com.alttd.cosmos:cosmos-api:1.21.6-R0.1-SNAPSHOT") {
-        isChanging = true
-    }
+    compileOnly("com.alttd.cosmos:cosmos-api:26.2.build.17-stable")
     compileOnly("com.github.milkbowl:VaultAPI:1.7") {
         exclude("org.bukkit","bukkit")
     }

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,7 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.4.1-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 #
-# Copyright © 2015-2021 the original authors.
+# Copyright © 2015 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,6 +15,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# SPDX-License-Identifier: Apache-2.0
+#
 
 ##############################################################################
 #
@@ -55,7 +57,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/b631911858264c0b6e4d6603d677ff5218766cee/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -80,13 +82,11 @@ do
     esac
 done
 
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-
-APP_NAME="Gradle"
+# This is normally unused
+# shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -114,7 +114,6 @@ case "$( uname )" in                #(
   NONSTOP* )        nonstop=true ;;
 esac
 
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
 
 # Determine the Java command to use to start the JVM.
@@ -133,22 +132,29 @@ location of your Java installation."
     fi
 else
     JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
 if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
     case $MAX_FD in #(
       max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
         MAX_FD=$( ulimit -H -n ) ||
             warn "Could not query maximum file descriptor limit"
     esac
     case $MAX_FD in  #(
       '' | soft) :;; #(
       *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
         ulimit -n "$MAX_FD" ||
             warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
@@ -165,7 +171,6 @@ fi
 # For Cygwin or MSYS, switch paths to Windows format before running java
 if "$cygwin" || "$msys" ; then
     APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
 
     JAVACMD=$( cygpath --unix "$JAVACMD" )
 
@@ -193,18 +198,27 @@ if "$cygwin" || "$msys" ; then
     done
 fi
 
-# Collect all arguments for the java command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
 
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
         "$@"
 
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
 # Use "xargs" to parse quoted args.
 #
 # With -n1 it outputs one arg per line, with the quotes and backslashes removed.

gradlew.bat

@@ -13,8 +13,10 @@
 @rem See the License for the specific language governing permissions and
 @rem limitations under the License.
 @rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
 
-@if "%DEBUG%" == "" @echo off
+@if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
@@ -25,7 +27,8 @@
 if "%OS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
@@ -40,13 +43,13 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto execute
+if %ERRORLEVEL% equ 0 goto execute
 
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
@@ -56,32 +59,33 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
 if exist "%JAVA_EXE%" goto execute
 
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
 :execute
 @rem Setup the command line
 
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
 
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
 
 :end
 @rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
+if %ERRORLEVEL% equ 0 goto mainEnd
 
 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal

settings.gradle.kts

@@ -1,20 +1,26 @@
 rootProject.name = "VillagerShopUI"
 
-val nexusUser = providers.gradleProperty("alttdSnapshotUsername").get()
-val nexusPass = providers.gradleProperty("alttdSnapshotPassword").get()
+val nexusUser = providers.gradleProperty("alttdSnapshotUsername").orNull ?: System.getenv("NEXUS_USERNAME")
+val nexusPass = providers.gradleProperty("alttdSnapshotPassword").orNull ?: System.getenv("NEXUS_PASSWORD")
 
 dependencyResolutionManagement {
     repositories {
         mavenLocal()
         mavenCentral()
         maven {
-            name = "nexus"
             url = uri("https://repo.alttd.com/repository/alttd-snapshot/")
             credentials {
                 username = nexusUser
                 password = nexusPass
             }
         }
+        maven {
+            url = uri("https://repo.alttd.com/repository/alttd/")
+            credentials {
+                username = nexusUser
+                password = nexusPass
+            }
+        }
         maven("https://repo.destro.xyz/snapshots") // Cosmos
         maven("https://jitpack.io") { // Vault
             content { includeGroup("com.github.milkbowl") }

src/main/java/com/alttd/VillagerUI.java

@@ -11,6 +11,7 @@ import com.alttd.datalock.DataLockAPI;
 import com.alttd.events.*;
 import com.alttd.logging.LogInOut;
 import com.alttd.objects.EconUser;
+import com.alttd.util.auto_sell.AutoSellTask;
 import com.alttd.util.Logger;
 import com.alttd.util.SaveTask;
 import net.milkbowl.vault.economy.Economy;
@@ -36,15 +37,16 @@ public class VillagerUI extends JavaPlugin {
     @Override
     public void onEnable() {
         logInOut = new LogInOut();
-        registerEvents();
-        new CommandManager();
+        AutoSellTask autoSellTask = new AutoSellTask();
+        registerEvents(autoSellTask);
+        new CommandManager(autoSellTask);
         Config.reload();
         VillagerConfig.reload();
         WorthConfig.reload();
         if (!setupEconomy())
             return;
         Database.getDatabase().init();
-        scheduleTasks();
+        scheduleTasks(autoSellTask);
         DataLockAPI dataLockAPI = DataLockAPI.get();
         if (dataLockAPI == null) {
             Logger.severe("Unable to load datalockapi");
@@ -68,7 +70,7 @@ public class VillagerUI extends JavaPlugin {
         logInOut.run();
     }
 
-    private void scheduleTasks() {
+    private void scheduleTasks(AutoSellTask autoSellTask) {
         new SaveTask().runTaskTimerAsynchronously(
                 this,
                 0,
@@ -77,9 +79,14 @@ public class VillagerUI extends JavaPlugin {
                 this,
                 0,
                 20);
+        autoSellTask.runTaskTimerAsynchronously(
+                this,
+                10 * 20,
+                10 * 20
+        );
     }
 
-    private void registerEvents() {
+    private void registerEvents(AutoSellTask autoSellTask) {
         getServer().getPluginManager().registerEvents(new GUIListener(), this);
         getServer().getPluginManager().registerEvents(new VillagerEvents(), this);
         getServer().getPluginManager().registerEvents(new LogoutEvent(), this);
@@ -87,6 +94,7 @@ public class VillagerUI extends JavaPlugin {
         getServer().getPluginManager().registerEvents(new VehicleEvent(), this);
         getServer().getPluginManager().registerEvents(new SpawnShopListener(logInOut), this);
         getServer().getPluginManager().registerEvents(new DataLock(), this);
+        getServer().getPluginManager().registerEvents(new ItemPickupEvent(autoSellTask), this);
     }
 
     public Economy getEconomy() {

src/main/java/com/alttd/commands/CommandManager.java

@@ -3,6 +3,7 @@ package com.alttd.commands;
 import com.alttd.VillagerUI;
 import com.alttd.commands.subcommands.*;
 import com.alttd.config.Config;
+import com.alttd.util.auto_sell.AutoSellTask;
 import com.alttd.util.Logger;
 import net.kyori.adventure.text.minimessage.MiniMessage;
 import org.bukkit.command.*;
@@ -18,7 +19,7 @@ public class CommandManager implements CommandExecutor, TabExecutor {
     private final List<SubCommand> subCommands;
     private final MiniMessage miniMessage;
 
-    public CommandManager() {
+    public CommandManager(AutoSellTask autoSellTask) {
         VillagerUI villagerUI = VillagerUI.getInstance();
 
         PluginCommand command = villagerUI.getCommand("villagerui");
@@ -36,8 +37,10 @@ public class CommandManager implements CommandExecutor, TabExecutor {
                 new CommandPoints(),
                 new CommandBuy(),
                 new CommandSell(),
+                new CommandAutoSell(autoSellTask),
                 new CommandCreateVillager(),
                 new CommandReload(),
+                new CommandReset(),
                 new CommandRemoveVillager());
         miniMessage = MiniMessage.miniMessage();
     }

src/main/java/com/alttd/commands/subcommands/CommandAutoSell.java

@@ -0,0 +1,130 @@
+package com.alttd.commands.subcommands;
+
+import com.alttd.commands.SubCommand;
+import com.alttd.config.Config;
+import com.alttd.objects.VillagerTypeManager;
+import com.alttd.util.auto_sell.AutoSellTask;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.ComponentLike;
+import net.kyori.adventure.text.JoinConfiguration;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
+import org.bukkit.Material;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+
+public class CommandAutoSell extends SubCommand {
+
+    private final AutoSellTask autoSellTask;
+    private final MiniMessage miniMessage = MiniMessage.miniMessage();
+
+    public CommandAutoSell(AutoSellTask autoSellTask) {
+        this.autoSellTask = autoSellTask;
+    }
+
+    @Override
+    public boolean onCommand(CommandSender commandSender, String[] args) {
+        if (!(commandSender instanceof Player player)) {
+            commandSender.sendRichMessage(Config.NO_CONSOLE);
+            return true;
+        }
+        if (args.length == 1) {
+            sendActiveList(player);
+        } else if (args.length == 2) {
+            if (args[1].equalsIgnoreCase("off")) {
+                turnOffAutoSell(player);
+            } else {
+                toggleMaterial(player, args[1]);
+            }
+        } else {
+            player.sendRichMessage(getHelpMessage());
+        }
+        return true;
+    }
+
+    private void sendActiveList(Player player) {
+        UUID uuid = player.getUniqueId();
+        if (!autoSellTask.hasAutoSellEntry(uuid)) {
+            player.sendRichMessage(Config.NO_AUTO_SELL_ITEMS);
+            return;
+        }
+        Set<Material> materials = autoSellTask.getAutoSellList(uuid);
+        List<Component> materialComponents = materials.stream().map(Material::name)
+                                                      .map(material -> miniMessage.deserialize(
+                                                              Config.LIST_AUTO_SELL_COMPONENT,
+                                                              Placeholder.parsed("material", material))).toList();
+
+        Component deserialize = miniMessage.deserialize(Config.LIST_AUTO_SELL_ITEMS);
+        Component joinedMaterialComponents = Component.join(JoinConfiguration.newlines(), materialComponents);
+        ComponentLike message = Component.join(JoinConfiguration.newlines(), deserialize, joinedMaterialComponents);
+        player.sendMessage(message);
+    }
+
+    private void turnOffAutoSell(Player player) {
+        autoSellTask.clearAutoSell(player);
+        player.sendRichMessage(Config.DISABLED_AUTO_SELL);
+    }
+
+    private void toggleMaterial(Player player, String stringMaterial) {
+        Material material = Material.getMaterial(stringMaterial.toUpperCase());
+        if (material == null) {
+            player.sendRichMessage(Config.INVALID_AUTO_SELL_ITEM, Placeholder.parsed("material", stringMaterial));
+            return;
+        }
+        UUID uuid = player.getUniqueId();
+
+        boolean autoSellToggledOn = autoSellTask.toggleAutoSell(uuid, material);
+
+        TagResolver.Single materialPlaceholder = Placeholder.parsed("material", material.name());
+
+        if (autoSellToggledOn && autoSellTask.getEntries(uuid) > Config.MAX_AUTO_SELL) {
+            autoSellTask.removeAutoSell(uuid, material);
+            player.sendRichMessage(Config.MAX_AUTO_SELL_REACHED,
+                    Placeholder.parsed("max_auto_sell", String.valueOf(Config.MAX_AUTO_SELL)));
+            return;
+        }
+        if (autoSellToggledOn) {
+            player.sendRichMessage(Config.TURNED_ON_AUTO_SELL_FOR, materialPlaceholder);
+        } else {
+            player.sendRichMessage(Config.TURNED_OFF_AUTO_SELL_FOR, materialPlaceholder);
+        }
+    }
+
+    @Override
+    public String getName() {
+        return "autosell";
+    }
+
+    @Override
+    public List<String> getTabComplete(CommandSender commandSender, String[] args) {
+        if (args.length != 2) {
+            return List.of();
+        }
+        ArrayList<String> tabComplete = new ArrayList<>();
+        tabComplete.add("off");
+        tabComplete.addAll(VillagerTypeManager
+                .getVillagerTypes()
+                .stream()
+                .flatMap(villagerType -> villagerType
+                        .getSelling()
+                        .stream()
+                        .map(ItemStack::getType)
+                )
+                .map(material -> material.name().toLowerCase())
+                .toList());
+        tabComplete.removeIf(string -> !string.toLowerCase().startsWith(args[1].toLowerCase()));
+        return tabComplete;
+    }
+
+    @Override
+    public String getHelpMessage() {
+        return Config.AUTO_SELL_MESSAGE;
+    }
+}

src/main/java/com/alttd/commands/subcommands/CommandReset.java

@@ -0,0 +1,75 @@
+package com.alttd.commands.subcommands;
+
+import com.alttd.commands.SubCommand;
+import com.alttd.config.Config;
+import com.alttd.objects.EconUser;
+import com.alttd.objects.VillagerType;
+import com.alttd.objects.VillagerTypeManager;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+public class CommandReset extends SubCommand {
+
+    @Override
+    public boolean onCommand(CommandSender commandSender, String[] args) {
+        if (args.length != 2) {
+            commandSender.sendRichMessage(getHelpMessage());
+            return true;
+        }
+        if (!(commandSender instanceof Player player)) {
+            commandSender.sendRichMessage(Config.NO_CONSOLE);
+            return true;
+        }
+        EconUser user = EconUser.getUser(player.getUniqueId());
+        if (user == null) {
+            player.sendRichMessage(Config.LOADING_ECON_DATA);
+            return true;
+        }
+
+        if (args[1].equals("all")) {
+            VillagerTypeManager.getVillagerTypes().forEach(villagerType -> resetPoints(user, villagerType));
+        } else {
+            Optional<VillagerType> optionalVillagerType = VillagerTypeManager.getVillagerType(args[1].toLowerCase());
+            if (optionalVillagerType.isEmpty()) {
+                player.sendRichMessage(Config.NOT_A_VILLAGER, TagResolver.resolver(Placeholder.unparsed("villager_type", args[1])));
+                return true;
+            }
+            resetPoints(user, optionalVillagerType.get());
+        }
+
+        return true;
+    }
+
+    private void resetPoints(EconUser user, VillagerType villagerType) {
+        int pointsToRemove = user.getPointsMap().getOrDefault(villagerType.getName(), 0);
+        user.addPoints(villagerType.getName(), pointsToRemove * -1);
+    }
+
+    @Override
+    public String getName() {
+        return "reset";
+    }
+
+    @Override
+    public List<String> getTabComplete(CommandSender commandSender, String[] args) {
+        List<String> res = new ArrayList<>();
+        if (args.length == 2) {
+            res.addAll(VillagerTypeManager.getVillagerTypes().stream()
+                               .map(VillagerType::getName)
+                               .toList());
+        }
+        res.add("all");
+        return res;
+    }
+
+    @Override
+    public String getHelpMessage() {
+        return Config.RESET_POINTS_MESSAGE;
+    }
+}

src/main/java/com/alttd/config/Config.java

@@ -68,21 +68,25 @@ public final class Config extends AbstractConfig {
     public static String HELP_MESSAGE_WRAPPER = "<gold>VillagerShopUI help:\n<commands></gold>";
     public static String HELP_MESSAGE = "<green>Show this menu: <gold>/villagerui help</gold></green>";
     public static String POINTS_MESSAGE = "<green>Show points: <gold>/villagerui points [villagerType]</green>";
+    public static String AUTO_SELL_MESSAGE = "<green>Toggle auto sell per item: <gold>/villagerui autosell <block></green>";
     public static String BUY_MESSAGE = "<green>Check where/if you can buy an item: <gold>/villagerui buy <item_name></green>";
     public static String SELL_MESSAGE = "<green>Check where/if you can sell an item: <gold>/villagerui sell <item_name></green>";
     public static String RELOAD_MESSAGE = "<green>Reload configs: <gold>/villagerui reload</gold></green>";
     public static String CREATE_VILLAGER_MESSAGE = "<green>Create a new trading villager: <gold>/villagerui createvillager <type> <biome> <x> <y> <z> <yaw> <pitch> <world></gold></green>";
     public static String REMOVE_VILLAGER_MESSAGE = "<green>Removes all existing trading villagers in a 2 block radius: <gold>/villagerui removevillager</gold></green>";
+    public static String RESET_POINTS_MESSAGE = "<green>Reset all villager points: <gold>/villagerui resetpoints <villager_type></gold></green>";
 
     private static void loadHelp() {
         HELP_MESSAGE_WRAPPER = config.getString("help.help-wrapper", HELP_MESSAGE_WRAPPER);
         HELP_MESSAGE = config.getString("help.help", HELP_MESSAGE);
         POINTS_MESSAGE = config.getString("help.points", POINTS_MESSAGE);
+        AUTO_SELL_MESSAGE = config.getString("help.auto-sell", AUTO_SELL_MESSAGE);
         BUY_MESSAGE = config.getString("help.buy", BUY_MESSAGE);
         SELL_MESSAGE = config.getString("help.sell", SELL_MESSAGE);
         RELOAD_MESSAGE = config.getString("help.reload", RELOAD_MESSAGE);
         CREATE_VILLAGER_MESSAGE = config.getString("help.create-villager", CREATE_VILLAGER_MESSAGE);
         REMOVE_VILLAGER_MESSAGE = config.getString("help.remove-villager", REMOVE_VILLAGER_MESSAGE);
+        RESET_POINTS_MESSAGE = config.getString("help.reset-points-message", RESET_POINTS_MESSAGE);
     }
 
     public static String NO_PERMISSION = "<red>You do not have permission to do that.</red>";
@@ -140,6 +144,15 @@ public final class Config extends AbstractConfig {
     public static String LOADING_ECON_DATA = "<red>Loading your economy data, please wait...</red>";
     public static String NO_VILLAGER_POINTS = "<red>You don't have any villager points.</red>";
     public static String NOTIFY_POINTS_RESET = "<green>Your points for <villager_type> reset to 0!</green>";
+    public static String NO_AUTO_SELL_ITEMS = "<green>You don't have any items set to auto sell!</green>";
+    public static String LIST_AUTO_SELL_ITEMS = "<green>You have the following items enabled to auto sell</green>";
+    public static String LIST_AUTO_SELL_COMPONENT = "<yellow><material></yellow>";
+    public static String INVALID_AUTO_SELL_ITEM = "<red><material> is not a valid auto sell item</red>";
+    public static String TURNED_ON_AUTO_SELL_FOR = "<yellow>Turned <green>on</green> auto sell for <material></yellow>";
+    public static String TURNED_OFF_AUTO_SELL_FOR = "<yellow>Turned <red>off</red> auto sell for <material></yellow>";
+    public static String AUTO_SOLD = "<green>You made <total_money_made> from auto selling</green>";
+    public static String MAX_AUTO_SELL_REACHED = "<red>You can only auto sell up to <max_auto_sell> items at a time</red>";
+    public static String DISABLED_AUTO_SELL = "<green>You have disabled auto sell</green>";
 
     private static void loadMessages() {
         NOT_ENOUGH_MONEY = config.getString("messages.not-enough-money", NOT_ENOUGH_MONEY);
@@ -159,12 +172,23 @@ public final class Config extends AbstractConfig {
         LOADING_ECON_DATA = config.getString("messages.loading-econ-data", LOADING_ECON_DATA);
         NO_VILLAGER_POINTS = config.getString("messages.no-villager-points", NO_VILLAGER_POINTS);
         NOTIFY_POINTS_RESET = config.getString("messages.notify-points-reset", NOTIFY_POINTS_RESET);
+        NO_AUTO_SELL_ITEMS = config.getString("messages.no-auto-sell-items", NO_AUTO_SELL_ITEMS);
+        LIST_AUTO_SELL_ITEMS = config.getString("messages.list-auto-sell-items", LIST_AUTO_SELL_ITEMS);
+        LIST_AUTO_SELL_COMPONENT = config.getString("messages.list-auto-sell-component", LIST_AUTO_SELL_COMPONENT);
+        INVALID_AUTO_SELL_ITEM = config.getString("messages.invalid-auto-sell-item", INVALID_AUTO_SELL_ITEM);
+        TURNED_ON_AUTO_SELL_FOR = config.getString("messages.turned-on-auto-sell-for", TURNED_ON_AUTO_SELL_FOR);
+        TURNED_OFF_AUTO_SELL_FOR = config.getString("messages.turned-off-auto-sell-for", TURNED_OFF_AUTO_SELL_FOR);
+        AUTO_SOLD = config.getString("messages.auto-sold", AUTO_SOLD);
+        MAX_AUTO_SELL_REACHED = config.getString("messages.max-auto-sell-reached", MAX_AUTO_SELL_REACHED);
+        DISABLED_AUTO_SELL = config.getString("messages.disabled-auto-sell", DISABLED_AUTO_SELL);
     }
 
     public static boolean DEBUG = false;
+    public static int MAX_AUTO_SELL = 5;
 
     private static void loadSettings() {
         DEBUG = config.getBoolean("settings.debug", DEBUG);
+        MAX_AUTO_SELL = config.getInt("settings.max-auto-sell", MAX_AUTO_SELL);
     }
 
     private static void loadVillagerTypes() {

src/main/java/com/alttd/events/ItemPickupEvent.java

@@ -0,0 +1,32 @@
+package com.alttd.events;
+
+import com.alttd.util.auto_sell.AutoSellTask;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityPickupItemEvent;
+
+import java.util.UUID;
+
+public class ItemPickupEvent implements Listener {
+
+    private final AutoSellTask autoSellTask;
+
+    public ItemPickupEvent(AutoSellTask autoSellTask) {
+        this.autoSellTask = autoSellTask;
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onItemPickupEvent(EntityPickupItemEvent event) {
+        if (!(event.getEntity() instanceof Player player)) {
+            return;
+        }
+        UUID uuid = player.getUniqueId();
+        if (!autoSellTask.autoSellEnabled(uuid, event.getItem().getItemStack().getType())) {
+            return;
+        }
+        autoSellTask.putAutoSellPlayer(uuid);
+    }
+
+}

src/main/java/com/alttd/events/SpawnShopEvent.java

@@ -31,6 +31,7 @@ public final class SpawnShopEvent extends Event {
         return player;
     }
 
+    //Trade
     public SpawnShopEvent(Player player, Material material, int amount, double price, boolean buy) {
         this.player = player;
         this.amount = amount;
@@ -41,6 +42,17 @@ public final class SpawnShopEvent extends Event {
         this.buy = buy;
     }
 
+    //Auto sell
+    public SpawnShopEvent(Player player, Purchase purchase, int pointsBefore, int pointsAfter, double price) {
+        this.player = player;
+        this.amount = purchase.amount();
+        this.price = price;
+        this.item = purchase.material();
+        this.pointsBefore = pointsBefore;
+        this.pointsAfter = pointsAfter;
+        this.buy = false;
+    }
+
     public int amount() {
         return amount;
     }
@@ -75,4 +87,3 @@ public final class SpawnShopEvent extends Event {
         return handlers;
     }
 }
-

src/main/java/com/alttd/util/auto_sell/AutoSell.java

@@ -0,0 +1,100 @@
+package com.alttd.util.auto_sell;
+
+import com.alttd.VillagerUI;
+import com.alttd.config.Config;
+import com.alttd.config.WorthConfig;
+import com.alttd.events.SpawnShopEvent;
+import com.alttd.objects.*;
+import com.alttd.util.Logger;
+import com.alttd.util.Utilities;
+import net.kyori.adventure.text.minimessage.MiniMessage;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import net.milkbowl.vault.economy.Economy;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.scheduler.BukkitScheduler;
+
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.Set;
+
+public class AutoSell {
+
+    private static final MiniMessage miniMessage = MiniMessage.miniMessage();
+
+    public static void autoSell(Player player, Set<Material> materials) {
+        EconUser econUser = EconUser.getUser(player.getUniqueId());
+        if (econUser == null) {
+            player.sendRichMessage(Config.LOADING_ECON_DATA);
+            return;
+        }
+        double totalMoneyMade = VillagerTypeManager
+                .getVillagerTypes()
+                .stream()
+                .flatMap(villagerType -> villagerType
+                        .getSelling()
+                        .stream()
+                        .map(ItemStack::getType)
+                        .filter(materials::contains)
+                        .map(material -> sell(player, econUser, villagerType, material)))
+                .mapToDouble(Double::doubleValue)
+                .sum();
+        player.sendActionBar(miniMessage.deserialize(Config.AUTO_SOLD,
+                Placeholder.parsed("total_money_made", String.valueOf(totalMoneyMade))));
+    }
+
+    private static double sell(Player player, EconUser econUser, VillagerType villagerType, Material material) {
+        int amount = countTotalBlocksInInventory(player.getInventory(), material);
+        if (amount == 0) {
+            return 0;
+        }
+        Price price = Utilities.getPrice(new ItemStack(material, amount), WorthConfig.sell);
+        if (price == null) {
+            Logger.warning("Unable to sell %s for % due to missing worth data.",
+                    material.name(), villagerType.getName());
+            return 0;
+        }
+
+        int oldPoints = econUser.getPointsMap().getOrDefault(villagerType.getName(), 0);
+        int itemPts = price.getPoints();
+        int transPts = (itemPts * amount) * -1;
+        double cost = price.calculatePriceThing(oldPoints, transPts, false, itemPts);
+
+        Purchase purchase = new Purchase(material, cost, itemPts, transPts, amount);
+
+        Economy econ = VillagerUI.getInstance().getEconomy();
+        double finalPrice = purchase.price();
+        if (!player.hasPermission("villagerui.autosell.full-price")) {
+            finalPrice /= 2;
+        }
+        econ.depositPlayer(player, finalPrice);
+        econUser.addPoints(villagerType.getName(), purchase.totalPointCost());
+
+        player.getInventory().remove(material);
+        player.updateInventory();
+
+        int newPoints = econUser.getPointsMap().get(villagerType.getName());
+
+        BukkitScheduler scheduler = Bukkit.getServer().getScheduler();
+        double effectivelyFinalPrice = finalPrice;
+        scheduler.callSyncMethod(VillagerUI.getInstance(), () -> {
+            Bukkit.getServer().getPluginManager()
+                  .callEvent(new SpawnShopEvent(player, purchase, oldPoints, newPoints, effectivelyFinalPrice));
+            return null;
+        });
+
+        return finalPrice;
+    }
+
+    private static int countTotalBlocksInInventory(Inventory inventory, Material material) {
+        return Arrays.stream(inventory.getContents())
+                     .filter(Objects::nonNull)
+                     .filter(itemStack -> itemStack.getType().equals(material))
+                     .mapToInt(ItemStack::getAmount)
+                     .sum();
+    }
+
+}

src/main/java/com/alttd/util/auto_sell/AutoSellTask.java

@@ -0,0 +1,94 @@
+package com.alttd.util.auto_sell;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+
+public class AutoSellTask extends BukkitRunnable {
+
+    private final HashMap<UUID, Set<Material>> autoSellMap = new HashMap<>();
+    private final Set<UUID> autoSellPlayers = new HashSet<>();
+
+    @Override
+    public void run() {
+        runAutoSell();
+    }
+
+    public synchronized void putAutoSellPlayer(UUID uuid) {
+        autoSellPlayers.add(uuid);
+    }
+
+    public synchronized void runAutoSell() {
+        Bukkit.getOnlinePlayers()
+              .stream()
+              .filter(player -> autoSellPlayers.contains(player.getUniqueId()))
+              .forEach(player -> {
+                  Set<Material> materials = autoSellMap.get(player.getUniqueId());
+                  if (materials != null && !materials.isEmpty()) {
+                      AutoSell.autoSell(player, materials);
+                  }
+              });
+        autoSellPlayers.clear();
+    }
+
+    public boolean hasAutoSellEntry(UUID uuid) {
+        if (!autoSellMap.containsKey(uuid)) {
+            return false;
+        }
+        return !autoSellMap.get(uuid).isEmpty();
+    }
+
+    public boolean toggleAutoSell(UUID uuid, Material material) {
+        Set<Material> materials = autoSellMap.computeIfAbsent(uuid, k -> new HashSet<>());
+        if (materials.contains(material)) {
+            materials.remove(material);
+            return false;
+        } else {
+            materials.add(material);
+            return true;
+        }
+    }
+
+    public Set<Material> getAutoSellList(UUID uuid) {
+        return autoSellMap.getOrDefault(uuid, new HashSet<>());
+    }
+
+    public boolean autoSellEnabled(UUID uuid, @NotNull Material type) {
+        if (!autoSellMap.containsKey(uuid)) {
+            return false;
+        }
+        Set<Material> materials = autoSellMap.getOrDefault(uuid, new HashSet<>());
+        if (materials.isEmpty()) {
+            return false;
+        }
+        return materials.contains(type);
+    }
+
+    public int getEntries(UUID uuid) {
+        Set<Material> materials = autoSellMap.get(uuid);
+        if (materials == null || materials.isEmpty()) {
+            return 0;
+        }
+        return materials.size();
+    }
+
+    public void removeAutoSell(UUID uuid, Material material) {
+        Set<Material> materials = autoSellMap.get(uuid);
+        if (materials == null) {
+            return;
+        }
+        materials.remove(material);
+    }
+
+    public synchronized void clearAutoSell(Player player) {
+        autoSellPlayers.remove(player.getUniqueId());
+        autoSellMap.remove(player.getUniqueId());
+    }
+}