Add villager points reset command and related configurations

Jenkinsfile

@@ -3,7 +3,22 @@ pipeline {
     stages {
         stage('Gradle') {
             steps {
-                sh 'bash gradlew build'
+               withCredentials([usernamePassword(credentialsId: 'alttd-publish-user', usernameVariable: 'USERNAME', passwordVariable: 'PASSWORD')]) {
+                 sh '''
+                   chmod +x gradlew
+                   ./gradlew build -PalttdDevPublishUser=$USERNAME -PalttdDevPublishPass=$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') {
@@ -23,4 +38,4 @@ pipeline {
             }
         }
     }
-}
+}

build.gradle.kts

@@ -5,7 +5,7 @@ plugins {
 }
 
 group = "com.alttd"
-version = "1.0.0-SNAPSHOT"
+version = "1.1-SNAPSHOT"
 description = "Altitude Villager Shop plugin."
 
 apply<JavaLibraryPlugin>()
@@ -28,8 +28,8 @@ publishing {
             name = "nexus"
             url = uri("https://repo.alttd.com/repository/alttd-snapshot/")
             credentials {
-                username = project.property("alttdSnapshotUsername") as String
+                username = project.property("alttdDevPublishUser") as String
-                password = project.property("alttdSnapshotPassword") as String
+                password = project.property("alttdDevPublishPass") as String
             }
         }
     }
@@ -58,7 +58,7 @@ tasks {
 }
 
 dependencies {
-    compileOnly("com.alttd.cosmos:cosmos-api:1.21.6-R0.1-SNAPSHOT") {
+    compileOnly("com.alttd.cosmos:cosmos-api:1.21.8-R0.1-SNAPSHOT") {
         isChanging = true
     }
     compileOnly("com.github.milkbowl:VaultAPI:1.7") {

settings.gradle.kts

@@ -1,7 +1,7 @@
 rootProject.name = "VillagerShopUI"
 
-val nexusUser = providers.gradleProperty("alttdSnapshotUsername").get()
+val nexusUser = providers.gradleProperty("alttdDevPublishUser").get()
-val nexusPass = providers.gradleProperty("alttdSnapshotPassword").get()
+val nexusPass = providers.gradleProperty("alttdDevPublishPass").get()
 
 dependencyResolutionManagement {
     repositories {

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();
+        AutoSellTask autoSellTask = new AutoSellTask();
-        new CommandManager();
+        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());
+    }
+}