] ";
+ if (plugin != null && plugin.getLang() != null) {
+ prefix = plugin.getLang().prefix;
+ }
+ sendColoredMini(Bukkit.getConsoleSender(), prefix + msg);
+ }
+
+ /**
+ * Log a prefixed formatted message to console
+ * Formatted in the same style as {@link String#format(String, Object...)}
+ *
+ * @param format Message format
+ * @param objects Objects in format
+ */
+ public static void logMini(String format, Object... objects) {
+ logMini(String.format(format, objects));
+ }
+
+ /**
+ * Spawn a particle at a location for all players
+ *
+ * @param location The location to spawn a particle at
+ * @param particle The particle to spawn
+ * @param amount The amount of particles
+ * @param offsetX Offset by x
+ * @param offsetY Offset by y
+ * @param offsetZ Offset by z
+ */
+ public static void spawnParticle(Location location, Particle particle, int amount, double offsetX, double offsetY, double offsetZ) {
+ assert location.getWorld() != null;
+ location.getWorld().spawnParticle(particle, location, amount, offsetX, offsetY, offsetZ);
+ }
+
+ /**
+ * Spawn a particle at a location for a player
+ *
+ * @param location The location to spawn a particle at
+ * @param particle The particle to spawn
+ * @param amount The amount of particles
+ * @param offsetX Offset by x
+ * @param offsetY Offset by y
+ * @param offsetZ Offset by z
+ * @param player The player to spawn a particle for
+ */
+ public static void spawnParticle(Location location, Particle particle, int amount, double offsetX, double offsetY, double offsetZ, Player player) {
+ player.spawnParticle(particle, location, amount, offsetX, offsetY, offsetZ);
+ }
+
+ /**
+ * Gets the minutes a player has played on the server
+ *
+ * @param player The player to check
+ * @return The number of minutes they have played on the server
+ */
+ @SuppressWarnings("IntegerDivisionInFloatingPointContext")
+ public static int getMinutesPlayed(Player player) {
+ int played = player.getStatistic(Statistic.PLAY_ONE_MINUTE);
+ return Math.round(played / 1200);
+ }
+
+ /**
+ * Check if server is running a minimum Minecraft version
+ *
+ * @param major Major version to check (Most likely just going to be 1)
+ * @param minor Minor version to check
+ * @return True if running this version or higher
+ */
+ public static boolean isRunningMinecraft(int major, int minor) {
+ return isRunningMinecraft(major, minor, 0);
+ }
+
+ /**
+ * Check if server is running a minimum Minecraft version
+ *
+ * @param major Major version to check (Most likely just going to be 1)
+ * @param minor Minor version to check
+ * @param revision Revision to check
+ * @return True if running this version or higher
+ */
+ public static boolean isRunningMinecraft(int major, int minor, int revision) {
+ String[] version = Bukkit.getServer().getBukkitVersion().split("-")[0].split("\\.");
+ int maj = Integer.parseInt(version[0]);
+ int min = Integer.parseInt(version[1]);
+ int rev;
+ try {
+ rev = Integer.parseInt(version[2]);
+ } catch (Exception ignore) {
+ rev = 0;
+ }
+ return maj > major || min > minor || (min == minor && rev >= revision);
+ }
+
+ public static boolean isRunningPaper() {
+ return classExists("io.papermc.paper.ServerBuildInfo");
+ }
+
+ /**
+ * Check if a class exists
+ *
+ * @param className The {@link Class#getCanonicalName() canonical name} of the class
+ * @return True if the class exists
+ */
+ public static boolean classExists(final String className) {
+ try {
+ Class.forName(className);
+ return true;
+ } catch (ClassNotFoundException ex) {
+ return false;
+ }
+ }
+
+ /**
+ * Check if a method exists
+ *
+ * @param c Class the method belongs to
+ * @param methodName Name of method
+ * @param parameterTypes Parameter types for this method
+ * @return True if the method exists
+ */
+ public static boolean methodExists(final Class c, final String methodName, final Class... parameterTypes) {
+ try {
+ c.getDeclaredMethod(methodName, parameterTypes);
+ return true;
+ } catch (NoSuchMethodException ex) {
+ return false;
+ }
+ }
+
+ /**
+ * Check if this entity is a Citizens NPC
+ *
+ * @param entity Entity to check
+ * @return True if entity is an NPC
+ */
+ public static boolean isCitizensNPC(Metadatable entity) {
+ return entity.hasMetadata("NPC");
+ }
+
+ /**
+ * Get a {@link NamespacedKey} linked to this plugin
+ *
+ * @param key Key to create
+ * @return New NamespacedKey linked to this plugin
+ */
+ public static NamespacedKey getNamespacedKey(String key) {
+ return new NamespacedKey("survival_plus", key);
+ }
+
+}
diff --git a/src/main/java/com/shanebeestudios/survival/api/util/package-info.java b/src/main/java/com/shanebeestudios/survival/api/util/package-info.java
new file mode 100644
index 0000000..4fb37f3
--- /dev/null
+++ b/src/main/java/com/shanebeestudios/survival/api/util/package-info.java
@@ -0,0 +1,4 @@
+/**
+ * General utility classes
+ */
+package com.shanebeestudios.survival.api.util;
diff --git a/src/main/java/com/shanebeestudios/survival/plugin/SurvivalBootstrap.java b/src/main/java/com/shanebeestudios/survival/plugin/SurvivalBootstrap.java
new file mode 100644
index 0000000..b1b4699
--- /dev/null
+++ b/src/main/java/com/shanebeestudios/survival/plugin/SurvivalBootstrap.java
@@ -0,0 +1,16 @@
+package com.shanebeestudios.survival.plugin;
+
+import com.shanebeestudios.survival.plugin.registry.TagGenerator;
+import io.papermc.paper.plugin.bootstrap.BootstrapContext;
+import io.papermc.paper.plugin.bootstrap.PluginBootstrap;
+import org.jetbrains.annotations.NotNull;
+
+@SuppressWarnings({"UnstableApiUsage", "unused"})
+public class SurvivalBootstrap implements PluginBootstrap {
+
+ @Override
+ public void bootstrap(@NotNull BootstrapContext context) {
+ new TagGenerator(context);
+ }
+
+}
diff --git a/src/main/java/com/shanebeestudios/survival/plugin/SurvivalPlugin.java b/src/main/java/com/shanebeestudios/survival/plugin/SurvivalPlugin.java
new file mode 100644
index 0000000..cdbb784
--- /dev/null
+++ b/src/main/java/com/shanebeestudios/survival/plugin/SurvivalPlugin.java
@@ -0,0 +1,367 @@
+package com.shanebeestudios.survival.plugin;
+
+import com.shanebeestudios.survival.api.registry.ItemTags;
+import com.shanebeestudios.survival.plugin.commands.SurvivalCommand;
+import com.shanebeestudios.survival.plugin.config.Config;
+import com.shanebeestudios.survival.plugin.config.Lang;
+import com.shanebeestudios.survival.plugin.config.PlayerDataConfig;
+import com.shanebeestudios.survival.api.data.PlayerData;
+import com.shanebeestudios.survival.plugin.listeners.EventManager;
+import com.shanebeestudios.survival.plugin.managers.EffectManager;
+import com.shanebeestudios.survival.plugin.managers.LootManager;
+import com.shanebeestudios.survival.plugin.managers.MessageManager;
+import com.shanebeestudios.survival.plugin.managers.PapiPlaceholders;
+import com.shanebeestudios.survival.plugin.managers.PlayerManager;
+import com.shanebeestudios.survival.plugin.managers.RecipeManager;
+import com.shanebeestudios.survival.plugin.managers.ScoreBoardManager;
+import com.shanebeestudios.survival.plugin.tasks.TaskManager;
+import com.shanebeestudios.survival.api.registry.BlockTags;
+import com.shanebeestudios.survival.api.util.Utils;
+import dev.jorel.commandapi.CommandAPI;
+import dev.jorel.commandapi.CommandAPIBukkitConfig;
+import dev.jorel.commandapi.exceptions.UnsupportedVersionException;
+import org.bstats.bukkit.Metrics;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.command.CommandSender;
+import org.bukkit.configuration.serialization.ConfigurationSerialization;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Listener;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * Main plugin class
+ */
+@SuppressWarnings("UnstableApiUsage")
+public class SurvivalPlugin extends JavaPlugin implements Listener {
+
+ static {
+ ConfigurationSerialization.registerClass(PlayerData.class);
+ }
+
+ private static SurvivalPlugin INSTANCE;
+
+ // Lists & Map
+ private Map playerDataMap = new HashMap<>();
+
+ // Configs
+ private Config config;
+ private Lang lang;
+ private PlayerDataConfig playerDataConfig;
+
+ // Managers
+ private EffectManager effectManager;
+ private ScoreBoardManager scoreBoardManager;
+ private PlayerManager playerManager;
+ private TaskManager taskManager;
+ private LootManager lootManager;
+ private RecipeManager recipeManager;
+ private MessageManager messageManager;
+
+ // Other
+ private boolean loaded = true;
+
+ /**
+ * @hidden
+ */
+ @Override
+ public void onLoad() {
+ try {
+ CommandAPI.onLoad(new CommandAPIBukkitConfig(this)
+ .setNamespace("survivalplus")
+ .verboseOutput(false)
+ .silentLogs(true)
+ .skipReloadDatapacks(true));
+ } catch (UnsupportedVersionException ignore) {
+ Utils.logMini("CommandAPI does not support this version of Minecraft, will update soon.");
+ }
+ }
+
+ /**
+ * @hidden
+ */
+ public void onEnable() {
+ INSTANCE = this;
+ long time = System.currentTimeMillis();
+
+ // VERSION CHECK
+ if (!Utils.isRunningMinecraft(1, 21, 4)) {
+ Utils.logMini("-----------------------------------------------------------");
+ Utils.logMini("Your version is not supported: " + Bukkit.getMinecraftVersion());
+ Utils.logMini("This plugin only works on Minecraft 1.16+");
+ Utils.logMini("-----------------------------------------------------------");
+ loaded = false;
+ Bukkit.getPluginManager().disablePlugin(this);
+ return;
+ }
+
+ // PAPER CHECK
+ // This shouldn't really happen since we're using paper-plugin.yml
+ if (!Utils.isRunningPaper()) {
+ Utils.logMini("-----------------------------------------------------------");
+ Utils.logMini("Your server software is not supported: " + Bukkit.getName());
+ Utils.logMini("This plugin will only work on Paper.");
+ Utils.logMini("-----------------------------------------------------------");
+ loaded = false;
+ Bukkit.getPluginManager().disablePlugin(this);
+ return;
+ }
+
+ // LOAD CONFIG FILES
+ loadSettings(Bukkit.getConsoleSender());
+
+ // LOAD RESOURCE PACK
+ if (this.config.settings_resource_pack_enabled) {
+ if (this.config.settings_resource_pack_url.isEmpty()) {
+ Utils.logMini("Resource Pack is not set! Plugin disabling");
+ Bukkit.getPluginManager().disablePlugin(this);
+ return;
+ } else {
+ Utils.logMini("Resource pack enabled");
+ }
+ } else {
+ Utils.logMini("Resource Pack disabled");
+ }
+
+ // LOAD TAGS
+ BlockTags.initialize();
+ ItemTags.initialize();
+
+ // LOAD MANAGERS
+ this.playerManager = new PlayerManager(this, this.playerDataMap);
+ this.effectManager = new EffectManager(this);
+ this.taskManager = new TaskManager(this);
+ this.scoreBoardManager = new ScoreBoardManager(this);
+ this.lootManager = new LootManager(this);
+ this.recipeManager = new RecipeManager(this);
+ this.messageManager = new MessageManager(this);
+
+ // LOAD PLAYER DATA - (during a reload if players are still online)
+ playerDataLoader(true);
+ this.scoreBoardManager.resetStatusScoreboard(config.mechanics_status_scoreboard);
+
+ // LOAD PLACEHOLDERS
+ if (Bukkit.getPluginManager().getPlugin("PlaceholderAPI") != null) {
+ new PapiPlaceholders(this).register();
+ Utils.logMini("PlaceholderAPI placeholders enabled");
+ }
+
+ // REGISTER EVENTS & COMMANDS
+ registerCommands();
+ EventManager eventManager = new EventManager(this);
+ eventManager.registerEvents();
+
+ // LOAD CUSTOM RECIPES
+ // This is a helper for other plugins that wipe custom recipes - secret hidden config
+ if (this.config.recipe_delay > 0) {
+ Utils.logMini("Custom recipe loading delayed... will load in " + this.config.recipe_delay + " second[s]");
+ Bukkit.getScheduler().runTaskLater(this, () -> {
+ this.recipeManager.loadCustomRecipes();
+ Utils.logMini("Custom recipes loaded");
+ }, this.config.recipe_delay * 20L);
+
+ } else {
+ this.recipeManager.loadCustomRecipes();
+ Utils.logMini("Custom recipes loaded");
+ }
+
+ // LOAD METRICS
+ new Metrics(this, 24831);
+
+ Utils.logMini("Successfully loaded in " + (System.currentTimeMillis() - time) + " milliseconds");
+
+ // BETA WARNING
+ if (this.getPluginMeta().getVersion().contains("Beta")) {
+ Utils.logMini("YOU ARE RUNNING A BETA VERSION, PLEASE USE WITH CAUTION!");
+ }
+ }
+
+ /**
+ * @hidden
+ */
+ public void onDisable() {
+ if (!loaded) return;
+ Utils.logMini("Shutting down");
+ getServer().getScheduler().cancelTasks(this);
+
+ // Unload player data (decrease chance of memory leak)
+ playerDataLoader(false);
+
+ //Avoid WorkbenchShare glitch
+ if (this.config.mechanics_shared_workbench) {
+ for (Player p : Bukkit.getOnlinePlayers()) {
+ if (p.hasMetadata("shared_workbench")) {
+ Block workbench = (p.getMetadata("shared_workbench").getFirst().value() instanceof Block) ? (Block)
+ p.getMetadata("shared_workbench").getFirst().value() : null;
+
+ if (workbench != null && workbench.getType() == Material.CRAFTING_TABLE) {
+ if (workbench.hasMetadata("shared_players"))
+ workbench.removeMetadata("shared_players", SurvivalPlugin.INSTANCE);
+ else
+ p.getOpenInventory().getTopInventory().clear();
+ p.closeInventory();
+ }
+ p.removeMetadata("shared_workbench", SurvivalPlugin.INSTANCE);
+ }
+ }
+ }
+ INSTANCE = null;
+ Utils.logMini("Successfully disabled");
+ }
+
+ private void playerDataLoader(boolean load) {
+ int size = Bukkit.getOnlinePlayers().size();
+ if (load) {
+ // Load player data - if players are online (useful during reload)
+ for (Player player : Bukkit.getOnlinePlayers()) {
+ if (this.playerDataConfig.hasPlayerDataFile(player)) {
+ this.playerManager.loadPlayerData(player);
+ } else {
+ this.playerManager.createNewPlayerData(player);
+ }
+ }
+ if (size > 0) {
+ Utils.logMini("Loading player data for " + size + " player" + (size != 1 ? "s" : ""));
+ }
+ } else {
+ // Unload player data - if players are still online
+ for (Player player : Bukkit.getOnlinePlayers()) {
+ playerManager.unloadPlayerData(player);
+ }
+ // Clear/delete player data map to prevent memory leaks
+ this.playerDataMap.clear();
+ this.playerDataMap = null;
+ Utils.logMini("Unloading player data for " + size + " player" + (size != 1 ? "s" : ""));
+ }
+ }
+
+ /**
+ * Load config settings
+ *
+ * @param sender The person/console loading config
+ */
+ public void loadSettings(CommandSender sender) {
+ if (this.config == null) {
+ this.config = new Config(this);
+ }
+ this.config.loadDefaultSettings();
+ if (this.lang == null) {
+ this.lang = new Lang(this, this.config.lang);
+ }
+ this.lang.loadLangFile(sender);
+ this.playerDataConfig = new PlayerDataConfig(this);
+ }
+
+ private void registerCommands() {
+ if (CommandAPI.isLoaded()) {
+ CommandAPI.onEnable();
+ new SurvivalCommand(this, "survival");
+ }
+ }
+
+ /**
+ * Get instance of this plugin
+ *
+ * @return Instance of this plugin
+ */
+ public static SurvivalPlugin getInstance() {
+ return INSTANCE;
+ }
+
+ /**
+ * Get the effect manager
+ *
+ * @return Instance of the effect manager
+ */
+ public EffectManager getEffectManager() {
+ return this.effectManager;
+ }
+
+ /**
+ * Get the scoreboard manager
+ *
+ * @return Instance of the scoreboard manager
+ */
+ public ScoreBoardManager getScoreboardManager() {
+ return this.scoreBoardManager;
+ }
+
+ /**
+ * Get the player manager
+ *
+ * @return Instance of the player manager
+ */
+ public PlayerManager getPlayerManager() {
+ return this.playerManager;
+ }
+
+ /**
+ * Get the task manager
+ *
+ * @return Instance of the task manager
+ */
+ @SuppressWarnings("unused")
+ public TaskManager getTaskManager() {
+ return this.taskManager;
+ }
+
+ /**
+ * Get an instance of the loot manager
+ *
+ * @return Instance of the loot manager
+ */
+ public LootManager getLootManager() {
+ return lootManager;
+ }
+
+ /**
+ * Get an instance of the recipe manager
+ *
+ * @return Instance of recipe manager
+ */
+ public RecipeManager getRecipeManager() {
+ return recipeManager;
+ }
+
+ /**
+ * Get an instance of the message manager
+ *
+ * @return Instance of message manager
+ */
+ public MessageManager getMessageManager() {
+ return this.messageManager;
+ }
+
+ /**
+ * Get the main SurvivalPlus config
+ *
+ * @return SurvivalPlus config
+ */
+ public Config getSurvivalConfig() {
+ return this.config;
+ }
+
+ /**
+ * Get an instance of the language config
+ *
+ * @return Language config
+ */
+ public Lang getLang() {
+ return lang;
+ }
+
+ /**
+ * Get an instance of the player data config
+ *
+ * @return Player data config
+ */
+ public PlayerDataConfig getPlayerDataConfig() {
+ return playerDataConfig;
+ }
+
+}
diff --git a/src/main/java/com/shanebeestudios/survival/plugin/commands/BaseCommand.java b/src/main/java/com/shanebeestudios/survival/plugin/commands/BaseCommand.java
new file mode 100644
index 0000000..ff4db5a
--- /dev/null
+++ b/src/main/java/com/shanebeestudios/survival/plugin/commands/BaseCommand.java
@@ -0,0 +1,25 @@
+package com.shanebeestudios.survival.plugin.commands;
+
+import dev.jorel.commandapi.arguments.Argument;
+import com.shanebeestudios.survival.plugin.SurvivalPlugin;
+import com.shanebeestudios.survival.plugin.config.Config;
+import com.shanebeestudios.survival.plugin.config.Lang;
+import com.shanebeestudios.survival.plugin.managers.PlayerManager;
+
+public abstract class BaseCommand {
+
+ protected final SurvivalPlugin plugin;
+ protected final Config config;
+ protected final Lang lang;
+ protected final PlayerManager playerManager;
+
+ public BaseCommand(SurvivalPlugin plugin) {
+ this.plugin = plugin;
+ this.config = plugin.getSurvivalConfig();
+ this.lang = plugin.getLang();
+ this.playerManager = plugin.getPlayerManager();
+ }
+
+ abstract Argument register();
+
+}
diff --git a/src/main/java/com/shanebeestudios/survival/plugin/commands/DataGenCommand.java b/src/main/java/com/shanebeestudios/survival/plugin/commands/DataGenCommand.java
new file mode 100644
index 0000000..6732662
--- /dev/null
+++ b/src/main/java/com/shanebeestudios/survival/plugin/commands/DataGenCommand.java
@@ -0,0 +1,29 @@
+package com.shanebeestudios.survival.plugin.commands;
+
+import com.shanebeestudios.survival.api.data.Permissions;
+import dev.jorel.commandapi.arguments.Argument;
+import dev.jorel.commandapi.arguments.LiteralArgument;
+import com.shanebeestudios.survival.plugin.SurvivalPlugin;
+import com.shanebeestudios.survival.api.generator.TagFileGenerator;
+import com.shanebeestudios.survival.api.util.Utils;
+
+public class DataGenCommand extends BaseCommand {
+
+ private final TagFileGenerator tagFileGenerator;
+
+ public DataGenCommand(SurvivalPlugin plugin) {
+ super(plugin);
+ this.tagFileGenerator = new TagFileGenerator(plugin);
+ }
+
+ @Override
+ Argument register() {
+ return LiteralArgument.literal("datagen")
+ .withPermission(Permissions.COMMAND_DATA_GEN.permission())
+ .executes(info -> {
+ this.tagFileGenerator.generate();
+ Utils.sendColoredMini(info.sender(), "Finished generating block-tags.yml");
+ });
+ }
+
+}
diff --git a/src/main/java/com/shanebeestudios/survival/plugin/commands/DebugCommand.java b/src/main/java/com/shanebeestudios/survival/plugin/commands/DebugCommand.java
new file mode 100644
index 0000000..cca134a
--- /dev/null
+++ b/src/main/java/com/shanebeestudios/survival/plugin/commands/DebugCommand.java
@@ -0,0 +1,43 @@
+package com.shanebeestudios.survival.plugin.commands;
+
+import com.shanebeestudios.survival.plugin.SurvivalPlugin;
+import com.shanebeestudios.survival.api.data.Permissions;
+import com.shanebeestudios.survival.api.data.Placeholders;
+import com.shanebeestudios.survival.api.item.Items;
+import com.shanebeestudios.survival.api.item.Nutrition;
+import dev.jorel.commandapi.arguments.Argument;
+import dev.jorel.commandapi.arguments.LiteralArgument;
+
+public class DebugCommand extends BaseCommand{
+ public DebugCommand(SurvivalPlugin plugin) {
+ super(plugin);
+ }
+
+ @Override
+ Argument register() {
+ return LiteralArgument.literal("debug")
+ .withPermission(Permissions.COMMAND_DEBUG.permission())
+ .then(LiteralArgument.literal("nutrition")
+ .executesConsole(info -> {
+ Nutrition.debug();
+ }))
+ .then(LiteralArgument.literal("items")
+ .then(LiteralArgument.literal("create")
+ .executesPlayer(info -> {
+ Items.debug(info.sender());
+ }))
+ .then(LiteralArgument.literal("remove")
+ .executesPlayer(info -> {
+ Items.debug(null);
+ })))
+ .then(LiteralArgument.literal("placeholders")
+ .executesConsole(info -> {
+ Placeholders.debug();
+ }))
+ .then(LiteralArgument.literal("permissions")
+ .executesConsole(info -> {
+ Permissions.debug();
+ }));
+ }
+
+}
diff --git a/src/main/java/com/shanebeestudios/survival/plugin/commands/GiveItemCommand.java b/src/main/java/com/shanebeestudios/survival/plugin/commands/GiveItemCommand.java
new file mode 100644
index 0000000..f00aa0d
--- /dev/null
+++ b/src/main/java/com/shanebeestudios/survival/plugin/commands/GiveItemCommand.java
@@ -0,0 +1,106 @@
+package com.shanebeestudios.survival.plugin.commands;
+
+import com.shanebeestudios.survival.api.data.Permissions;
+import dev.jorel.commandapi.arguments.Argument;
+import dev.jorel.commandapi.arguments.ArgumentSuggestions;
+import dev.jorel.commandapi.arguments.EntitySelectorArgument;
+import dev.jorel.commandapi.arguments.IntegerArgument;
+import dev.jorel.commandapi.arguments.LiteralArgument;
+import dev.jorel.commandapi.arguments.StringArgument;
+import dev.jorel.commandapi.executors.CommandArguments;
+import io.papermc.paper.datacomponent.DataComponentTypes;
+import net.kyori.adventure.text.Component;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.Nullable;
+import com.shanebeestudios.survival.plugin.SurvivalPlugin;
+import com.shanebeestudios.survival.api.item.Item;
+import com.shanebeestudios.survival.api.item.Items;
+import com.shanebeestudios.survival.api.util.Utils;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.StringJoiner;
+
+public class GiveItemCommand extends BaseCommand {
+
+ private final List names = new ArrayList<>();
+
+ public GiveItemCommand(SurvivalPlugin plugin) {
+ super(plugin);
+ Items.allItemKeys().forEach(key -> this.names.add(key.value()));
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ Argument register() {
+ return LiteralArgument.literal("giveitem")
+ .withPermission(Permissions.COMMAND_GIVEITEM.permission())
+ .then(new EntitySelectorArgument.ManyPlayers("players")
+ .then(new StringArgument("item")
+ .includeSuggestions(ArgumentSuggestions.strings(this.names))
+ .then(new IntegerArgument("amount", 1, 99)
+ .setOptional(true)
+ .executes(info -> {
+ CommandSender sender = info.sender();
+ CommandArguments args = info.args();
+ Collection players = (Collection) args.get("players");
+ String itemKey = args.getByClass("item", String.class);
+ int amount = args.getByClassOrDefault("amount", Integer.class, 1);
+
+ assert itemKey != null;
+ assert players != null;
+
+ Item item = Items.getByKey(itemKey);
+
+ if (item != null) {
+ ItemStack itemStack = item.getItemStack(amount);
+
+ StringJoiner joiner = new StringJoiner(", ");
+ players.forEach(player -> {
+ giveItem(player, itemStack);
+ joiner.add(player.getName());
+ });
+ String itemName = getItemName(itemStack);
+ if (itemName == null) itemName = item.getKey().toString();
+
+ sendMessage(sender, itemStack, itemName, amount, joiner.toString());
+ } else {
+ Utils.sendColoredMini(sender, this.lang.prefix + "Invalid item %s", itemKey);
+ }
+ }))));
+ }
+
+ private void giveItem(Player player, ItemStack item) {
+ HashMap returnMap = player.getInventory().addItem(item);
+ if (!returnMap.isEmpty()) {
+ World world = player.getWorld();
+ Location location = player.getLocation();
+ returnMap.values().forEach(itemStack -> world.dropItemNaturally(location, itemStack));
+ }
+ }
+
+ @SuppressWarnings("UnstableApiUsage")
+ private @Nullable String getItemName(ItemStack itemStack) {
+ if (itemStack.hasData(DataComponentTypes.CUSTOM_NAME)) {
+ return Utils.reverseComponent(itemStack.getData(DataComponentTypes.CUSTOM_NAME));
+ } else if (itemStack.hasData(DataComponentTypes.ITEM_NAME)) {
+ return Utils.reverseComponent(itemStack.getData(DataComponentTypes.ITEM_NAME));
+ }
+ return null;
+ }
+
+ private void sendMessage(CommandSender sender, ItemStack itemStack, String itemName, int amount, String players) {
+ String who = sender instanceof Player ? "You" : "CONSOLE";
+ Component message = Utils.getMini(this.lang.prefix + "%s gave %s of ", who, amount)
+ .append(Utils.getMini("[%s]", itemName).hoverEvent(itemStack.asHoverEvent()))
+ .append(Utils.getMini(" to %s", players));
+ sender.sendMessage(message);
+ }
+
+}
diff --git a/src/main/java/com/shanebeestudios/survival/plugin/commands/HealCommand.java b/src/main/java/com/shanebeestudios/survival/plugin/commands/HealCommand.java
new file mode 100644
index 0000000..b3d53ff
--- /dev/null
+++ b/src/main/java/com/shanebeestudios/survival/plugin/commands/HealCommand.java
@@ -0,0 +1,71 @@
+package com.shanebeestudios.survival.plugin.commands;
+
+import com.shanebeestudios.survival.api.data.Permissions;
+import dev.jorel.commandapi.arguments.Argument;
+import dev.jorel.commandapi.arguments.EntitySelectorArgument;
+import dev.jorel.commandapi.arguments.LiteralArgument;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import com.shanebeestudios.survival.plugin.SurvivalPlugin;
+import com.shanebeestudios.survival.api.data.PlayerData;
+import com.shanebeestudios.survival.api.util.Utils;
+
+import java.util.Collection;
+import java.util.StringJoiner;
+
+public class HealCommand extends BaseCommand {
+
+ public HealCommand(SurvivalPlugin plugin) {
+ super(plugin);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ Argument register() {
+ return LiteralArgument.literal("heal")
+ .withPermission(Permissions.COMMAND_HEAL.permission())
+ .executesPlayer(info -> {
+ heal(info.sender());
+ Utils.sendColoredMini(info.sender(), this.lang.cmd_heal_self);
+ })
+ .then(new EntitySelectorArgument.ManyPlayers("players")
+ .withPermission(Permissions.COMMAND_HEAL_OTHERS.permission())
+ .executes(info -> {
+ CommandSender sender = info.sender();
+ Collection players = (Collection) info.args().get("players");
+ assert players != null;
+
+ StringJoiner joiner = new StringJoiner(", ");
+ players.forEach(player -> {
+ joiner.add(player.getName());
+ heal(player);
+ Utils.sendColoredMini(player, lang.cmd_heal_by, sender.getName());
+ });
+ Utils.sendColoredMini(sender, this.lang.cmd_heal_other, joiner.toString());
+ }));
+ }
+
+ @SuppressWarnings("DataFlowIssue")
+ private void heal(Player player) {
+ PlayerData playerData = this.plugin.getPlayerManager().getPlayerData(player);
+
+ player.setHealth(player.getAttribute(Attribute.MAX_HEALTH).getValue());
+ playerData.setHunger(this.config.mechanics_hunger_respawn_amount);
+
+ if (this.config.mechanics_thirst_enabled) {
+ playerData.setThirst(this.config.mechanics_thirst_respawn_amount);
+ }
+ if (this.config.mechanics_food_diversity_enabled) {
+ int carbs = this.config.mechanics_food_respawn_carbs;
+ int proteins = this.config.mechanics_food_respawn_proteins;
+ int salts = this.config.mechanics_food_respawn_vitamins;
+ playerData.setNutrients(carbs, proteins, salts);
+ }
+ if (this.config.mechanics_energy_enabled) {
+ playerData.setEnergy(this.config.mechanics_energy_respawn);
+ }
+ player.clearActivePotionEffects();
+ }
+
+}
diff --git a/src/main/java/com/shanebeestudios/survival/plugin/commands/NutritionCommand.java b/src/main/java/com/shanebeestudios/survival/plugin/commands/NutritionCommand.java
new file mode 100644
index 0000000..0ce7fcf
--- /dev/null
+++ b/src/main/java/com/shanebeestudios/survival/plugin/commands/NutritionCommand.java
@@ -0,0 +1,27 @@
+package com.shanebeestudios.survival.plugin.commands;
+
+import com.shanebeestudios.survival.api.data.Permissions;
+import dev.jorel.commandapi.arguments.Argument;
+import dev.jorel.commandapi.arguments.LiteralArgument;
+import org.bukkit.entity.Player;
+import com.shanebeestudios.survival.plugin.SurvivalPlugin;
+import com.shanebeestudios.survival.api.gui.NutritionGUI;
+
+public class NutritionCommand extends BaseCommand {
+
+ public NutritionCommand(SurvivalPlugin plugin) {
+ super(plugin);
+ }
+
+ @Override
+ Argument register() {
+ return LiteralArgument.literal("nutrition")
+ .withPermission(Permissions.COMMAND_NUTRITION.permission())
+ .executesPlayer(info -> {
+ Player player = info.sender();
+ NutritionGUI gui = new NutritionGUI(this.plugin);
+ gui.openInventory(player, 0);
+ });
+ }
+
+}
diff --git a/src/main/java/com/shanebeestudios/survival/plugin/commands/PlayerDataCommand.java b/src/main/java/com/shanebeestudios/survival/plugin/commands/PlayerDataCommand.java
new file mode 100644
index 0000000..2315a27
--- /dev/null
+++ b/src/main/java/com/shanebeestudios/survival/plugin/commands/PlayerDataCommand.java
@@ -0,0 +1,78 @@
+package com.shanebeestudios.survival.plugin.commands;
+
+import com.shanebeestudios.survival.api.data.Permissions;
+import dev.jorel.commandapi.arguments.Argument;
+import dev.jorel.commandapi.arguments.DoubleArgument;
+import dev.jorel.commandapi.arguments.EntitySelectorArgument;
+import dev.jorel.commandapi.arguments.LiteralArgument;
+import dev.jorel.commandapi.arguments.MultiLiteralArgument;
+import org.bukkit.entity.Player;
+import com.shanebeestudios.survival.plugin.SurvivalPlugin;
+import com.shanebeestudios.survival.api.data.PlayerData;
+import com.shanebeestudios.survival.api.util.Utils;
+
+import java.util.Collection;
+
+public class PlayerDataCommand extends BaseCommand {
+
+ public PlayerDataCommand(SurvivalPlugin plugin) {
+ super(plugin);
+ }
+
+ @SuppressWarnings("unchecked")
+ @Override
+ Argument register() {
+ return LiteralArgument.literal("playerdata")
+ .withPermission(Permissions.COMMAND_PLAYERDATA.permission())
+ .then(new EntitySelectorArgument.ManyPlayers("players")
+ .then(new MultiLiteralArgument("type", PlayerData.DataType.getNames())
+ .then(LiteralArgument.literal("get")
+ .executes(info -> {
+ Collection players = (Collection) info.args().get("players");
+ String type = info.args().getByClass("type", String.class);
+ PlayerData.DataType dataType = PlayerData.DataType.getByName(type);
+ if (dataType == null) {
+ return;
+ }
+ assert players != null;
+ players.forEach(player -> {
+ PlayerData playerData = this.playerManager.getPlayerData(player);
+ if (playerData == null) {
+ Utils.sendColoredMini(info.sender(), "Invalid player data for " + player.getName());
+ return;
+ }
+
+ double data = playerData.getData(dataType);
+ Utils.sendColoredMini(info.sender(), "Data: %s = %.2f", type, data);
+ });
+
+ }))
+ .then(new MultiLiteralArgument("change", "add", "remove", "set")
+ .then(new DoubleArgument("amount")
+ .executes(info -> {
+ Collection players = (Collection) info.args().get("players");
+ String type = info.args().getByClass("type", String.class);
+ String change = info.args().getByClass("change", String.class);
+ Double value = info.args().getByClass("amount", Double.class);
+ PlayerData.DataType dataType = PlayerData.DataType.getByName(type);
+
+ if (dataType == null || players == null || change == null || value == null) return;
+
+ players.forEach(player -> {
+ double changeValue = value;
+ PlayerData playerData = this.playerManager.getPlayerData(player);
+ if (playerData == null) {
+ Utils.sendColoredMini(info.sender(), "Invalid player data for " + player.getName());
+ return;
+ }
+ changeValue = switch (change) {
+ case "add" -> value + playerData.getData(dataType);
+ case "remove" -> playerData.getData(dataType) - value;
+ default -> changeValue;
+ };
+ playerData.setData(dataType, changeValue);
+ });
+ })))));
+ }
+
+}
diff --git a/src/main/java/com/shanebeestudios/survival/plugin/commands/ReloadCommand.java b/src/main/java/com/shanebeestudios/survival/plugin/commands/ReloadCommand.java
new file mode 100644
index 0000000..fdc195d
--- /dev/null
+++ b/src/main/java/com/shanebeestudios/survival/plugin/commands/ReloadCommand.java
@@ -0,0 +1,25 @@
+package com.shanebeestudios.survival.plugin.commands;
+
+import com.shanebeestudios.survival.api.data.Permissions;
+import dev.jorel.commandapi.arguments.Argument;
+import dev.jorel.commandapi.arguments.LiteralArgument;
+import com.shanebeestudios.survival.plugin.SurvivalPlugin;
+import com.shanebeestudios.survival.api.util.Utils;
+
+public class ReloadCommand extends BaseCommand {
+
+ public ReloadCommand(SurvivalPlugin plugin) {
+ super(plugin);
+ }
+
+ @Override
+ Argument register() {
+ return LiteralArgument.literal("reload")
+ .withPermission(Permissions.COMMAND_RELOAD.permission())
+ .executes(info -> {
+ this.plugin.loadSettings(info.sender());
+ Utils.sendColoredMini(info.sender(), this.lang.prefix + "Reload complete");
+ });
+ }
+
+}
diff --git a/src/main/java/com/shanebeestudios/survival/plugin/commands/StatCommand.java b/src/main/java/com/shanebeestudios/survival/plugin/commands/StatCommand.java
new file mode 100644
index 0000000..50e88d9
--- /dev/null
+++ b/src/main/java/com/shanebeestudios/survival/plugin/commands/StatCommand.java
@@ -0,0 +1,148 @@
+package com.shanebeestudios.survival.plugin.commands;
+
+import com.shanebeestudios.survival.api.data.Permissions;
+import dev.jorel.commandapi.BukkitStringTooltip;
+import dev.jorel.commandapi.IStringTooltip;
+import dev.jorel.commandapi.arguments.Argument;
+import dev.jorel.commandapi.arguments.ArgumentSuggestions;
+import dev.jorel.commandapi.arguments.LiteralArgument;
+import dev.jorel.commandapi.arguments.StringArgument;
+import dev.jorel.commandapi.executors.CommandArguments;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import com.shanebeestudios.survival.plugin.SurvivalPlugin;
+import com.shanebeestudios.survival.api.data.Info;
+import com.shanebeestudios.survival.api.data.Nutrient;
+import com.shanebeestudios.survival.api.data.PlayerData;
+import com.shanebeestudios.survival.api.util.Utils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+public class StatCommand extends BaseCommand {
+
+ private final List infoTooltips = new ArrayList<>();
+ private final List typeTooltips = new ArrayList<>();
+
+ public StatCommand(SurvivalPlugin plugin) {
+ super(plugin);
+
+ setupInfos("all", "Manage all stats");
+ setupInfos("hunger", "Manage hunger stat");
+ if (this.config.mechanics_thirst_enabled) {
+ setupInfos("thirst", "Manage thirst stat");
+ }
+ if (this.config.mechanics_energy_enabled) {
+ setupInfos("energy", "Manage energy stat");
+ }
+ if (this.config.mechanics_food_diversity_enabled) {
+ setupInfos("nutrients", "Manage nutrient stat");
+ }
+
+ if (this.config.mechanics_status_scoreboard) {
+ setupTypes("toggle", "Toggle a stat");
+ setupTypes("on", "Turn a stat on");
+ setupTypes("off", "Turn a stat off");
+ }
+ setupTypes("show", "Show a stat in chat");
+ }
+
+ @Override
+ Argument register() {
+ return LiteralArgument.literal("stats")
+ .withPermission(Permissions.COMMAND_STATS.permission())
+ .then(new StringArgument("info")
+ .includeSuggestions(ArgumentSuggestions.stringsWithTooltips(this.infoTooltips))
+ .then(new StringArgument("type")
+ .includeSuggestions(ArgumentSuggestions.stringsWithTooltips(this.typeTooltips))
+ .executesPlayer(commandInfo -> {
+ CommandArguments args = commandInfo.args();
+ Player player = commandInfo.sender();
+
+ String infoName = args.getByClassOrDefault("info", String.class, "all");
+ String type = args.getByClassOrDefault("type", String.class, "show");
+
+ Info info = getStat(infoName);
+
+ if (type.equalsIgnoreCase("show")) {
+ showStat(player, info);
+ } else {
+ manageStat(player, info, type);
+ }
+ })))
+ ;
+ }
+
+ private void showStat(@NotNull Player player, @Nullable Info info) {
+ if (info == null) {
+ for (Info value : Info.values()) {
+ showStat(player, value);
+ }
+ return;
+ }
+
+ PlayerData playerData = this.playerManager.getPlayerData(player);
+ String message = switch (info) {
+ case HUNGER -> String.format("%s: %.2f", this.lang.hunger, playerData.getHunger());
+ case THIRST -> String.format("%s: %.2f", this.lang.thirst, playerData.getThirst());
+ case ENERGY -> String.format("%s: %.2f", this.lang.energy, playerData.getEnergy());
+ case NUTRIENTS -> String.format("%s: " +
+ "<#A0E853>%s = %s, " +
+ "<#CE784D>%s = %s, " +
+ "<#53DDE8>%s = %s",
+ this.lang.nutrients,
+ this.lang.carbohydrates,
+ playerData.getNutrient(Nutrient.CARBS),
+ this.lang.protein,
+ playerData.getNutrient(Nutrient.PROTEIN),
+ this.lang.vitamins,
+ playerData.getNutrient(Nutrient.VITAMINS));
+
+ //nutrients.add("<#A0E853>" + this.lang.carbohydrates);
+ // nutrients.add("<#CE784D>" + this.lang.protein);
+ // nutrients.add("<#53DDE8>" + this.lang.vitamins);
+ };
+
+ Utils.sendColoredMini(player, message);
+ }
+
+ private void manageStat(@NotNull Player player, @Nullable Info info, @NotNull String type) {
+ if (!this.config.mechanics_status_scoreboard) return;
+ PlayerData playerData = this.playerManager.getPlayerData(player);
+
+ if (info == null) {
+ for (Info value : Info.values()) {
+ switch (type) {
+ case "toggle" -> playerData.setInfoDisplayed(value, !playerData.isInfoDisplayed(value));
+ case "on" -> playerData.setInfoDisplayed(value, true);
+ case "off" -> playerData.setInfoDisplayed(value, false);
+ }
+ }
+ } else {
+ switch (type) {
+ case "toggle" -> playerData.setInfoDisplayed(info, !playerData.isInfoDisplayed(info));
+ case "on" -> playerData.setInfoDisplayed(info, true);
+ case "off" -> playerData.setInfoDisplayed(info, false);
+ }
+ }
+ }
+
+ private Info getStat(String stat) {
+ try {
+ return Info.valueOf(stat.toUpperCase(Locale.ROOT));
+ } catch (IllegalArgumentException e) {
+ return null;
+ }
+ }
+
+ private void setupInfos(String stat, String tooltip) {
+ this.infoTooltips.add(BukkitStringTooltip.ofString(stat, tooltip));
+ }
+
+ private void setupTypes(String type, String tooltip) {
+ this.typeTooltips.add(BukkitStringTooltip.ofString(type, tooltip));
+ }
+
+}
diff --git a/src/main/java/com/shanebeestudios/survival/plugin/commands/SurvivalCommand.java b/src/main/java/com/shanebeestudios/survival/plugin/commands/SurvivalCommand.java
new file mode 100644
index 0000000..0af3f08
--- /dev/null
+++ b/src/main/java/com/shanebeestudios/survival/plugin/commands/SurvivalCommand.java
@@ -0,0 +1,41 @@
+package com.shanebeestudios.survival.plugin.commands;
+
+import dev.jorel.commandapi.CommandTree;
+import com.shanebeestudios.survival.plugin.SurvivalPlugin;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SurvivalCommand {
+
+ public SurvivalCommand(SurvivalPlugin plugin, String commandName) {
+ List arguments = new ArrayList<>();
+
+ arguments.add(new GiveItemCommand(plugin));
+ arguments.add(new HealCommand(plugin));
+ arguments.add(new NutritionCommand(plugin));
+ arguments.add(new PlayerDataCommand(plugin));
+ arguments.add(new ReloadCommand(plugin));
+ arguments.add(new StatCommand(plugin));
+
+ if (plugin.getSurvivalConfig().settings_local_chat_distance >= 0) {
+ arguments.add(new ToggleChatCommand(plugin));
+ }
+
+ // TODO comment out
+ arguments.add(new DataGenCommand(plugin));
+ arguments.add(new DebugCommand(plugin));
+
+ register(commandName, arguments);
+ }
+
+ private void register(String commandName, List arguments) {
+ CommandTree command = new CommandTree(commandName);
+ for (BaseCommand argument : arguments) {
+ command.then(argument.register());
+ }
+
+ command.register();
+ }
+
+}
diff --git a/src/main/java/com/shanebeestudios/survival/plugin/commands/ToggleChatCommand.java b/src/main/java/com/shanebeestudios/survival/plugin/commands/ToggleChatCommand.java
new file mode 100644
index 0000000..0abea12
--- /dev/null
+++ b/src/main/java/com/shanebeestudios/survival/plugin/commands/ToggleChatCommand.java
@@ -0,0 +1,53 @@
+package com.shanebeestudios.survival.plugin.commands;
+
+import com.shanebeestudios.survival.api.data.Permissions;
+import dev.jorel.commandapi.BukkitStringTooltip;
+import dev.jorel.commandapi.IStringTooltip;
+import dev.jorel.commandapi.arguments.Argument;
+import dev.jorel.commandapi.arguments.ArgumentSuggestions;
+import dev.jorel.commandapi.arguments.LiteralArgument;
+import dev.jorel.commandapi.arguments.StringArgument;
+import org.bukkit.entity.Player;
+import com.shanebeestudios.survival.plugin.SurvivalPlugin;
+import com.shanebeestudios.survival.api.data.PlayerData;
+import com.shanebeestudios.survival.api.util.Utils;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class ToggleChatCommand extends BaseCommand {
+
+ private final List typeTooltips = new ArrayList<>();
+
+ public ToggleChatCommand(SurvivalPlugin plugin) {
+ super(plugin);
+ setupInfos("global", "Set chat to global chat");
+ setupInfos("local", "Set chat to local chat");
+ }
+
+ @Override
+ Argument register() {
+ return LiteralArgument.literal("chat")
+ .withPermission(Permissions.COMMAND_CHAT.permission())
+ //.then(new StringArgument("type")
+ .then(new StringArgument("type")
+ .replaceSuggestions(ArgumentSuggestions.stringsWithTooltips(this.typeTooltips))
+ .executesPlayer(info -> {
+ Player player = info.sender();
+ String type = info.args().getByClassOrDefault("type", String.class, "global");
+ PlayerData playerData = this.playerManager.getPlayerData(player);
+ if (type.equalsIgnoreCase("global")) {
+ Utils.sendColoredMini(player, lang.toggle_chat_global);
+ playerData.setLocalChat(false);
+ } else if (type.equalsIgnoreCase("local")) {
+ Utils.sendColoredMini(player, lang.toggle_chat_local);
+ playerData.setLocalChat(true);
+ }
+ }));
+ }
+
+ private void setupInfos(String stat, String tooltip) {
+ this.typeTooltips.add(BukkitStringTooltip.ofString(stat, tooltip));
+ }
+
+}
diff --git a/src/main/java/com/shanebeestudios/survival/plugin/config/Config.java b/src/main/java/com/shanebeestudios/survival/plugin/config/Config.java
new file mode 100644
index 0000000..6fe7531
--- /dev/null
+++ b/src/main/java/com/shanebeestudios/survival/plugin/config/Config.java
@@ -0,0 +1,563 @@
+package com.shanebeestudios.survival.plugin.config;
+
+import com.shanebeestudios.survival.plugin.SurvivalPlugin;
+import com.shanebeestudios.survival.api.goals.AngryWolfGoal;
+import com.shanebeestudios.survival.api.util.Utils;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.Registry;
+import org.bukkit.Tag;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Mob;
+
+import java.io.File;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Config {
+
+ private final SurvivalPlugin plugin;
+ private FileConfiguration settings;
+ private File configFile;
+
+ public String lang;
+
+ public String settings_resource_pack_url;
+ public boolean settings_resource_pack_enabled;
+
+ public int settings_local_chat_distance;
+
+ public boolean welcome_guide_enabled;
+ public boolean welcome_guide_new_players;
+ public int welcome_guide_delay;
+
+ // SURVIVAL
+ public boolean survival_enabled;
+ public boolean survival_unlock_all_recipes;
+ public boolean survival_remove_wood_tools;
+ public boolean survival_torch;
+ public boolean survival_update_merchant_trades;
+ public boolean survival_update_loot_tables;
+
+ public boolean survival_break_only_with_sickle;
+ public boolean survival_break_only_with_shovel;
+ public boolean survival_break_only_with_axe;
+ public boolean survival_break_only_with_pickaxe;
+ public boolean survival_break_only_with_shears;
+ public boolean survival_place_only_with_hammer;
+
+ public boolean survival_sickle_flint;
+ public boolean survival_sickle_stone;
+ public boolean survival_sickle_iron;
+ public boolean survival_sickle_diamond;
+
+ public double survival_drop_rate_stick;
+ public double survival_drop_rate_flint;
+
+ // MECHANICS
+ public boolean mechanics_shared_workbench;
+
+ // ENERGY
+ public boolean mechanics_energy_enabled;
+ public double mechanics_energy_start;
+ public double mechanics_energy_respawn;
+ public int mechanics_energy_immunity_minutes;
+ public boolean mechanics_energy_warning;
+ public double mechanics_energy_drain_rate;
+ public double mechanics_energy_drain_cold_rate;
+ public double mechanics_energy_refresh_rate_bed;
+ public double mechanics_energy_refresh_rate_chair;
+ public double mechanics_energy_exhaustion;
+ public boolean mechanics_energy_coffee_enabled;
+ public boolean mechanics_energy_absorption;
+ public boolean mechanics_energy_haste;
+
+ public boolean mechanics_slow_armor;
+ public boolean mechanics_reinforced_armor;
+ public boolean mechanics_bow;
+ public boolean mechanics_recurved_bow;
+ public boolean mechanics_grappling_hook;
+ public boolean mechanics_medic_kit;
+ public boolean mechanics_reduced_iron_nugget;
+ public boolean mechanics_reduced_gold_nugget;
+
+ public boolean mechanics_status_scoreboard;
+ public int MECHANICS_ALERT_INTERVAL;
+
+ public boolean mechanics_raw_meat_hunger;
+ public boolean mechanics_empty_potion;
+ public boolean mechanics_poison_potato;
+ public boolean mechanics_cookie_boost;
+ public boolean mechanics_beet_strength;
+
+ public boolean mechanics_food_diversity_enabled;
+ public int mechanics_food_max_level;
+ public int mechanics_food_start_carbs;
+ public int mechanics_food_start_protein;
+ public int mechanics_food_start_vitamins;
+ public int mechanics_food_immunity_minutes;
+ public int mechanics_food_respawn_proteins;
+ public int mechanics_food_respawn_vitamins;
+ public int mechanics_food_respawn_carbs;
+ public int mechanics_food_effects_carbs_ex_amp_easy;
+ public int mechanics_food_effects_carbs_ex_amp_medium;
+ public int mechanics_food_effects_carbs_ex_amp_hard;
+ public int mechanics_food_effects_vitamins_ex_amp;
+ public String mechanics_food_effects_vitamins_se_normal_effect;
+ public int mechanics_food_effects_vitamins_se_normal_amp;
+ public int mechanics_food_effects_vitamins_se_normal_duration;
+ public String mechanics_food_effects_vitamins_se_hard_effect;
+ public int mechanics_food_effects_vitamins_se_hard_amp;
+ public int mechanics_food_effects_vitamins_se_hard_duration;
+ public int mechanics_food_effects_protein_ex_amp;
+ public String mechanics_food_effects_protein_se_normal_effect;
+ public int mechanics_food_effects_protein_se_normal_amp;
+ public int mechanics_food_effects_protein_se_normal_duration;
+ public String mechanics_food_effects_protein_se_hard_effect;
+ public int mechanics_food_effects_protein_se_hard_amp;
+ public int mechanics_food_effects_protein_se_hard_duration;
+
+ // THIRST
+ public boolean mechanics_thirst_enabled;
+ public double mechanics_thirst_starting_amount;
+ public double mechanics_thirst_respawn_amount;
+ public int mechanics_thirst_immunity_minutes;
+ public boolean mechanics_thirst_purify_water;
+ public boolean mechanics_thirst_melt_snow;
+ public double mechanics_thirst_drain_rate;
+ public double mechanics_thirst_heat_drain_rate;
+ public double mechanics_thirst_nether_drain_rate;
+ public double mechanics_thirst_damage_rate;
+ public double mechanics_thirst_rep_apple;
+ public double mechanics_thirst_rep_beetroot_soup;
+ public double mechanics_thirst_rep_melon_slice;
+ public double mechanics_thirst_rep_mush_stew;
+ public double mechanics_thirst_rep_milk_bucket;
+ public double mechanics_thirst_rep_water;
+ public double mechanics_thirst_rep_honey_bottle;
+ public double mechanics_thirst_rep_other_water;
+
+ public int mechanics_hunger_start_amount;
+ public int mechanics_hunger_respawn_amount;
+
+ public boolean mechanics_compass_waypoint;
+ public boolean mechanics_compass_waypoint_worlds;
+ public boolean mechanics_tropical_fish;
+ public boolean mechanics_fermented_skin;
+ public boolean mechanics_living_slime;
+ public boolean mechanics_snowball_revamp;
+
+ public boolean mechanics_farming_products_cookie;
+ public boolean mechanics_farming_products_bread;
+
+ public boolean mechanics_chairs_enabled;
+ public int mechanics_chairs_max_width;
+ public List mechanics_chairs_blocks;
+
+ public boolean mechanics_weather_enabled;
+ public double mechanics_weather_speed_base;
+ public double mechanics_weather_speed_rain;
+ public double mechanics_weather_speed_storm;
+ public double mechanics_weather_speed_snow;
+ public double mechanics_weather_speed_snowstorm;
+
+ // ITEM MECHANICS
+ public int item_mechanics_firestriker_cook_time;
+
+ // ENTITY MECHANICS
+ public boolean entity_mechanics_pigmen_chest_enabled;
+ public int entity_mechanics_pigmen_chest_radius;
+ public double entity_mechanics_pigmen_chest_speed;
+ public boolean entity_mechanics_beekeeper_suit_enabled;
+ public boolean entity_mechanics_suspicious_meat_enabled;
+ public int entity_mechanics_suspicious_meat_chance;
+ public boolean entity_mechanics_chicken_breeding_enabled;
+ public int entity_mechanics_chicken_breeding_max_eggs;
+ public boolean entity_mechanics_chicken_breeding_always_baby;
+ public int entity_mechanics_chicken_breeding_baby_ticks;
+ public boolean entity_mechanics_piglin_drop_water;
+ public boolean entity_mechanics_piglin_alt_drop;
+ public List entity_mechanics_mobs_avoid_players;
+ public AngryWolfGoal.Type entity_mechanics_angry_wolves;
+
+ // RECIPES
+ public boolean recipes_saddle;
+ public boolean recipes_name_tag;
+ public boolean recipes_packed_ice;
+ public boolean recipes_leather_bard;
+ public boolean recipes_iron_bard;
+ public boolean recipes_gold_bard;
+ public boolean recipes_diamond_bard;
+ public boolean recipes_clay_brick;
+ public boolean recipes_quartz_block;
+ public boolean recipes_wool_string;
+ public boolean recipes_web_string;
+ public boolean recipes_ice;
+ public boolean recipes_clay;
+ public boolean recipes_diorite;
+ public boolean recipes_granite;
+ public boolean recipes_andesite;
+ public boolean recipes_gravel;
+ public boolean recipes_slimeball;
+ public boolean recipes_cobweb;
+ public boolean recipes_sapling_stick;
+ public boolean recipes_fishing_rod;
+ public boolean recipes_furnace;
+ public boolean recipes_workbench;
+
+ // LEGENDARY TOOLS
+ public boolean legendary_valkyrie;
+ public boolean legendary_quartz_pickaxe;
+ public boolean legendary_obsidian_mace;
+ public boolean legendary_giant_blade;
+ public boolean legendary_blaze_sword;
+ public boolean legendary_notch_apple;
+ public boolean legendary_gold_armor_buff;
+
+ // HIDDEN CONFIG
+ public int recipe_delay;
+
+ public Config(SurvivalPlugin plugin) {
+ this.plugin = plugin;
+ }
+
+ public void loadDefaultSettings() {
+ if (this.configFile == null) {
+ this.configFile = new File(plugin.getDataFolder(), "config.yml");
+ }
+ if (!this.configFile.exists()) {
+ this.plugin.saveResource("config.yml", false);
+ this.settings = YamlConfiguration.loadConfiguration(this.configFile);
+ Utils.logMini("new config.yml created");
+ } else {
+ this.settings = YamlConfiguration.loadConfiguration(this.configFile);
+ }
+ matchConfig(this.settings, this.configFile);
+ loadSettings();
+ Utils.logMini("config.yml loaded");
+ }
+
+ // Used to update config
+ @SuppressWarnings("ConstantConditions")
+ private void matchConfig(FileConfiguration config, File file) {
+ try {
+ boolean hasUpdated = false;
+ InputStream is = plugin.getResource(file.getName());
+ assert is != null;
+ InputStreamReader isr = new InputStreamReader(is);
+ YamlConfiguration defConfig = YamlConfiguration.loadConfiguration(isr);
+ for (String key : defConfig.getConfigurationSection("").getKeys(true)) {
+ if (!config.contains(key)) {
+ config.set(key, defConfig.get(key));
+ hasUpdated = true;
+ }
+ }
+ for (String key : config.getConfigurationSection("").getKeys(true)) {
+ if (!defConfig.contains(key) && !key.equalsIgnoreCase("recipe-delay")) {
+ config.set(key, null);
+ hasUpdated = true;
+ }
+ }
+ if (hasUpdated)
+ config.save(file);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ @SuppressWarnings("unused")
+ public FileConfiguration getSettings() {
+ return this.settings;
+ }
+
+ private void loadSettings() {
+ this.lang = this.settings.getString("Language");
+
+ // SETTINGS
+ this.settings_resource_pack_enabled = this.settings.getBoolean("settings.enable-resource-pack");
+ this.settings_resource_pack_url = this.settings.getString("settings.resource-pack-url");
+ this.settings_local_chat_distance = this.settings.getInt("settings.local-chat-distance");
+
+ // WELCOME GUIDE
+ this.welcome_guide_enabled = this.settings.getBoolean("welcome-guide.enabled");
+ this.welcome_guide_new_players = this.settings.getBoolean("welcome-guide.new-players-only");
+ this.welcome_guide_delay = this.settings.getInt("welcome-guide.delay");
+
+ // SURVIVAL
+ this.survival_enabled = this.settings.getBoolean("survival.enabled");
+ this.survival_unlock_all_recipes = this.settings.getBoolean("survival.unlock-all-recipes-on-join");
+ this.survival_remove_wood_tools = this.settings.getBoolean("survival.remove-wooden-tools");
+ this.survival_torch = this.settings.getBoolean("survival.torch"); // TODO move to recipes area?!?!?
+ this.survival_update_merchant_trades = this.settings.getBoolean("survival.update-merchant-trades");
+ this.survival_update_loot_tables = this.settings.getBoolean("survival.update-loot-tables");
+
+ this.survival_break_only_with_sickle = this.settings.getBoolean("survival.break-only-with.sickle");
+ this.survival_break_only_with_shovel = this.settings.getBoolean("survival.break-only-with.shovel");
+ this.survival_break_only_with_axe = this.settings.getBoolean("survival.break-only-with.axe");
+ this.survival_break_only_with_pickaxe = this.settings.getBoolean("survival.break-only-with.pickaxe");
+ this.survival_break_only_with_shears = this.settings.getBoolean("survival.break-only-with.shears");
+ this.survival_place_only_with_hammer = this.settings.getBoolean("survival.place-only-with.hammer");
+
+ this.survival_sickle_flint = this.settings.getBoolean("survival.sickles.flint");
+ this.survival_sickle_stone = this.settings.getBoolean("survival.sickles.stone");
+ this.survival_sickle_iron = this.settings.getBoolean("survival.sickles.iron");
+ this.survival_sickle_diamond = this.settings.getBoolean("survival.sickles.diamond");
+
+ this.survival_drop_rate_stick = this.settings.getDouble("survival.drop-rate.stick");
+ this.survival_drop_rate_flint = this.settings.getDouble("survival.drop-rate.flint");
+
+ // MECHANICS
+ this.mechanics_slow_armor = this.settings.getBoolean("mechanics.slow-armor");
+ this.mechanics_reinforced_armor = this.settings.getBoolean("mechanics.reinforced-leather-armor");
+ this.mechanics_bow = this.settings.getBoolean("mechanics.bow");
+ this.mechanics_recurved_bow = this.settings.getBoolean("mechanics.recurve-bow");
+ this.mechanics_grappling_hook = this.settings.getBoolean("mechanics.grappling-hook");
+ this.mechanics_medic_kit = this.settings.getBoolean("mechanics.medical-kit");
+ this.mechanics_reduced_iron_nugget = this.settings.getBoolean("mechanics.reduced-iron-nugget");
+ this.mechanics_reduced_gold_nugget = this.settings.getBoolean("mechanics.reduced-gold-nugget");
+
+ this.mechanics_status_scoreboard = this.settings.getBoolean("mechanics.status-scoreboard");
+ this.MECHANICS_ALERT_INTERVAL = this.settings.getInt("mechanics.alert-interval");
+
+ this.mechanics_raw_meat_hunger = this.settings.getBoolean("mechanics.raw-meat-hunger");
+ this.mechanics_empty_potion = this.settings.getBoolean("mechanics.empty-potions");
+ this.mechanics_poison_potato = this.settings.getBoolean("mechanics.poisonous-potato");
+ this.mechanics_cookie_boost = this.settings.getBoolean("mechanics.cookie-health-boost");
+ this.mechanics_beet_strength = this.settings.getBoolean("mechanics.beetroot-strength");
+
+ this.mechanics_food_diversity_enabled = this.settings.getBoolean("mechanics.food-diversity.enabled");
+ this.mechanics_food_immunity_minutes = this.settings.getInt("mechanics.food-diversity.immunity-minutes");
+ this.mechanics_food_max_level = this.settings.getInt("mechanics.food-diversity.max-level");
+ this.mechanics_food_diversity_enabled = this.settings.getBoolean("mechanics.food-diversity.enabled");
+ this.mechanics_food_start_carbs = this.settings.getInt("mechanics.food-diversity.start-level.carbs");
+ this.mechanics_food_start_vitamins = this.settings.getInt("mechanics.food-diversity.start-level.vitamins");
+ this.mechanics_food_start_protein = this.settings.getInt("mechanics.food-diversity.start-level.proteins");
+ this.mechanics_food_diversity_enabled = this.settings.getBoolean("mechanics.food-diversity.enabled");
+ this.mechanics_food_respawn_carbs = this.settings.getInt("mechanics.food-diversity.respawn-level.carbs");
+ this.mechanics_food_respawn_vitamins = this.settings.getInt("mechanics.food-diversity.respawn-level.vitamins");
+ this.mechanics_food_respawn_proteins = this.settings.getInt("mechanics.food-diversity.respawn-level.proteins");
+ this.mechanics_food_effects_carbs_ex_amp_easy = this.settings.getInt("mechanics.food-diversity.effects.carbs.exhaustion-amplifier.easy");
+ this.mechanics_food_effects_carbs_ex_amp_medium = this.settings.getInt("mechanics.food-diversity.effects.carbs.exhaustion-amplifier.normal");
+ this.mechanics_food_effects_carbs_ex_amp_hard = this.settings.getInt("mechanics.food-diversity.effects.carbs.exhaustion-amplifier.hard");
+ this.mechanics_food_effects_vitamins_ex_amp = this.settings.getInt("mechanics.food-diversity.effects.vitamins.exhaustion-amplifier");
+ this.mechanics_food_effects_vitamins_se_normal_effect = this.settings.getString("mechanics.food-diversity.effects.vitamins.status-effects.normal.effect");
+ this.mechanics_food_effects_vitamins_se_normal_amp = this.settings.getInt("mechanics.food-diversity.effects.vitamins.status-effects.normal.amplifier");
+ this.mechanics_food_effects_vitamins_se_normal_duration = this.settings.getInt("mechanics.food-diversity.effects.vitamins.status-effects.normal.duration");
+ this.mechanics_food_effects_vitamins_se_hard_effect = this.settings.getString("mechanics.food-diversity.effects.vitamins.status-effects.hard.effect");
+ this.mechanics_food_effects_vitamins_se_hard_amp = this.settings.getInt("mechanics.food-diversity.effects.vitamins.status-effects.hard.amplifier");
+ this.mechanics_food_effects_vitamins_se_hard_duration = this.settings.getInt("mechanics.food-diversity.effects.vitamins.status-effects.hard.duration");
+
+ this.mechanics_food_effects_protein_ex_amp = this.settings.getInt("mechanics.food-diversity.effects.proteins.exhaustion-amplifier");
+ this.mechanics_food_effects_protein_se_normal_effect = this.settings.getString("mechanics.food-diversity.effects.proteins.status-effects.normal.effect");
+ this.mechanics_food_effects_protein_se_normal_amp = this.settings.getInt("mechanics.food-diversity.effects.proteins.status-effects.normal.amplifier");
+ this.mechanics_food_effects_protein_se_normal_duration = this.settings.getInt("mechanics.food-diversity.effects.proteins.status-effects.normal.duration");
+ this.mechanics_food_effects_protein_se_hard_effect = this.settings.getString("mechanics.food-diversity.effects.proteins.status-effects.hard.effect");
+ this.mechanics_food_effects_protein_se_hard_amp = this.settings.getInt("mechanics.food-diversity.effects.proteins.status-effects.hard.amplifier");
+ this.mechanics_food_effects_protein_se_hard_duration = this.settings.getInt("mechanics.food-diversity.effects.proteins.status-effects.hard.duration");
+
+ this.mechanics_thirst_enabled = this.settings.getBoolean("mechanics.thirst.enabled");
+ this.mechanics_thirst_starting_amount = this.settings.getDouble("mechanics.thirst.starting-amount");
+ this.mechanics_thirst_respawn_amount = this.settings.getDouble("mechanics.thirst.respawn-amount");
+ this.mechanics_thirst_immunity_minutes = this.settings.getInt("mechanics.thirst.immunity-minutes");
+ this.mechanics_thirst_purify_water = this.settings.getBoolean("mechanics.thirst.purify-water");
+ this.mechanics_thirst_melt_snow = this.settings.getBoolean("mechanics.thirst.melt-snow");
+ this.mechanics_thirst_drain_rate = this.settings.getDouble("mechanics.thirst.drain-rate");
+ this.mechanics_thirst_heat_drain_rate = this.settings.getDouble("mechanics.thirst.heat-drain-rate");
+ this.mechanics_thirst_nether_drain_rate = this.settings.getDouble("mechanics.thirst.nether-drain-rate");
+ this.mechanics_thirst_damage_rate = this.settings.getDouble("mechanics.thirst.damage-rate");
+
+ this.mechanics_thirst_rep_apple = this.settings.getDouble("mechanics.thirst.replenish-level.apple");
+ this.mechanics_thirst_rep_beetroot_soup = this.settings.getDouble("mechanics.thirst.replenish-level.beetroot-soup");
+ this.mechanics_thirst_rep_melon_slice = this.settings.getDouble("mechanics.thirst.replenish-level.melon-slice");
+ this.mechanics_thirst_rep_mush_stew = this.settings.getDouble("mechanics.thirst.replenish-level.mushroom-stew");
+ this.mechanics_thirst_rep_milk_bucket = this.settings.getDouble("mechanics.thirst.replenish-level.milk-bucket");
+ this.mechanics_thirst_rep_honey_bottle = this.settings.getDouble("mechanics.thirst.replenish-level.honey-bottle");
+ this.mechanics_thirst_rep_other_water = this.settings.getDouble("mechanics.thirst.replenish-level.other-water");
+ this.mechanics_thirst_rep_water = this.settings.getDouble("mechanics.thirst.replenish-level.water");
+
+ this.mechanics_shared_workbench = this.settings.getBoolean("mechanics.shared-workbench");
+ this.mechanics_energy_enabled = this.settings.getBoolean("mechanics.energy.enabled");
+ this.mechanics_energy_start = this.settings.getDouble("mechanics.energy.start-level");
+ this.mechanics_energy_respawn = this.settings.getDouble("mechanics.energy.respawn-level");
+ this.mechanics_energy_immunity_minutes = this.settings.getInt("mechanics.energy.immunity-minutes");
+ this.mechanics_energy_warning = this.settings.getBoolean("mechanics.energy.warning");
+ this.mechanics_energy_drain_rate = this.settings.getDouble("mechanics.energy.drain-rate");
+ this.mechanics_energy_drain_cold_rate = this.settings.getDouble("mechanics.energy.cold-drain-rate");
+ this.mechanics_energy_refresh_rate_bed = this.settings.getDouble("mechanics.energy.sleeping-refresh-rate");
+ this.mechanics_energy_refresh_rate_chair = this.settings.getDouble("mechanics.energy.chair-refresh-rate");
+ this.mechanics_energy_exhaustion = this.settings.getDouble("mechanics.energy.exhaustion");
+ this.mechanics_energy_coffee_enabled = this.settings.getBoolean("mechanics.energy.coffee");
+ this.mechanics_energy_absorption = this.settings.getBoolean("mechanics.energy.absorption");
+ this.mechanics_energy_haste = this.settings.getBoolean("mechanics.energy.haste");
+
+ this.mechanics_hunger_start_amount = this.settings.getInt("mechanics.hunger.starting-amount");
+ this.mechanics_hunger_respawn_amount = this.settings.getInt("mechanics.hunger.respawn-amount");
+
+ this.mechanics_compass_waypoint = this.settings.getBoolean("mechanics.compass-waypoint.enabled");
+ this.mechanics_compass_waypoint_worlds = this.settings.getBoolean("mechanics.compass-waypoint.per-world");
+
+ this.mechanics_tropical_fish = this.settings.getBoolean("mechanics.tropical-fish");
+ this.mechanics_fermented_skin = this.settings.getBoolean("mechanics.fermented-skin");
+ this.mechanics_living_slime = this.settings.getBoolean("mechanics.living-slime");
+
+ this.mechanics_snowball_revamp = this.settings.getBoolean("mechanics.snowball-revamp");
+
+ this.mechanics_farming_products_cookie = this.settings.getBoolean("mechanics.farming-products.cookie");
+ this.mechanics_farming_products_bread = this.settings.getBoolean("mechanics.farming-products.bread");
+
+ this.mechanics_chairs_enabled = this.settings.getBoolean("mechanics.chairs.enabled");
+ this.mechanics_chairs_max_width = this.settings.getInt("mechanics.chairs.max-chair-width");
+ this.mechanics_chairs_blocks = getChairBlocks();
+
+ this.mechanics_weather_enabled = this.settings.getBoolean("mechanics.weather.enabled");
+ this.mechanics_weather_speed_base = this.settings.getDouble("mechanics.weather.speed.base");
+ this.mechanics_weather_speed_rain = this.settings.getDouble("mechanics.weather.speed.rain");
+ this.mechanics_weather_speed_storm = this.settings.getDouble("mechanics.weather.speed.storm");
+ this.mechanics_weather_speed_snow = this.settings.getDouble("mechanics.weather.speed.snow");
+ this.mechanics_weather_speed_snowstorm = this.settings.getDouble("mechanics.weather.speed.snowstorm");
+
+ // ITEM MECHANICS
+ this.item_mechanics_firestriker_cook_time = this.settings.getInt("item-mechanics.firestriker.cook-time");
+
+ // ENTITY MECHANICS
+ this.entity_mechanics_pigmen_chest_enabled = this.settings.getBoolean("entity-mechanics.zombified-piglin-chests.enabled");
+ this.entity_mechanics_pigmen_chest_radius = this.settings.getInt("entity-mechanics.zombified-piglin-chests.distance");
+ this.entity_mechanics_pigmen_chest_speed = this.settings.getDouble("entity-mechanics.zombified-piglin-chests.speed-modifier");
+ this.entity_mechanics_beekeeper_suit_enabled = this.settings.getBoolean("entity-mechanics.beekeeper-suit.enabled");
+ this.entity_mechanics_suspicious_meat_enabled = this.settings.getBoolean("entity-mechanics.suspicious-meat.enabled");
+ this.entity_mechanics_suspicious_meat_chance = this.settings.getInt("entity-mechanics.suspicious-meat.chance");
+ this.entity_mechanics_chicken_breeding_enabled = this.settings.getBoolean("entity-mechanics.chicken-breeding.enabled");
+ this.entity_mechanics_chicken_breeding_max_eggs = this.settings.getInt("entity-mechanics.chicken-breeding.max-eggs");
+ this.entity_mechanics_chicken_breeding_always_baby = this.settings.getBoolean("entity-mechanics.chicken-breeding.always-baby");
+ this.entity_mechanics_chicken_breeding_baby_ticks = this.settings.getInt("entity-mechanics.chicken-breeding.baby-ticks");
+ this.entity_mechanics_piglin_drop_water = this.settings.getBoolean("entity-mechanics.piglin-barter.drop-purified-water");
+ this.entity_mechanics_piglin_alt_drop = this.settings.getBoolean("entity-mechanics.piglin-barter.alternate-bartering");
+ this.entity_mechanics_mobs_avoid_players = getEntityTypes("entity-mechanics.mobs-avoid-players");
+ this.entity_mechanics_angry_wolves = AngryWolfGoal.Type.getByKey(this.settings.getString("entity-mechanics.angry-wolves", "night"));
+
+ // RECIPES
+ this.recipes_saddle = this.settings.getBoolean("recipes.saddle");
+ this.recipes_name_tag = this.settings.getBoolean("recipes.nametag");
+ this.recipes_packed_ice = this.settings.getBoolean("recipes.packed-ice");
+ this.recipes_leather_bard = this.settings.getBoolean("recipes.leather-bard");
+ this.recipes_iron_bard = this.settings.getBoolean("recipes.iron-bard");
+ this.recipes_gold_bard = this.settings.getBoolean("recipes.gold-bard");
+ this.recipes_diamond_bard = this.settings.getBoolean("recipes.diamond-bard");
+ this.recipes_clay_brick = this.settings.getBoolean("recipes.clay-brick");
+ this.recipes_quartz_block = this.settings.getBoolean("recipes.quartz-block");
+ this.recipes_wool_string = this.settings.getBoolean("recipes.wool-string");
+ this.recipes_web_string = this.settings.getBoolean("recipes.web-string");
+ this.recipes_ice = this.settings.getBoolean("recipes.ice");
+ this.recipes_clay = this.settings.getBoolean("recipes.clay");
+ this.recipes_diorite = this.settings.getBoolean("recipes.diorite");
+ this.recipes_granite = this.settings.getBoolean("recipes.granite");
+ this.recipes_andesite = this.settings.getBoolean("recipes.andesite");
+ this.recipes_gravel = this.settings.getBoolean("recipes.gravel");
+ this.recipes_slimeball = this.settings.getBoolean("recipes.slimeball");
+ this.recipes_cobweb = this.settings.getBoolean("recipes.cobweb");
+ this.recipes_sapling_stick = this.settings.getBoolean("recipes.sapling-to-sticks");
+ this.recipes_fishing_rod = this.settings.getBoolean("recipes.fishing-rod");
+ this.recipes_furnace = this.settings.getBoolean("recipes.furnace");
+ this.recipes_workbench = this.settings.getBoolean("recipes.workbench");
+
+ // LEGENDARY ITEMS
+ this.legendary_valkyrie = this.settings.getBoolean("legendary-items.valkyrie-axe");
+ this.legendary_quartz_pickaxe = this.settings.getBoolean("legendary-items.quartz-pickaxe");
+ this.legendary_obsidian_mace = this.settings.getBoolean("legendary-items.obsidian-mace");
+ this.legendary_giant_blade = this.settings.getBoolean("legendary-items.giant-blade");
+ this.legendary_blaze_sword = this.settings.getBoolean("legendary-items.blaze-sword");
+ this.legendary_notch_apple = this.settings.getBoolean("legendary-items.notch-apple");
+ this.legendary_gold_armor_buff = this.settings.getBoolean("legendary-items.gold-armor-buff");
+
+ // HIDDEN CONFIG
+ this.recipe_delay = this.settings.getInt("recipe-delay", 0);
+ }
+
+ private List getChairBlocks() {
+ List materials = new ArrayList<>();
+ List allowedByStrings = this.settings.getStringList("mechanics.chairs.allowed-blocks");
+ for (String string : allowedByStrings) {
+ if (string.startsWith("#")) {
+ NamespacedKey key;
+ if (string.contains(":")) key = NamespacedKey.fromString(string.substring(1));
+ else key = NamespacedKey.minecraft(string.substring(1));
+
+ if (key != null) {
+ Tag tag = Bukkit.getTag(Tag.REGISTRY_BLOCKS, key, Material.class);
+ if (tag != null) {
+ for (Material material : tag.getValues()) {
+ if (Tag.STAIRS.isTagged(material)) {
+ materials.add(material);
+ } else {
+ Utils.logMini("Invalid chair material: %s", key.toString());
+ }
+ }
+ }
+ }
+ } else {
+ NamespacedKey key;
+ if (string.contains(":")) key = NamespacedKey.fromString(string);
+ else key = NamespacedKey.minecraft(string);
+
+ if (key != null) {
+ Material material = Registry.MATERIAL.get(key);
+ if (material != null) {
+ if (Tag.STAIRS.isTagged(material)) {
+ materials.add(material);
+ } else {
+ Utils.logMini("Invalid chair material: %s", key.toString());
+ }
+ }
+
+ }
+ }
+ }
+ return materials;
+ }
+
+ @SuppressWarnings("SameParameterValue")
+ private List getEntityTypes(String path) {
+ List entityTypes = new ArrayList<>();
+ List stringList = this.settings.getStringList(path);
+ for (String string : stringList) {
+ if (string.startsWith("#")) {
+ NamespacedKey key;
+ if (string.contains(":")) key = NamespacedKey.fromString(string);
+ else key = NamespacedKey.minecraft(string);
+ if (key != null) {
+ Tag tag = Bukkit.getTag(Tag.REGISTRY_ENTITY_TYPES, key, EntityType.class);
+ if (tag != null) {
+ for (EntityType entityType : tag.getValues()) {
+ if (entityType != null) {
+ Class entityClass = entityType.getEntityClass();
+ if (entityClass == null || !Mob.class.isAssignableFrom(entityClass)) continue;
+ entityTypes.add(entityType);
+ }
+ }
+ }
+ }
+ } else {
+ NamespacedKey key;
+ if (string.contains(":")) key = NamespacedKey.fromString(string);
+ else key = NamespacedKey.minecraft(string);
+ if (key != null) {
+ EntityType entityType = Registry.ENTITY_TYPE.get(key);
+ if (entityType != null) {
+ Class entityClass = entityType.getEntityClass();
+ if (entityClass == null || !Mob.class.isAssignableFrom(entityClass)) continue;
+ entityTypes.add(entityType);
+ }
+ }
+ }
+ }
+
+ return entityTypes;
+ }
+
+}
diff --git a/src/main/java/com/shanebeestudios/survival/plugin/config/ItemConfig.java b/src/main/java/com/shanebeestudios/survival/plugin/config/ItemConfig.java
new file mode 100644
index 0000000..da8f851
--- /dev/null
+++ b/src/main/java/com/shanebeestudios/survival/plugin/config/ItemConfig.java
@@ -0,0 +1,170 @@
+package com.shanebeestudios.survival.plugin.config;
+
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import com.shanebeestudios.survival.plugin.SurvivalPlugin;
+import com.shanebeestudios.survival.api.item.Nutrition;
+import com.shanebeestudios.survival.api.util.Utils;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.List;
+
+public class ItemConfig {
+
+ public static ItemConfig INSTANCE;
+ private final SurvivalPlugin plugin = SurvivalPlugin.getInstance();
+ private FileConfiguration settings;
+ private File configFile;
+
+ public ItemConfig() {
+ INSTANCE = this;
+ loadDefaultSettings();
+ Nutrition.setup();
+ save();
+ Utils.logMini("