diff --git a/.github/workflows/pulls.yml b/.github/workflows/pulls.yml new file mode 100644 index 000000000..cbc5b3171 --- /dev/null +++ b/.github/workflows/pulls.yml @@ -0,0 +1,17 @@ +name: PR Categorization + +on: + pull_request: + types: [opened, reopened] + +jobs: + assign_labels: + runs-on: ubuntu-latest + name: Categorize Pull Requests + steps: + - name: Branch Categorization + uses: TheBusyBiscuit/branch-cat@v1.0.6 + with: + rules: '{ "fix\/.+" : "Bug Fix" }' + env: + GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }} diff --git a/pom.xml b/pom.xml index b3116f0f2..83a0d54e7 100644 --- a/pom.xml +++ b/pom.xml @@ -1,5 +1,6 @@ + 4.0.0 me.mrCookieSlime Slimefun @@ -29,10 +30,10 @@ https://maven.sk89q.com/repo/ - CodeMC - https://repo.codemc.org/repository/maven-public - - + CodeMC + https://repo.codemc.org/repository/maven-public + + placeholderapi-repo http://repo.extendedclip.com/content/repositories/placeholderapi/ @@ -41,6 +42,7 @@ ${project.basedir}/src/main/java ${project.name} v${project.version} + org.apache.maven.plugins @@ -54,34 +56,31 @@ - - org.apache.maven.plugins - maven-shade-plugin - 3.2.1 - - - - - org.bstats - me.mrCookieSlime.Slimefun.bstats - - - - io.github.thebusybiscuit.cscorelib2 - me.mrCookieSlime.Slimefun.cscorelib2 - - - - - - - package - - shade - - - - + + org.apache.maven.plugins + maven-shade-plugin + 3.2.1 + + + + org.bstats + me.mrCookieSlime.Slimefun.bstats + + + io.github.thebusybiscuit.cscorelib2 + me.mrCookieSlime.Slimefun.cscorelib2 + + + + + + package + + shade + + + + @@ -94,63 +93,64 @@ + org.bukkit bukkit - 1.14.4-R0.1-SNAPSHOT + 1.15-R0.1-SNAPSHOT provided com.github.TheBusyBiscuit CS-CoreLib - 6e17183656 - provided - - - com.github.thebusybiscuit - CS-CoreLib2 - 0.7.3 - compile - - - org.bstats - bstats-bukkit - 1.5 - compile - - - com.sk89q.worldedit - worldedit-bukkit - 7.0.1 + ec5b4c24e3 provided - me.clip - placeholderapi - 2.10.4 - provided + com.github.thebusybiscuit + CS-CoreLib2 + 0.7.6 + compile + + + org.bstats + bstats-bukkit + 1.5 + compile + + + com.sk89q.worldedit + worldedit-bukkit + 7.0.1 + provided + + + me.clip + placeholderapi + 2.10.4 + provided me.minebuilders clearlag-core - 2.9.7 + 2.9.7 system ${project.basedir}/lib/Clearlag.jar me.mrCookieSlime EmeraldEnchants - 2.0 + 2.0 system ${project.basedir}/lib/EmeraldEnchants v2.0.jar me.mrCookieSlime ExoticGarden - 1.2.0 + 1.2.0 system ${project.basedir}/lib/ExoticGarden v1.2.0.jar - + \ No newline at end of file diff --git a/src/main/java/me/mrCookieSlime/Slimefun/api/ErrorReport.java b/src/main/java/io/github/thebusybiscuit/slimefun4/api/ErrorReport.java similarity index 77% rename from src/main/java/me/mrCookieSlime/Slimefun/api/ErrorReport.java rename to src/main/java/io/github/thebusybiscuit/slimefun4/api/ErrorReport.java index eaa76a5a3..983343742 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/api/ErrorReport.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/api/ErrorReport.java @@ -1,4 +1,4 @@ -package me.mrCookieSlime.Slimefun.api; +package io.github.thebusybiscuit.slimefun4.api; import java.io.File; import java.io.FileNotFoundException; @@ -20,22 +20,18 @@ import org.bukkit.plugin.Plugin; import me.mrCookieSlime.CSCoreLibPlugin.CSCoreLib; import me.mrCookieSlime.Slimefun.SlimefunPlugin; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem; +import me.mrCookieSlime.Slimefun.api.BlockStorage; +import me.mrCookieSlime.Slimefun.api.PlayerProfile; +import me.mrCookieSlime.Slimefun.api.Slimefun; +import me.mrCookieSlime.Slimefun.api.TickerTask; public class ErrorReport { private File file; public ErrorReport(Throwable throwable, Consumer printer) { - SlimefunPlugin.instance.getServer().getScheduler().scheduleSyncDelayedTask(SlimefunPlugin.instance, () -> { - String path = "plugins/Slimefun/error-reports/" + new SimpleDateFormat("yyyy-MM-dd-HH-mm").format(new Date()); - file = new File(path + ".err"); - - if (file.exists()) { - IntStream stream = IntStream.iterate(1, i -> i + 1).filter(i -> !new File(path + " (" + i + ").err").exists()); - int id = stream.findFirst().getAsInt(); - - file = new File(path + " (" + id + ").err"); - } + Slimefun.runSync(() -> { + file = getNewFile(); try (PrintStream stream = new PrintStream(file)) { stream.println(); @@ -55,18 +51,7 @@ public class ErrorReport { List plugins = new ArrayList<>(); List addons = new ArrayList<>(); - for (Plugin p: Bukkit.getPluginManager().getPlugins()) { - if (Bukkit.getPluginManager().isPluginEnabled(p)) { - plugins.add(" + " + p.getName() + ' ' + p.getDescription().getVersion()); - if (p.getDescription().getDepend().contains("Slimefun") || p.getDescription().getSoftDepend().contains("Slimefun")) - addons.add(" + " + p.getName() + ' ' + p.getDescription().getVersion()); - } - else { - plugins.add(" - " + p.getName() + ' ' + p.getDescription().getVersion()); - if (p.getDescription().getDepend().contains("Slimefun") || p.getDescription().getSoftDepend().contains("Slimefun")) - addons.add(" - " + p.getName() + ' ' + p.getDescription().getVersion()); - } - } + scanPlugins(plugins, addons); stream.println("Installed Addons (" + addons.size() + ")"); addons.forEach(stream::println); @@ -95,7 +80,7 @@ public class ErrorReport { } }); } - + public ErrorReport(Throwable throwable, TickerTask task, Location l, SlimefunItem item) { this(throwable, stream -> { stream.println("Block Info:"); @@ -155,6 +140,37 @@ public class ErrorReport { }); } + private void scanPlugins(List plugins, List addons) { + String dependency = "Slimefun"; + + for (Plugin plugin : Bukkit.getPluginManager().getPlugins()) { + if (Bukkit.getPluginManager().isPluginEnabled(plugin)) { + plugins.add(" + " + plugin.getName() + ' ' + plugin.getDescription().getVersion()); + if (plugin.getDescription().getDepend().contains(dependency) || plugin.getDescription().getSoftDepend().contains(dependency)) + addons.add(" + " + plugin.getName() + ' ' + plugin.getDescription().getVersion()); + } + else { + plugins.add(" - " + plugin.getName() + ' ' + plugin.getDescription().getVersion()); + if (plugin.getDescription().getDepend().contains(dependency) || plugin.getDescription().getSoftDepend().contains(dependency)) + addons.add(" - " + plugin.getName() + ' ' + plugin.getDescription().getVersion()); + } + } + } + + private File getNewFile() { + String path = "plugins/Slimefun/error-reports/" + new SimpleDateFormat("yyyy-MM-dd-HH-mm").format(new Date()); + File newFile = new File(path + ".err"); + + if (newFile.exists()) { + IntStream stream = IntStream.iterate(1, i -> i + 1).filter(i -> !new File(path + " (" + i + ").err").exists()); + int id = stream.findFirst().getAsInt(); + + newFile = new File(path + " (" + id + ").err"); + } + + return newFile; + } + public File getFile() { return file; } diff --git a/src/main/java/io/github/thebusybiscuit/slimefun4/api/JsonDataHolder.java b/src/main/java/io/github/thebusybiscuit/slimefun4/api/JsonDataHolder.java new file mode 100644 index 000000000..55778ab81 --- /dev/null +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/api/JsonDataHolder.java @@ -0,0 +1,161 @@ +package io.github.thebusybiscuit.slimefun4.api; + +import java.util.Optional; +import java.util.function.Function; +import java.util.function.IntFunction; + +import com.google.gson.JsonArray; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonPrimitive; + +public abstract class JsonDataHolder { + + protected JsonObject data; + private boolean dirty; + + public JsonDataHolder() { + this(null); + } + + public JsonDataHolder(JsonObject data) { + this.data = data != null ? data: new JsonObject(); + this.dirty = false; + } + + public void markDirty() { + dirty = true; + } + + public void markClean() { + dirty = false; + } + + public boolean isDirty() { + return dirty; + } + + // Setters + public void setString(String key, String value) { + data.addProperty(key, value); + markDirty(); + } + + public void setInt(String key, int value) { + data.addProperty(key, value); + markDirty(); + } + + public void setBoolean(String key, boolean value) { + data.addProperty(key, value); + markDirty(); + } + + public void setFloat(String key, float value) { + data.addProperty(key, value); + markDirty(); + } + + public void setStringArray(String key, String[] array) { + JsonArray json = new JsonArray(); + for (String value: array) json.add(value); + data.add(key, json); + markDirty(); + } + + public void setIntArray(String key, int[] array) { + JsonArray json = new JsonArray(); + for (int value: array) json.add(value); + data.add(key, json); + markDirty(); + } + + public void setBooleanArray(String key, boolean[] array) { + JsonArray json = new JsonArray(); + for (boolean value: array) json.add(value); + data.add(key, json); + markDirty(); + } + + public void setFloatArray(String key, float[] array) { + JsonArray json = new JsonArray(); + for (float value: array) json.add(value); + data.add(key, json); + markDirty(); + } + + // Getters + public Optional getString(String key) { + return getPrimitive(key, JsonElement::getAsString); + } + public String getString(String key, String defaultValue) { + return getString(key).orElse(defaultValue); + } + + public Optional getInt(String key) { + return getPrimitive(key, JsonElement::getAsInt); + } + public int getInt(String key, int defaultValue) { + return getInt(key).orElse(defaultValue); + } + + public Optional getBoolean(String key) { + return getPrimitive(key, JsonElement::getAsBoolean); + } + public boolean getBoolean(String key, boolean defaultValue) { + return getBoolean(key).orElse(defaultValue); + } + + public Optional getFloat(String key) { + return getPrimitive(key, JsonElement::getAsFloat); + } + public float getFloat(String key, float defaultValue) { + return getFloat(key).orElse(defaultValue); + } + + public Optional getStringArray(String key) { + return getArray(key, String[]::new, JsonElement::getAsString); + } + + public Optional getIntArray(String key) { + return getArray(key, Integer[]::new, JsonElement::getAsInt); + } + + public Optional getBooleanArray(String key) { + return getArray(key, Boolean[]::new, JsonElement::getAsBoolean); + } + + public Optional getFloatArray(String key) { + return getArray(key, Float[]::new, JsonElement::getAsFloat); + } + + protected Optional getArray(String key, IntFunction constructor, Function getter) { + JsonElement element = data.get(key); + + if (element instanceof JsonArray) { + JsonArray json = (JsonArray) element; + T[] array = constructor.apply(json.size()); + + for (int i = 0; i < array.length; i++) { + array[i] = getter.apply(json.get(i)); + } + + return Optional.of(array); + } + else { + return Optional.empty(); + } + } + + protected Optional getPrimitive(String key, Function getter) { + JsonElement element = data.get(key); + + if (element instanceof JsonPrimitive) { + return Optional.of(getter.apply(element)); + } + else { + return Optional.empty(); + } + } + +} \ No newline at end of file diff --git a/src/main/java/io/github/thebusybiscuit/slimefun4/api/SlimefunAPI.java b/src/main/java/io/github/thebusybiscuit/slimefun4/api/SlimefunAPI.java new file mode 100644 index 000000000..931ff50b0 --- /dev/null +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/api/SlimefunAPI.java @@ -0,0 +1,100 @@ +package io.github.thebusybiscuit.slimefun4.api; + +import java.util.Optional; +import java.util.Set; +import java.util.stream.Collectors; + +import org.bukkit.OfflinePlayer; +import org.bukkit.World; +import org.bukkit.entity.Player; +import org.bukkit.inventory.ItemStack; + +import io.github.thebusybiscuit.slimefun4.api.blocks.SlimefunBlock; +import io.github.thebusybiscuit.slimefun4.api.items.ItemRestriction; +import io.github.thebusybiscuit.slimefun4.core.SlimefunWorld; +import me.mrCookieSlime.Slimefun.Objects.Category; +import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem; +import me.mrCookieSlime.Slimefun.api.PlayerProfile; + +/** + * This class will hold the declarations of important API methods for Slimefun. + * Normally these methods will not be implemented in this interface, but some + * methods will have a default implementation for convenience. + * + * @author TheBusyBiscuit + * + */ +public interface SlimefunAPI { + + /** + * This method will register the given restriction. + * Calling this should directly influence the outcome of {@link SlimefunAPI#getItemRestrictions()}. + * + * @param restriction The restriction to register + */ + void addItemRestriction(ItemRestriction restriction); + + /** + * This method will return a {@link Set} of all instances of {@link ItemRestriction} that will directly + * affect the outcome of {@link SlimefunAPI#isAllowedToUse(Player, ItemStack, boolean)} + * + * @return The Set of all registered item restrictions + */ + Set getItemRestrictions(); + + /** + * This method will return whether a Player is allowed to use the given {@link ItemStack}. + * If warningMessages is set to true, the Player will be informed about the outcome of this method. + * + * Internally this method will loop through {@link SlimefunAPI#getItemRestrictions()} and perform + * checks using all available instances of {@link ItemRestriction}. + * + * Do NOT warn Players about a restriction if this method returns false. + * Warnings should be exclusively handled via {@link ItemRestriction#warnPlayer(PlayerProfile, Player, SlimefunItem, ItemStack)} + * + * @param p The Player to perform the check on + * @param item The Item to perform the check on + * @param sendWarnings Whether to warn the Player about not being able to use the given item + * @return Whether the Player is allowed to use the given item + */ + default boolean isAllowedToUse(Player p, ItemStack item, boolean sendWarnings) { + PlayerProfile profile = PlayerProfile.get(p); + SlimefunItem sfItem = SlimefunItem.getByItem(item); + + for (ItemRestriction restriction : getItemRestrictions()) { + if (!restriction.isAllowed(profile, p, sfItem, item)) { + if (sendWarnings) restriction.warnPlayer(profile, p, sfItem, item); + return false; + } + } + + return true; + } + + /** + * This method returns a {@link Set} of all registered instances of {@link Category}. + * + * @return A Set of all Categories + */ + Set getCategories(); + + /** + * This method returns A {@link Set} of all registered instances of {@link SlimefunItem}. + * Its default implementation generates a new Set based on all items found in the categories + * returned by {@link SlimefunAPI#getCategories()} + * + * @return A Set of all SlimefunItems + */ + default Set getItems() { + return getCategories().stream().flatMap(cat -> cat.getItems().stream()).collect(Collectors.toSet()); + } + + Optional fromItemStack(ItemStack item); + + Optional fromBlock(); + + SlimefunWorld fromWorld(World world); + + PlayerProfile fromPlayer(OfflinePlayer player); + +} diff --git a/src/main/java/io/github/thebusybiscuit/slimefun4/api/blocks/BlockLocation.java b/src/main/java/io/github/thebusybiscuit/slimefun4/api/blocks/BlockLocation.java new file mode 100644 index 000000000..eeb4e286b --- /dev/null +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/api/blocks/BlockLocation.java @@ -0,0 +1,59 @@ +package io.github.thebusybiscuit.slimefun4.api.blocks; + +import java.util.Objects; + +import org.bukkit.Location; +import org.bukkit.block.Block; + +public final class BlockLocation { + + private final int x; + private final int y; + private final int z; + + public BlockLocation(Block b) { + this(b.getX(), b.getY(), b.getZ()); + } + + public BlockLocation(Location l) { + this(l.getBlockX(), l.getBlockY(), l.getBlockZ()); + } + + public BlockLocation(int x, int y, int z) { + this.x = x; + this.y = y; + this.z = z; + } + + public int getX() { + return x; + } + + public int getY() { + return y; + } + + public int getZ() { + return z; + } + + @Override + public boolean equals(Object obj) { + if (obj instanceof BlockLocation) { + BlockLocation l = (BlockLocation) obj; + return l.getX() == x && l.getY() == y && l.getZ() == z; + } + else return false; + } + + @Override + public int hashCode() { + return Objects.hash(x, y, z); + } + + @Override + public String toString() { + return "[" + x + " | " + y + " | " + z + "]"; + } + +} \ No newline at end of file diff --git a/src/main/java/io/github/thebusybiscuit/slimefun4/api/blocks/SlimefunBlock.java b/src/main/java/io/github/thebusybiscuit/slimefun4/api/blocks/SlimefunBlock.java new file mode 100644 index 000000000..bf2b29ded --- /dev/null +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/api/blocks/SlimefunBlock.java @@ -0,0 +1,25 @@ +package io.github.thebusybiscuit.slimefun4.api.blocks; + +import com.google.gson.JsonObject; + +import io.github.thebusybiscuit.slimefun4.api.JsonDataHolder; + +public class SlimefunBlock extends JsonDataHolder { + + private String id; + + public SlimefunBlock(String id) { + this(id, null); + } + + public SlimefunBlock(String id, JsonObject data) { + super(data); + + this.id = id; + } + + public String getID() { + return id; + } + +} diff --git a/src/main/java/io/github/thebusybiscuit/slimefun4/api/events/AndroidMineEvent.java b/src/main/java/io/github/thebusybiscuit/slimefun4/api/events/AndroidMineEvent.java new file mode 100644 index 000000000..e39673ef6 --- /dev/null +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/api/events/AndroidMineEvent.java @@ -0,0 +1,68 @@ +package io.github.thebusybiscuit.slimefun4.api.events; + +import org.bukkit.block.Block; +import org.bukkit.event.Cancellable; +import org.bukkit.event.Event; +import org.bukkit.event.HandlerList; + +import me.mrCookieSlime.Slimefun.androids.AndroidEntity; + +/** + * This event is fired before a miner android mines a block. + * If this event is cancelled, the block will not be mined. + */ +public class AndroidMineEvent extends Event implements Cancellable { + + private static final HandlerList handlers = new HandlerList(); + + private final Block block; + private final AndroidEntity android; + private boolean cancelled; + + /** + * @param block - mined block + * @param android - the block of the android + */ + public AndroidMineEvent(Block block, AndroidEntity android) { + this.block = block; + this.android = android; + } + + public static HandlerList getHandlerList() { + return handlers; + } + + public HandlerList getHandlers() { + return handlers; + } + + /** + * This method returns the mined block + * + * @return the mined block + */ + public Block getBlock() { + return block; + } + + /** + * This method returns the block of the + * android who wants to mine a block. + * + * @return the block of the android + */ + public AndroidEntity getAndroid() { + return android; + } + + @Override + public boolean isCancelled() { + return cancelled; + } + + @Override + public void setCancelled(boolean cancel) { + cancelled = cancel; + } + +} \ No newline at end of file diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Events/AutoDisenchantEvent.java b/src/main/java/io/github/thebusybiscuit/slimefun4/api/events/AutoDisenchantEvent.java similarity index 93% rename from src/main/java/me/mrCookieSlime/Slimefun/Events/AutoDisenchantEvent.java rename to src/main/java/io/github/thebusybiscuit/slimefun4/api/events/AutoDisenchantEvent.java index a4643aa63..71b0e900a 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Events/AutoDisenchantEvent.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/api/events/AutoDisenchantEvent.java @@ -1,4 +1,4 @@ -package me.mrCookieSlime.Slimefun.Events; +package io.github.thebusybiscuit.slimefun4.api.events; import org.bukkit.event.Cancellable; import org.bukkit.event.Event; @@ -14,6 +14,7 @@ public class AutoDisenchantEvent extends Event implements Cancellable { public AutoDisenchantEvent(ItemStack item) { super(true); + this.item = item; } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Events/MultiBlockInteractEvent.java b/src/main/java/io/github/thebusybiscuit/slimefun4/api/events/MultiBlockInteractEvent.java similarity index 75% rename from src/main/java/me/mrCookieSlime/Slimefun/Events/MultiBlockInteractEvent.java rename to src/main/java/io/github/thebusybiscuit/slimefun4/api/events/MultiBlockInteractEvent.java index 0737cc11d..18eb21d4d 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Events/MultiBlockInteractEvent.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/api/events/MultiBlockInteractEvent.java @@ -1,4 +1,4 @@ -package me.mrCookieSlime.Slimefun.Events; +package io.github.thebusybiscuit.slimefun4.api.events; import me.mrCookieSlime.Slimefun.Objects.MultiBlock; @@ -12,9 +12,9 @@ public class MultiBlockInteractEvent extends Event implements Cancellable { private static final HandlerList handlers = new HandlerList(); - private Player p; - private MultiBlock mb; - private Block b; + private Player player; + private MultiBlock multiBlock; + private Block clickedBlock; private boolean cancelled; public HandlerList getHandlers() { @@ -26,21 +26,21 @@ public class MultiBlockInteractEvent extends Event implements Cancellable { } public MultiBlockInteractEvent(Player p, MultiBlock mb, Block clicked) { - this.p = p; - this.mb = mb; - this.b = clicked; + this.player = p; + this.multiBlock = mb; + this.clickedBlock = clicked; } public Player getPlayer() { - return this.p; + return this.player; } public MultiBlock getMultiBlock() { - return this.mb; + return this.multiBlock; } public Block getClickedBlock() { - return this.b; + return this.clickedBlock; } @Override diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Events/ResearchUnlockEvent.java b/src/main/java/io/github/thebusybiscuit/slimefun4/api/events/ResearchUnlockEvent.java similarity index 74% rename from src/main/java/me/mrCookieSlime/Slimefun/Events/ResearchUnlockEvent.java rename to src/main/java/io/github/thebusybiscuit/slimefun4/api/events/ResearchUnlockEvent.java index 9b2ba24aa..566d69353 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Events/ResearchUnlockEvent.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/api/events/ResearchUnlockEvent.java @@ -1,4 +1,4 @@ -package me.mrCookieSlime.Slimefun.Events; +package io.github.thebusybiscuit.slimefun4.api.events; import me.mrCookieSlime.Slimefun.Objects.Research; @@ -11,8 +11,8 @@ public class ResearchUnlockEvent extends Event implements Cancellable { private static final HandlerList handlers = new HandlerList(); - private Player p; - private Research r; + private Player player; + private Research research; private boolean cancelled; public HandlerList getHandlers() { @@ -23,17 +23,17 @@ public class ResearchUnlockEvent extends Event implements Cancellable { return handlers; } - public ResearchUnlockEvent(Player p, Research res) { - this.p = p; - this.r = res; + public ResearchUnlockEvent(Player p, Research research) { + this.player = p; + this.research = research; } public Player getPlayer() { - return this.p; + return this.player; } public Research getResearch() { - return this.r; + return this.research; } @Override diff --git a/src/main/java/io/github/thebusybiscuit/slimefun4/api/items/ItemRestriction.java b/src/main/java/io/github/thebusybiscuit/slimefun4/api/items/ItemRestriction.java new file mode 100644 index 000000000..d41bdffc9 --- /dev/null +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/api/items/ItemRestriction.java @@ -0,0 +1,36 @@ +package io.github.thebusybiscuit.slimefun4.api.items; + +import org.bukkit.entity.Player; +import org.bukkit.inventory.ItemStack; + +import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem; +import me.mrCookieSlime.Slimefun.api.PlayerProfile; + +public interface ItemRestriction { + + /** + * This method represents a check. + * The returned boolean will decide whether to allow the action. + * + * @param profile The Player's profile + * @param p The Player itself + * @param item The SlimefunItem that the {@link ItemStack} represents + * @param itemstack The ItemStack that is being tested. + */ + boolean isAllowed(PlayerProfile profile, Player p, SlimefunItem item, ItemStack itemstack); + + /** + * This method is executed if an ItemRestriction took affect. + * Override it to send a message to the Player telling them they cannot + * use that item, or do something else in there. + * + * @param profile The Player's profile + * @param p The Player to warn + * @param item The SlimefunItem that the {@link ItemStack} represents + * @param itemstack The ItemStack that was prevented from being used + */ + void warnPlayer(PlayerProfile profile, Player p, SlimefunItem item, ItemStack itemstack); + + + +} diff --git a/src/main/java/io/github/thebusybiscuit/slimefun4/api/items/Placeable.java b/src/main/java/io/github/thebusybiscuit/slimefun4/api/items/Placeable.java new file mode 100644 index 000000000..596085e00 --- /dev/null +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/api/items/Placeable.java @@ -0,0 +1,15 @@ +package io.github.thebusybiscuit.slimefun4.api.items; + +import java.util.Collection; + +import org.bukkit.entity.Player; +import org.bukkit.inventory.ItemStack; + +public interface Placeable { + + boolean isTicking(); + + Collection getDrops(); + Collection getDrops(Player p); + +} diff --git a/src/main/java/io/github/thebusybiscuit/slimefun4/api/recipes/ContextualRecipe.java b/src/main/java/io/github/thebusybiscuit/slimefun4/api/recipes/ContextualRecipe.java new file mode 100644 index 000000000..2ea2e6685 --- /dev/null +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/api/recipes/ContextualRecipe.java @@ -0,0 +1,13 @@ +package io.github.thebusybiscuit.slimefun4.api.recipes; + +import java.util.function.Predicate; + +import org.bukkit.inventory.ItemStack; + +public interface ContextualRecipe extends Predicate { + + boolean isShapeless(); + + ItemStack getOutput(ItemStack[] input); + +} diff --git a/src/main/java/io/github/thebusybiscuit/slimefun4/core/SlimefunWorld.java b/src/main/java/io/github/thebusybiscuit/slimefun4/core/SlimefunWorld.java new file mode 100644 index 000000000..772933992 --- /dev/null +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/core/SlimefunWorld.java @@ -0,0 +1,64 @@ +package io.github.thebusybiscuit.slimefun4.core; + +import java.util.HashMap; +import java.util.Optional; +import java.util.UUID; + +import org.bukkit.World; +import org.bukkit.block.Block; +import org.bukkit.block.TileState; + +import io.github.thebusybiscuit.cscorelib2.collections.OptionalMap; +import io.github.thebusybiscuit.slimefun4.api.blocks.BlockLocation; +import io.github.thebusybiscuit.slimefun4.api.blocks.SlimefunBlock; +import me.mrCookieSlime.Slimefun.SlimefunPlugin; + +public class SlimefunWorld { + + private final UUID uuid; + private final OptionalMap blocks = new OptionalMap<>(HashMap::new); + + public SlimefunWorld(UUID uuid) { + this.uuid = uuid; + } + + /** + * This method will return the {@link UUID} of this instance. + * The {@link UUID} will be the same for {@link SlimefunWorld} and the corresponding instance + * of {@link World}. + * + * @return This world's {@link UUID} + */ + public UUID getUUID() { + return uuid; + } + + /** + * This method will reliably get the instance of {@link SlimefunBlock} associated with the given + * {@link Block}. + * + * @param b The {@link Block} to query + * @return An {@link Optional} of the requested {@link SlimefunBlock}, empty if none was found + */ + public Optional getBlock(Block b) { + if (b.getState() instanceof TileState) { + Optional blockData = SlimefunPlugin.getBlockDataService().getBlockData((TileState) b.getState()); + + if (blockData.isPresent()) { + return Optional.of(new SlimefunBlock(blockData.get())); + } + } + + return blocks.get(new BlockLocation(b)); + } + + public boolean isBlock(Block b, String id) { + if (id == null) { + throw new IllegalArgumentException("Cannot check blocks for id: null"); + } + + Optional block = getBlock(b); + + return block.isPresent() && block.get().getID().equals(id); + } +} diff --git a/src/main/java/me/mrCookieSlime/Slimefun/guides/BookSlimefunGuide.java b/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/BookSlimefunGuide.java similarity index 75% rename from src/main/java/me/mrCookieSlime/Slimefun/guides/BookSlimefunGuide.java rename to src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/BookSlimefunGuide.java index 5eb8b23a0..0623e3c3c 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/guides/BookSlimefunGuide.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/BookSlimefunGuide.java @@ -1,4 +1,4 @@ -package me.mrCookieSlime.Slimefun.guides; +package io.github.thebusybiscuit.slimefun4.core.guide; import java.util.ArrayList; import java.util.List; @@ -9,12 +9,13 @@ import org.bukkit.Material; import org.bukkit.entity.Player; import org.bukkit.inventory.ItemStack; +import io.github.thebusybiscuit.cscorelib2.chat.ChatColors; +import io.github.thebusybiscuit.cscorelib2.inventory.ItemUtils; import me.mrCookieSlime.CSCoreLibPlugin.PlayerRunnable; import me.mrCookieSlime.CSCoreLibPlugin.general.Chat.TellRawMessage; import me.mrCookieSlime.CSCoreLibPlugin.general.Chat.TellRawMessage.HoverAction; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.CustomBookOverlay; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.Item.CustomItem; -import me.mrCookieSlime.CSCoreLibPlugin.general.String.StringUtils; import me.mrCookieSlime.Slimefun.SlimefunGuide; import me.mrCookieSlime.Slimefun.SlimefunPlugin; import me.mrCookieSlime.Slimefun.Objects.Category; @@ -87,25 +88,25 @@ public class BookSlimefunGuide implements ISlimefunGuide { actions.add(null); } } - texts.add(ChatColor.translateAlternateColorCodes('&', "&8\u21E8 &6Tier " + tier)); + texts.add(ChatColors.color("&8\u21E8 &6Tier " + tier)); tooltips.add(null); actions.add(null); } if (category instanceof LockedCategory && !((LockedCategory) category).hasUnlocked(p, profile)) { - StringBuilder parents = new StringBuilder(ChatColor.translateAlternateColorCodes('&', "&4&lLOCKED\n\n&7In order to unlock this Category,\n&7you need to unlock all Items from\n&7the following Categories first:\n")); + StringBuilder parents = new StringBuilder(ChatColors.color("&4&lLOCKED\n\n&7In order to unlock this Category,\n&7you need to unlock all Items from\n&7the following Categories first:\n")); for (Category parent: ((LockedCategory) category).getParents()) { - parents.append(ChatColor.translateAlternateColorCodes('&', "\n&c" + StringUtils.formatItemName(parent.getItem(), false))); + parents.append(ChatColors.color("\n&c" + ItemUtils.getItemName(parent.getItem()))); } - texts.add(ChatColor.translateAlternateColorCodes('&', shorten("&c" , StringUtils.formatItemName(category.getItem(), false)))); + texts.add(ChatColors.color(shorten("&c" , ItemUtils.getItemName(category.getItem())))); tooltips.add(parents.toString()); actions.add(null); } else if (category instanceof SeasonalCategory) { if (((SeasonalCategory) category).isUnlocked()) { - texts.add(ChatColor.translateAlternateColorCodes('&', shorten("&a", StringUtils.formatItemName(category.getItem(), false)))); - tooltips.add(ChatColor.translateAlternateColorCodes('&', "&eClick to open the following Category:\n" + StringUtils.formatItemName(category.getItem(), false))); + texts.add(ChatColors.color(shorten("&a", ItemUtils.getItemName(category.getItem())))); + tooltips.add(ChatColors.color("&eClick to open the following Category:\n" + ItemUtils.getItemName(category.getItem()))); actions.add(new PlayerRunnable(1) { @Override public void run(final Player p) { @@ -115,8 +116,8 @@ public class BookSlimefunGuide implements ISlimefunGuide { } } else { - texts.add(ChatColor.translateAlternateColorCodes('&', shorten("&a", StringUtils.formatItemName(category.getItem(), false)))); - tooltips.add(ChatColor.translateAlternateColorCodes('&', "&eClick to open the following Category:\n" + StringUtils.formatItemName(category.getItem(), false))); + texts.add(ChatColors.color(shorten("&a", ItemUtils.getItemName(category.getItem())))); + tooltips.add(ChatColors.color("&eClick to open the following Category:\n" + ItemUtils.getItemName(category.getItem()))); actions.add(new PlayerRunnable(1) { @Override public void run(final Player p) { @@ -141,7 +142,7 @@ public class BookSlimefunGuide implements ISlimefunGuide { for (int i = 0; i < texts.size(); i = i + 10) { TellRawMessage pageMessage = new TellRawMessage(); - pageMessage.addText(ChatColor.translateAlternateColorCodes('&', "&b&l- Slimefun Guide -\n\n")); + pageMessage.addText(ChatColors.color("&b&l- Slimefun Guide -\n\n")); for (int j = i; j < texts.size() && j < i + 10; j++) { pageMessage.addText(texts.get(j) + "\n"); if (tooltips.get(j) != null) pageMessage.addHoverEvent(HoverAction.SHOW_TEXT, tooltips.get(j)); @@ -175,8 +176,8 @@ public class BookSlimefunGuide implements ISlimefunGuide { if (survival && !Slimefun.hasUnlocked(p, item, false) && item.getResearch() != null) { final Research research = item.getResearch(); - texts.add(ChatColor.translateAlternateColorCodes('&', shorten("&7", StringUtils.formatItemName(item.getItem(), false)))); - tooltips.add(ChatColor.translateAlternateColorCodes('&', StringUtils.formatItemName(item.getItem(), false) + "\n&c&lLOCKED\n\n&7Cost: " + (p.getLevel() >= research.getCost() ? "&b": "&4") + research.getCost() + " Levels\n\n&a> Click to unlock")); + texts.add(ChatColors.color(shorten("&7", item.getItemName()))); + tooltips.add(ChatColors.color(item.getItemName() + "\n&c&lLOCKED\n\n&7Cost: " + (p.getLevel() >= research.getCost() ? "&b": "&4") + research.getCost() + " Levels\n\n&a> Click to unlock")); actions.add(new PlayerRunnable(2) { @Override @@ -207,11 +208,11 @@ public class BookSlimefunGuide implements ISlimefunGuide { }); } else { - texts.add(ChatColor.translateAlternateColorCodes('&', shorten("&a", StringUtils.formatItemName(item.getItem(), false)))); + texts.add(ChatColors.color(shorten("&a", item.getItemName()))); StringBuilder tooltip = new StringBuilder(); - tooltip.append(StringUtils.formatItemName(item.getItem(), false)); + tooltip.append(item.getItemName()); if (item.getItem().hasItemMeta() && item.getItem().getItemMeta().hasLore()) { for (String line : item.getItem().getItemMeta().getLore()) { @@ -219,7 +220,7 @@ public class BookSlimefunGuide implements ISlimefunGuide { } } - tooltip.append(ChatColor.translateAlternateColorCodes('&', "\n\n&e&oClick for more Info")); + tooltip.append(ChatColors.color("\n\n&e&oClick for more Info")); tooltips.add(tooltip.toString()); actions.add(new PlayerRunnable(2) { @@ -233,15 +234,15 @@ public class BookSlimefunGuide implements ISlimefunGuide { } } else { - texts.add(ChatColor.translateAlternateColorCodes('&', shorten("&4", StringUtils.formatItemName(item.getItem(), false)))); - tooltips.add(ChatColor.translateAlternateColorCodes('&', "&cNo Permission!")); + texts.add(ChatColors.color(shorten("&4", ItemUtils.getItemName(item.getItem())))); + tooltips.add(ChatColors.color("&cNo Permission!")); actions.add(null); } } for (int i = 0; i < texts.size(); i = i + 10) { TellRawMessage pageMessage = new TellRawMessage(); - pageMessage.addText(ChatColor.translateAlternateColorCodes('&', "&b&l- Slimefun Guide -\n\n")); + pageMessage.addText(ChatColors.color("&b&l- Slimefun Guide -\n\n")); for (int j = i; j < texts.size() && j < i + 10; j++) { pageMessage.addText(texts.get(j) + "\n"); @@ -250,8 +251,8 @@ public class BookSlimefunGuide implements ISlimefunGuide { } pageMessage.addText("\n"); - pageMessage.addText(ChatColor.translateAlternateColorCodes('&', "&6\u21E6 &lBack")); - pageMessage.addHoverEvent(HoverAction.SHOW_TEXT, ChatColor.translateAlternateColorCodes('&', "&eClick to go back to the Category Overview")); + pageMessage.addText(ChatColors.color("&6\u21E6 &lBack")); + pageMessage.addHoverEvent(HoverAction.SHOW_TEXT, ChatColors.color("&eClick to go back to the Category Overview")); pageMessage.addClickEvent(new PlayerRunnable(2) { @Override diff --git a/src/main/java/me/mrCookieSlime/Slimefun/guides/ChestSlimefunGuide.java b/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/ChestSlimefunGuide.java similarity index 92% rename from src/main/java/me/mrCookieSlime/Slimefun/guides/ChestSlimefunGuide.java rename to src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/ChestSlimefunGuide.java index 568edfebe..8d5f51e3a 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/guides/ChestSlimefunGuide.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/ChestSlimefunGuide.java @@ -1,6 +1,7 @@ -package me.mrCookieSlime.Slimefun.guides; +package io.github.thebusybiscuit.slimefun4.core.guide; import java.util.ArrayList; +import java.util.Arrays; import java.util.LinkedList; import java.util.List; import java.util.Optional; @@ -13,6 +14,7 @@ import org.bukkit.GameMode; import org.bukkit.Material; import org.bukkit.Sound; import org.bukkit.entity.Player; +import org.bukkit.inventory.ItemFlag; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.Recipe; import org.bukkit.inventory.RecipeChoice; @@ -21,9 +23,8 @@ import io.github.thebusybiscuit.cscorelib2.chat.ChatInput; import io.github.thebusybiscuit.cscorelib2.inventory.ItemUtils; import io.github.thebusybiscuit.cscorelib2.item.CustomItem; import io.github.thebusybiscuit.cscorelib2.recipes.MinecraftRecipe; +import io.github.thebusybiscuit.cscorelib2.skull.SkullItem; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.ChestMenu; -import me.mrCookieSlime.CSCoreLibPlugin.general.String.StringUtils; -import me.mrCookieSlime.CSCoreLibPlugin.general.World.CustomSkull; import me.mrCookieSlime.Slimefun.SlimefunGuide; import me.mrCookieSlime.Slimefun.SlimefunPlugin; import me.mrCookieSlime.Slimefun.Lists.RecipeType; @@ -92,7 +93,7 @@ public class ChestSlimefunGuide implements ISlimefunGuide { Category category = categories.get(target); boolean locked = true; - for (SlimefunItem item: category.getItems()) { + for (SlimefunItem item : category.getItems()) { if (Slimefun.isEnabled(p, item, false)) { locked = false; break; @@ -260,7 +261,7 @@ public class ChestSlimefunGuide implements ISlimefunGuide { } else { List message = sfitem.getNoPermissionTooltip(); - menu.addItem(index, new CustomItem(Material.BARRIER, StringUtils.formatItemName(sfitem.getItem(), false), message.toArray(new String[message.size()]))); + menu.addItem(index, new CustomItem(Material.BARRIER, sfitem.getItemName(), message.toArray(new String[message.size()]))); menu.addMenuClickHandler(index, (pl, slot, item, action) -> false); index++; } @@ -312,22 +313,32 @@ public class ChestSlimefunGuide implements ISlimefunGuide { if (index == 44) break; - if (!itemName.isEmpty()) { - if (itemName.equals(searchTerm) || itemName.contains(searchTerm)) { - menu.addItem(index, item.getItem()); - menu.addMenuClickHandler(index, (pl, slot, itm, action) -> { - if (!survival) { - pl.getInventory().addItem(item.getItem().clone()); - } - else { - displayItem(profile, item, true); - } + if (!itemName.isEmpty() && (itemName.equals(searchTerm) || itemName.contains(searchTerm))) { + ItemStack itemstack = new CustomItem(item.getItem(), meta -> { + List lore = null; + Category category = item.getCategory(); + + if (category != null && category.getItem() != null && category.getItem().hasItemMeta() && category.getItem().getItemMeta().hasDisplayName()) { + lore = Arrays.asList("", ChatColor.DARK_GRAY + "\u21E8 " + ChatColor.RESET + item.getCategory().getItem().getItemMeta().getDisplayName()); + } + + meta.setLore(lore); + meta.addItemFlags(ItemFlag.HIDE_ATTRIBUTES, ItemFlag.HIDE_ENCHANTS, ItemFlag.HIDE_POTION_EFFECTS); + }); + + menu.addItem(index, itemstack); + menu.addMenuClickHandler(index, (pl, slot, itm, action) -> { + if (!survival) { + pl.getInventory().addItem(item.getItem().clone()); + } + else { + displayItem(profile, item, true); + } - return false; - }); + return false; + }); - index++; - } + index++; } } @@ -430,7 +441,7 @@ public class ChestSlimefunGuide implements ISlimefunGuide { if (Slimefun.getItemConfig().contains(item.getID() + ".youtube")) { try { - menu.addItem(7, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjQzNTNmZDBmODYzMTQzNTM4NzY1ODYwNzViOWJkZjBjNDg0YWFiMDMzMWI4NzJkZjExYmQ1NjRmY2IwMjllZCJ9fX0="), "&rDemonstration Video &7(Youtube)", "", "&7\u21E8 Click to watch")); + menu.addItem(7, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjQzNTNmZDBmODYzMTQzNTM4NzY1ODYwNzViOWJkZjBjNDg0YWFiMDMzMWI4NzJkZjExYmQ1NjRmY2IwMjllZCJ9fX0="), "&rDemonstration Video &7(Youtube)", "", "&7\u21E8 Click to watch")); menu.addMenuClickHandler(7, (pl, slot, itemstack, action) -> { pl.closeInventory(); pl.sendMessage(""); @@ -570,7 +581,7 @@ public class ChestSlimefunGuide implements ISlimefunGuide { if (playerHistory.size() > 1) { - menu.addItem(slot, new CustomItem(new ItemStack(Material.ENCHANTED_BOOK), + menu.addItem(slot, new CustomItem(SlimefunGuide.getItem(SlimefunGuideLayout.CHEST), "&7\u21E6 Back", "", "&rLeft Click: &7Go back to previous Page", "&rShift + left Click: &7Go back to Main Menu") @@ -652,14 +663,14 @@ public class ChestSlimefunGuide implements ISlimefunGuide { if ((i + (page * 18)) < recipes.size()) { if (page == 0) { - menu.replaceExistingItem(slot, recipes.get(i + (page * 18))); + menu.replaceExistingItem(slot, recipes.get(i + (page * 18)).clone()); menu.addMenuClickHandler(slot, (pl, s, itemstack, action) -> { displayItem(profile, itemstack, true); return false; }); } else { - menu.replaceExistingItem(slot, recipes.get(i + (page * 18))); + menu.replaceExistingItem(slot, recipes.get(i + (page * 18)).clone()); } } else { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/guides/GuideSettings.java b/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/GuideSettings.java similarity index 78% rename from src/main/java/me/mrCookieSlime/Slimefun/guides/GuideSettings.java rename to src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/GuideSettings.java index 4300dec35..c7f19ffb4 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/guides/GuideSettings.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/GuideSettings.java @@ -1,4 +1,4 @@ -package me.mrCookieSlime.Slimefun.guides; +package io.github.thebusybiscuit.slimefun4.core.guide; import java.util.ArrayList; import java.util.Comparator; @@ -7,7 +7,6 @@ import java.util.List; import java.util.Map; import java.util.logging.Level; -import me.mrCookieSlime.CSCoreLibPlugin.CSCoreLib; import org.bukkit.ChatColor; import org.bukkit.Material; import org.bukkit.Sound; @@ -16,16 +15,17 @@ import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.SkullMeta; import io.github.thebusybiscuit.cscorelib2.chat.ChatColors; +import io.github.thebusybiscuit.cscorelib2.skull.SkullItem; +import io.github.thebusybiscuit.slimefun4.core.services.github.Contributor; +import io.github.thebusybiscuit.slimefun4.core.utils.ChatUtils; +import io.github.thebusybiscuit.slimefun4.core.utils.NumberUtils; +import me.mrCookieSlime.CSCoreLibPlugin.CSCoreLib; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.ChestMenu; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.Item.CustomItem; -import me.mrCookieSlime.CSCoreLibPlugin.general.World.CustomSkull; import me.mrCookieSlime.Slimefun.SlimefunGuide; import me.mrCookieSlime.Slimefun.SlimefunPlugin; import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; import me.mrCookieSlime.Slimefun.api.Slimefun; -import me.mrCookieSlime.Slimefun.hooks.github.Contributor; -import me.mrCookieSlime.Slimefun.hooks.github.IntegerFormat; -import me.mrCookieSlime.Slimefun.utils.ChatUtils; public final class GuideSettings { @@ -50,7 +50,7 @@ public final class GuideSettings { menu.addMenuClickHandler(i, (pl, slot, item, action) -> false); } - if (SlimefunManager.isItemSimiliar(guide, getItem(SlimefunGuideLayout.CHEST), true)) { + if (SlimefunManager.isItemSimilar(guide, getItem(SlimefunGuideLayout.CHEST), true)) { if (p.hasPermission("slimefun.cheat.items")) { menu.addItem(19, new CustomItem(new ItemStack(Material.CHEST), "&7Guide Layout: &eChest GUI", "", "&aChest GUI", "&7Book GUI", "&7Cheat Sheet", "", "&e Click &8\u21E8 &7Change Layout")); menu.addMenuClickHandler(19, (pl, slot, item, action) -> { @@ -68,7 +68,7 @@ public final class GuideSettings { }); } } - else if (SlimefunManager.isItemSimiliar(guide, getItem(SlimefunGuideLayout.BOOK), true)) { + else if (SlimefunManager.isItemSimilar(guide, getItem(SlimefunGuideLayout.BOOK), true)) { if (p.hasPermission("slimefun.cheat.items")) { menu.addItem(19, new CustomItem(new ItemStack(Material.BOOK), "&7Guide Layout: &eBook GUI", "", "&7Chest GUI", "&aBook GUI", "&7Cheat Sheet", "", "&e Click &8\u21E8 &7Change Layout")); menu.addMenuClickHandler(19, (pl, slot, item, action) -> { @@ -86,7 +86,7 @@ public final class GuideSettings { }); } } - else if (SlimefunManager.isItemSimiliar(guide, getItem(SlimefunGuideLayout.CHEAT_SHEET), true)) { + else if (SlimefunManager.isItemSimilar(guide, getItem(SlimefunGuideLayout.CHEAT_SHEET), true)) { menu.addItem(19, new CustomItem(new ItemStack(Material.COMMAND_BLOCK), "&7Guide Layout: &eCheat Sheet", "", "&7Chest GUI", "&7Book GUI", "&aCheat Sheet", "", "&e Click &8\u21E8 &7Change Layout")); menu.addMenuClickHandler(19, (pl, slot, item, action) -> { pl.getInventory().setItemInMainHand(getItem(SlimefunGuideLayout.CHEST)); @@ -101,7 +101,7 @@ public final class GuideSettings { "&7Slimefun Version: &a" + Slimefun.getVersion(), "&7CS-CoreLib Version: &a" + CSCoreLib.getLib().getDescription().getVersion(), "&7Installed Addons: &b" + Slimefun.getInstalledAddons().size(), - "&7Contributors: &e" + SlimefunPlugin.getUtilities().contributors.size(), + "&7Contributors: &e" + SlimefunPlugin.getGitHubService().getContributors().size(), "", "&7\u21E8 Click to see the people behind this Plugin" )); @@ -111,7 +111,7 @@ public final class GuideSettings { }); try { - menu.addItem(5, new CustomItem(new ItemStack(Material.COMPARATOR), "&eSource Code", "", "&7Bytes of Code: &6" + IntegerFormat.formatBigNumber(SlimefunPlugin.getUtilities().codeBytes), "&7Last Update: &a" + IntegerFormat.timeDelta(SlimefunPlugin.getUtilities().lastUpdate) + " ago", "&7Forks: &e" + SlimefunPlugin.getUtilities().forks, "&7Stars: &e" + SlimefunPlugin.getUtilities().stars, "", "&7&oSlimefun 4 is a community project,", "&7&othe source code is available on GitHub", "&7&oand if you want to keep this Plugin alive,", "&7&othen please consider contributing to it", "", "&7\u21E8 Click to go to GitHub")); + menu.addItem(5, new CustomItem(new ItemStack(Material.COMPARATOR), "&eSource Code", "", "&7Bytes of Code: &6" + NumberUtils.formatBigNumber(SlimefunPlugin.getGitHubService().getCodeSize()), "&7Last Activity: &a" + NumberUtils.timeDelta(SlimefunPlugin.getGitHubService().getLastUpdate()) + " ago", "&7Forks: &e" + SlimefunPlugin.getGitHubService().getForks(), "&7Stars: &e" + SlimefunPlugin.getGitHubService().getStars(), "", "&7&oSlimefun 4 is a community project,", "&7&othe source code is available on GitHub", "&7&oand if you want to keep this Plugin alive,", "&7&othen please consider contributing to it", "", "&7\u21E8 Click to go to GitHub")); menu.addMenuClickHandler(5, (pl, slot, item, action) -> { pl.closeInventory(); ChatUtils.sendURL(pl, "https://github.com/TheBusyBiscuit/Slimefun4"); @@ -128,7 +128,7 @@ public final class GuideSettings { return false; }); - menu.addItem(20, new CustomItem(new ItemStack(Material.REDSTONE), "&4Report a bug", "", "&7Open Issues: &a" + SlimefunPlugin.getUtilities().issues, "&7Pending Pull Requests: &a" + SlimefunPlugin.getUtilities().prs, "", "&7\u21E8 Click to go to the Slimefun Bug Tracker")); + menu.addItem(20, new CustomItem(new ItemStack(Material.REDSTONE), "&4Report a bug", "", "&7Open Issues: &a" + SlimefunPlugin.getGitHubService().getIssues(), "&7Pending Pull Requests: &a" + SlimefunPlugin.getGitHubService().getPullRequests(), "", "&7\u21E8 Click to go to the Slimefun Bug Tracker")); menu.addMenuClickHandler(20, (pl, slot, item, action) -> { pl.closeInventory(); ChatUtils.sendURL(pl, "https://github.com/TheBusyBiscuit/Slimefun4/issues"); @@ -167,7 +167,7 @@ public final class GuideSettings { } } - List contributors = new ArrayList<>(SlimefunPlugin.getUtilities().contributors.values()); + List contributors = new ArrayList<>(SlimefunPlugin.getGitHubService().getContributors().values()); contributors.sort(Comparator.comparingInt(Contributor::index)); boolean hasPrevious = page > 0; @@ -183,19 +183,27 @@ public final class GuideSettings { ItemStack skull = new ItemStack(Material.PLAYER_HEAD); try { - skull = CustomSkull.getItem(contributor.getTexture()); + skull = SkullItem.fromBase64(contributor.getTexture()); } catch (Exception e) { - Slimefun.getLogger().log(Level.SEVERE, "An Error occured while inserting a Contributors head.", e); + Slimefun.getLogger().log(Level.SEVERE, "An Error occurred while inserting a Contributors head.", e); } SkullMeta meta = (SkullMeta) skull.getItemMeta(); - meta.setDisplayName(ChatColor.GRAY + contributor.getName()); + meta.setDisplayName(ChatColor.GRAY + contributor.getName() + + (!contributor.getName().equals(contributor.getMinecraftName()) ? ChatColor.DARK_GRAY + " (MC: " + contributor.getMinecraftName() + ")" : "") + ); List lore = new LinkedList<>(); lore.add(""); - for (Map.Entry entry: contributor.getContributions().entrySet()) { - lore.add(ChatColors.color(entry.getKey() + " &7(" + entry.getValue() + " Commit" + (entry.getValue() > 1 ? "s": "") + ")")); + for (Map.Entry entry : contributor.getContributions().entrySet()) { + String info = entry.getKey(); + + if (entry.getValue() > 0) { + info += " &7(" + entry.getValue() + " Commit" + (entry.getValue() > 1 ? "s": "") + ")"; + } + + lore.add(ChatColors.color(info)); } lore.add(""); @@ -203,8 +211,8 @@ public final class GuideSettings { meta.setLore(lore); skull.setItemMeta(meta); - menu.addItem(i + 9, skull); - menu.addMenuClickHandler(i + 9, (pl, slot, item, action) -> { + menu.addItem(i - page * 36 + 9, skull); + menu.addMenuClickHandler(i - page * 36 + 9, (pl, slot, item, action) -> { pl.closeInventory(); ChatUtils.sendURL(pl, contributor.getProfile()); return false; diff --git a/src/main/java/me/mrCookieSlime/Slimefun/guides/ISlimefunGuide.java b/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/ISlimefunGuide.java similarity index 87% rename from src/main/java/me/mrCookieSlime/Slimefun/guides/ISlimefunGuide.java rename to src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/ISlimefunGuide.java index f138b7422..f4ceb7543 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/guides/ISlimefunGuide.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/ISlimefunGuide.java @@ -1,4 +1,4 @@ -package me.mrCookieSlime.Slimefun.guides; +package io.github.thebusybiscuit.slimefun4.core.guide; import java.util.LinkedList; @@ -22,8 +22,12 @@ public interface ISlimefunGuide { void displayItem(PlayerProfile profile, SlimefunItem item, boolean addToHistory); default String shorten(String string, String string2) { - if (ChatColor.stripColor(string + string2).length() > 19) return (string + ChatColor.stripColor(string2)).substring(0, 18) + "..."; - else return (string + ChatColor.stripColor(string2)); + if (ChatColor.stripColor(string + string2).length() > 19) { + return (string + ChatColor.stripColor(string2)).substring(0, 18) + "..."; + } + else { + return string + ChatColor.stripColor(string2); + } } default Object getLastEntry(PlayerProfile profile, boolean remove) { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/guides/SlimefunGuideLayout.java b/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/SlimefunGuideLayout.java similarity index 55% rename from src/main/java/me/mrCookieSlime/Slimefun/guides/SlimefunGuideLayout.java rename to src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/SlimefunGuideLayout.java index 62a559394..c749af853 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/guides/SlimefunGuideLayout.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/SlimefunGuideLayout.java @@ -1,4 +1,4 @@ -package me.mrCookieSlime.Slimefun.guides; +package io.github.thebusybiscuit.slimefun4.core.guide; public enum SlimefunGuideLayout { diff --git a/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/BlockDataService.java b/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/BlockDataService.java new file mode 100644 index 000000000..4e66061bd --- /dev/null +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/BlockDataService.java @@ -0,0 +1,28 @@ +package io.github.thebusybiscuit.slimefun4.core.services; + +import java.util.Optional; + +import org.bukkit.NamespacedKey; +import org.bukkit.block.TileState; +import org.bukkit.plugin.Plugin; + +import io.github.thebusybiscuit.cscorelib2.data.PersistentDataAPI; + +public class BlockDataService { + + private final NamespacedKey namespacedKey; + + public BlockDataService(Plugin plugin, String key) { + namespacedKey = new NamespacedKey(plugin, key); + } + + public void setBlockData(TileState tileEntity, String value) { + PersistentDataAPI.setString(tileEntity, namespacedKey, value); + tileEntity.update(); + } + + public Optional getBlockData(TileState tileEntity) { + return PersistentDataAPI.getOptionalString(tileEntity, namespacedKey); + } + +} diff --git a/src/main/java/me/mrCookieSlime/Slimefun/services/CustomItemDataService.java b/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/CustomItemDataService.java similarity index 94% rename from src/main/java/me/mrCookieSlime/Slimefun/services/CustomItemDataService.java rename to src/main/java/io/github/thebusybiscuit/slimefun4/core/services/CustomItemDataService.java index 9d75560ee..fddcf9b92 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/services/CustomItemDataService.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/CustomItemDataService.java @@ -1,4 +1,4 @@ -package me.mrCookieSlime.Slimefun.services; +package io.github.thebusybiscuit.slimefun4.core.services; import java.util.Optional; diff --git a/src/main/java/me/mrCookieSlime/Slimefun/services/CustomTextureService.java b/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/CustomTextureService.java similarity index 73% rename from src/main/java/me/mrCookieSlime/Slimefun/services/CustomTextureService.java rename to src/main/java/io/github/thebusybiscuit/slimefun4/core/services/CustomTextureService.java index 57b4b6a64..a22dff4b0 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/services/CustomTextureService.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/CustomTextureService.java @@ -1,6 +1,4 @@ -package me.mrCookieSlime.Slimefun.services; - -import java.util.Collection; +package io.github.thebusybiscuit.slimefun4.core.services; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.ItemMeta; @@ -12,23 +10,37 @@ import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem; public class CustomTextureService { private final Config config; + private boolean modified = false; public CustomTextureService(Plugin plugin) { this.config = new Config(plugin, "item-models.yml"); } - public void setup(Collection items) { + public void setup(Iterable items) { config.setDefaultValue("SLIMEFUN_GUIDE", 0); + for (SlimefunItem item : items) { if (item != null && item.getID() != null) { config.setDefaultValue(item.getID(), 0); + + if (config.getInt(item.getID()) != 0) { + modified = true; + } } } config.save(); } + public String getVersion() { + return config.getString("version"); + } + + public boolean isActive() { + return modified; + } + public int getModelData(String id) { return config.getInt(id); } diff --git a/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/MetricsService.java b/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/MetricsService.java new file mode 100644 index 000000000..afb80ef5e --- /dev/null +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/MetricsService.java @@ -0,0 +1,43 @@ +package io.github.thebusybiscuit.slimefun4.core.services; + +import org.bstats.bukkit.Metrics; + +import me.mrCookieSlime.Slimefun.SlimefunPlugin; + +public class MetricsService extends Metrics { + + public MetricsService(SlimefunPlugin plugin) { + super(plugin); + + addCustomChart(new SimplePie("auto_updates", () -> + SlimefunPlugin.getCfg().getBoolean("options.auto-update") ? "enabled": "disabled" + )); + + addCustomChart(new SimplePie("resourcepack", () -> { + String version = SlimefunPlugin.getItemTextureService().getVersion(); + + if (SlimefunPlugin.getItemTextureService().isActive()) { + return "Custom / Modified"; + } + else if (version != null) { + return version + " (Official)"; + } + else { + return "None"; + } + })); + + addCustomChart(new SimplePie("branch", () -> { + if (plugin.getDescription().getVersion().startsWith("DEV - ")) { + return "master"; + } + else if (plugin.getDescription().getVersion().startsWith("RC - ")) { + return "stable"; + } + else { + return "Unknown"; + } + })); + } + +} diff --git a/src/main/java/me/mrCookieSlime/Slimefun/hooks/github/ContributionsConnector.java b/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/github/ContributionsConnector.java similarity index 57% rename from src/main/java/me/mrCookieSlime/Slimefun/hooks/github/ContributionsConnector.java rename to src/main/java/io/github/thebusybiscuit/slimefun4/core/services/github/ContributionsConnector.java index 89631716d..1b2af8543 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/hooks/github/ContributionsConnector.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/github/ContributionsConnector.java @@ -1,29 +1,48 @@ -package me.mrCookieSlime.Slimefun.hooks.github; +package io.github.thebusybiscuit.slimefun4.core.services.github; import java.util.Arrays; +import java.util.HashMap; import java.util.List; +import java.util.Map; import com.google.gson.JsonArray; import com.google.gson.JsonElement; import com.google.gson.JsonObject; -import me.mrCookieSlime.Slimefun.SlimefunPlugin; - public class ContributionsConnector extends GitHubConnector { - + // GitHub Bots that do not count as Contributors // (includes "invalid-email-address" because it is an invalid contributor) private static final List blacklist = Arrays.asList( "invalid-email-address", "renovate-bot", - "ImgBotApp" + "ImgBotApp", + "TheBusyBot", + "imgbot" ); + + // Matches a GitHub name with a Minecraft name. + private static final Map aliases = new HashMap<>(); + + // Should probably be switched to UUIDs at some point... + static { + aliases.put("WalshyDev", "HumanRightsAct"); + aliases.put("J3fftw1", "_lagpc_"); + aliases.put("ajan-12", "ajan_12"); + aliases.put("LinoxGH", "ajan_12"); + aliases.put("NihilistBrew", "ma1yang2"); + aliases.put("NihilistBrew", "ma1yang2"); + aliases.put("mrcoffee1026", "mr_coffee1026"); + aliases.put("BluGhostYT", "CyberPatriot"); + } private final String prefix; private final String repository; private final String role; - public ContributionsConnector(String prefix, String repository, String role) { + public ContributionsConnector(GitHubService github, String prefix, String repository, String role) { + super(github); + this.prefix = prefix; this.repository = repository; this.role = role; @@ -46,19 +65,22 @@ public class ContributionsConnector extends GitHubConnector { @Override public String getURLSuffix() { - return "/contributors"; + return "/contributors?per_page=100"; } private void computeContributors(JsonArray array) { for (int i = 0; i < array.size(); i++) { JsonObject object = array.get(i).getAsJsonObject(); - + String name = object.get("login").getAsString(); int commits = object.get("contributions").getAsInt(); String profile = object.get("html_url").getAsString(); - + if (!blacklist.contains(name)) { - Contributor contributor = SlimefunPlugin.getUtilities().contributors.computeIfAbsent(name, key -> new Contributor(name, profile)); + Contributor contributor = github.getContributors().computeIfAbsent( + name, + key -> new Contributor(aliases.getOrDefault(name, name), profile) + ); contributor.setContribution(role, commits); } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/hooks/github/Contributor.java b/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/github/Contributor.java similarity index 61% rename from src/main/java/me/mrCookieSlime/Slimefun/hooks/github/Contributor.java rename to src/main/java/io/github/thebusybiscuit/slimefun4/core/services/github/Contributor.java index b32a9cd4f..619201d12 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/hooks/github/Contributor.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/github/Contributor.java @@ -1,4 +1,4 @@ -package me.mrCookieSlime.Slimefun.hooks.github; +package io.github.thebusybiscuit.slimefun4.core.services.github; import java.util.Map; import java.util.Optional; @@ -13,15 +13,21 @@ import java.util.concurrent.ConcurrentMap; public class Contributor { private static final String PLACEHOLDER_HEAD = "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvNDZiYTYzMzQ0ZjQ5ZGQxYzRmNTQ4OGU5MjZiZjNkOWUyYjI5OTE2YTZjNTBkNjEwYmI0MGE1MjczZGM4YzgyIn19fQ=="; - - private String name; - private String profile; - private Optional headTexture; + + private final String ghName; + private final String mcName; + private String profileLink; private final ConcurrentMap contributions = new ConcurrentHashMap<>(); + // This field is nullable. + // null = "Texture was not pulled yet or failed to pull, it will try again next time" + // empty Optional = "No Texture could be found for this person. + private Optional headTexture; + public Contributor(String name, String profile) { - this.name = name; - this.profile = profile; + this.ghName = profile.substring(profile.lastIndexOf('/') + 1); + this.mcName = name; + this.profileLink = profile; } public void setContribution(String role, int commits) { @@ -35,7 +41,17 @@ public class Contributor { * @since 4.1.13 */ public String getName() { - return this.name; + return this.ghName; + } + + /** + * Returns the MC name of the contributor. + * This may be the same as {@link #getName()}. + * + * @return The MC username of this contributor. + */ + public String getMinecraftName() { + return this.mcName; } /** @@ -45,7 +61,7 @@ public class Contributor { * @since 4.1.13 */ public String getProfile() { - return this.profile; + return this.profileLink; } public Map getContributions() { @@ -53,7 +69,10 @@ public class Contributor { } /** - * Returns this Creator's head texture + * Returns this Creator's head texture. + * If no texture could be found, or it hasn't been pulled yet, + * then it will return a placeholder texture. + * * @return A Base64-Head Texture */ public String getTexture() { @@ -65,6 +84,12 @@ public class Contributor { } } + /** + * This method will return whether this instance of {@link Contributor} has + * pulled a texture yet. + * + * @return Whether this {@link Contributor} has been assigned a texture yet + */ public boolean hasTexture() { return headTexture != null; } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/hooks/github/GitHubConnector.java b/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/github/GitHubConnector.java similarity index 83% rename from src/main/java/me/mrCookieSlime/Slimefun/hooks/github/GitHubConnector.java rename to src/main/java/io/github/thebusybiscuit/slimefun4/core/services/github/GitHubConnector.java index 21b25d33a..859bf5113 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/hooks/github/GitHubConnector.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/github/GitHubConnector.java @@ -1,4 +1,4 @@ -package me.mrCookieSlime.Slimefun.hooks.github; +package io.github.thebusybiscuit.slimefun4.core.services.github; import java.io.BufferedReader; import java.io.File; @@ -14,16 +14,17 @@ import java.util.logging.Level; import com.google.gson.JsonElement; import com.google.gson.JsonParser; -import me.mrCookieSlime.Slimefun.SlimefunPlugin; import me.mrCookieSlime.Slimefun.api.Slimefun; public abstract class GitHubConnector { - private File file; + protected final File file; + protected final GitHubService github; - public GitHubConnector() { - this.file = new File("plugins/Slimefun/cache/github/" + this.getFileName() + ".json"); - SlimefunPlugin.getUtilities().connectors.add(this); + public GitHubConnector(GitHubService github) { + this.github = github; + + file = new File("plugins/Slimefun/cache/github/" + this.getFileName() + ".json"); } public abstract String getFileName(); @@ -36,7 +37,7 @@ public abstract class GitHubConnector { } public void pullFile() { - if (SlimefunPlugin.getCfg().getBoolean("options.print-out-github-data-retrieving")) { + if (github.isLoggingEnabled()) { Slimefun.getLogger().log(Level.INFO, "Retrieving '" + this.getFileName() + ".json' from GitHub..."); } @@ -55,7 +56,7 @@ public abstract class GitHubConnector { } } } catch (IOException e) { - if (SlimefunPlugin.getCfg().getBoolean("options.print-out-github-data-retrieving")) { + if (github.isLoggingEnabled()) { Slimefun.getLogger().log(Level.WARNING, "Could not connect to GitHub in time."); } diff --git a/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/github/GitHubService.java b/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/github/GitHubService.java new file mode 100644 index 000000000..52fc2c2a4 --- /dev/null +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/github/GitHubService.java @@ -0,0 +1,165 @@ +package io.github.thebusybiscuit.slimefun4.core.services.github; + +import java.util.Date; +import java.util.HashSet; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; + +import com.google.gson.JsonArray; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; + +import io.github.thebusybiscuit.slimefun4.core.utils.NumberUtils; + +public class GitHubService { + + private final String repository; + private final Set connectors; + private final ConcurrentMap contributors; + + private boolean logging = false; + + private int issues = 0; + private int pullRequests = 0; + private int forks = 0; + private int stars = 0; + private int codeBytes = 0; + private Date lastUpdate = new Date(); + + public GitHubService(String repository) { + this.repository = repository; + + connectors = new HashSet<>(); + contributors = new ConcurrentHashMap<>(); + } + + public void connect(boolean logging) { + this.logging = logging; + + connectors.add(new ContributionsConnector(this, "code", repository, "&6Developer")); + connectors.add(new ContributionsConnector(this, "wiki", "TheBusyBiscuit/Slimefun4-wiki", "&3Wiki Editor")); + connectors.add(new ContributionsConnector(this, "resourcepack", "TheBusyBiscuit/Slimefun4-Resourcepack", "&cResourcepack Artist")); + + connectors.add(new GitHubConnector(this) { + + @Override + public void onSuccess(JsonElement element) { + JsonObject object = element.getAsJsonObject(); + forks = object.get("forks").getAsInt(); + stars = object.get("stargazers_count").getAsInt(); + lastUpdate = NumberUtils.parseGitHubDate(object.get("pushed_at").getAsString()); + } + + @Override + public String getRepository() { + return repository; + } + + @Override + public String getFileName() { + return "repo"; + } + + @Override + public String getURLSuffix() { + return ""; + } + }); + + connectors.add(new GitHubConnector(this) { + + @Override + public void onSuccess(JsonElement element) { + JsonArray array = element.getAsJsonArray(); + + int issueCount = 0; + int prCount = 0; + + for (JsonElement elem : array) { + JsonObject obj = elem.getAsJsonObject(); + if (obj.has("pull_request")) prCount++; + else issueCount++; + } + + issues = issueCount; + pullRequests = prCount; + } + + @Override + public String getRepository() { + return repository; + } + + @Override + public String getFileName() { + return "issues"; + } + + @Override + public String getURLSuffix() { + return "/issues"; + } + }); + + connectors.add(new GitHubConnector(this) { + + @Override + public void onSuccess(JsonElement element) { + JsonObject object = element.getAsJsonObject(); + codeBytes = object.get("Java").getAsInt(); + } + + @Override + public String getRepository() { + return repository; + } + + @Override + public String getFileName() { + return "languages"; + } + + @Override + public String getURLSuffix() { + return "/languages"; + } + }); + } + + public Set getConnectors() { + return connectors; + } + + public ConcurrentMap getContributors() { + return contributors; + } + + public int getForks() { + return forks; + } + + public int getStars() { + return stars; + } + + public int getIssues() { + return issues; + } + + public int getPullRequests() { + return pullRequests; + } + + public int getCodeSize() { + return codeBytes; + } + + public Date getLastUpdate() { + return lastUpdate; + } + + protected boolean isLoggingEnabled() { + return logging; + } +} diff --git a/src/main/java/me/mrCookieSlime/Slimefun/utils/ChatUtils.java b/src/main/java/io/github/thebusybiscuit/slimefun4/core/utils/ChatUtils.java similarity index 53% rename from src/main/java/me/mrCookieSlime/Slimefun/utils/ChatUtils.java rename to src/main/java/io/github/thebusybiscuit/slimefun4/core/utils/ChatUtils.java index c766f7530..298378735 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/utils/ChatUtils.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/core/utils/ChatUtils.java @@ -1,5 +1,6 @@ -package me.mrCookieSlime.Slimefun.utils; +package io.github.thebusybiscuit.slimefun4.core.utils; +import org.bukkit.ChatColor; import org.bukkit.entity.Player; import io.github.thebusybiscuit.cscorelib2.chat.ChatColors; @@ -10,9 +11,13 @@ public final class ChatUtils { public static void sendURL(Player p, String url) { p.sendMessage(""); - p.sendMessage(ChatColors.color("&7&oClick here:")); + p.sendMessage(ChatColors.color("&eClick here:")); p.sendMessage(ChatColors.color("&7&o" + url)); p.sendMessage(""); } + + public static String christmas(String text) { + return ChatColors.alternating(text, ChatColor.GREEN, ChatColor.RED); + } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/hooks/github/IntegerFormat.java b/src/main/java/io/github/thebusybiscuit/slimefun4/core/utils/NumberUtils.java similarity index 71% rename from src/main/java/me/mrCookieSlime/Slimefun/hooks/github/IntegerFormat.java rename to src/main/java/io/github/thebusybiscuit/slimefun4/core/utils/NumberUtils.java index 9fc269993..f17854eab 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/hooks/github/IntegerFormat.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/core/utils/NumberUtils.java @@ -1,4 +1,4 @@ -package me.mrCookieSlime.Slimefun.hooks.github; +package io.github.thebusybiscuit.slimefun4.core.utils; import java.text.NumberFormat; import java.text.ParseException; @@ -9,17 +9,18 @@ import java.util.logging.Level; import me.mrCookieSlime.Slimefun.api.Slimefun; -public final class IntegerFormat { +public final class NumberUtils { - private IntegerFormat() {} + private NumberUtils() {} public static String formatBigNumber(int i) { return NumberFormat.getNumberInstance(Locale.US).format(i); } - public static Date parseGitHubDate(String str) { + public static Date parseGitHubDate(String date) { try { - return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(str.replace('T', ' ').replace("Z", "")); + // We have to create this instance here because it is not thread-safe and should not exist on a static level. + return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(date.replace('T', ' ').replace("Z", "")); } catch (ParseException x) { Slimefun.getLogger().log(Level.SEVERE, "An Error occured while parsing a GitHub-Date for Slimefun " + Slimefun.getVersion(), x); return null; diff --git a/src/main/java/me/mrCookieSlime/Slimefun/GEO/GEOScanner.java b/src/main/java/me/mrCookieSlime/Slimefun/GEO/GEOScanner.java index 33bcbe303..ad32208cb 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/GEO/GEOScanner.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/GEO/GEOScanner.java @@ -7,9 +7,9 @@ import org.bukkit.Material; import org.bukkit.entity.Player; import org.bukkit.inventory.ItemStack; +import io.github.thebusybiscuit.cscorelib2.skull.SkullItem; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.ChestMenu; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.Item.CustomItem; -import me.mrCookieSlime.CSCoreLibPlugin.general.World.CustomSkull; import me.mrCookieSlime.Slimefun.SlimefunPlugin; import me.mrCookieSlime.Slimefun.api.Slimefun; @@ -33,7 +33,7 @@ public final class GEOScanner { } try { - menu.addItem(4, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvODQ0OWI5MzE4ZTMzMTU4ZTY0YTQ2YWIwZGUxMjFjM2Q0MDAwMGUzMzMyYzE1NzQ5MzJiM2M4NDlkOGZhMGRjMiJ9fX0="), "&eScanned Chunk", "", "&8\u21E8 &7World: " + chunk.getWorld().getName(), "&8\u21E8 &7X: " + chunk.getX() + " Z: " + chunk.getZ()), (pl, slot, stack, action) -> false); + menu.addItem(4, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvODQ0OWI5MzE4ZTMzMTU4ZTY0YTQ2YWIwZGUxMjFjM2Q0MDAwMGUzMzMyYzE1NzQ5MzJiM2M4NDlkOGZhMGRjMiJ9fX0="), "&eScanned Chunk", "", "&8\u21E8 &7World: " + chunk.getWorld().getName(), "&8\u21E8 &7X: " + chunk.getX() + " Z: " + chunk.getZ()), (pl, slot, stack, action) -> false); } catch (Exception e) { Slimefun.getLogger().log(Level.SEVERE, "Error while scanning a chunk for Slimefun " + Slimefun.getVersion(), e); } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/GEO/OreGenSystem.java b/src/main/java/me/mrCookieSlime/Slimefun/GEO/OreGenSystem.java index 89d785b74..7b8156677 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/GEO/OreGenSystem.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/GEO/OreGenSystem.java @@ -7,7 +7,7 @@ import java.util.logging.Level; import org.bukkit.Chunk; import org.bukkit.block.Biome; -import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config; +import io.github.thebusybiscuit.cscorelib2.config.Config; import me.mrCookieSlime.Slimefun.SlimefunPlugin; import me.mrCookieSlime.Slimefun.api.BlockStorage; import me.mrCookieSlime.Slimefun.api.Slimefun; @@ -23,15 +23,17 @@ public final class OreGenSystem { public static void registerResource(OreGenResource resource) { Config cfg = new Config("plugins/Slimefun/generators/" + resource.getName() + ".yml"); cfg.setDefaultValue("enabled", true); - for (Biome biome: Biome.values()) { + + for (Biome biome : Biome.values()) { cfg.setDefaultValue("spawn-rates." + biome.toString(), resource.getDefaultSupply(biome)); } + cfg.save(); if (cfg.getBoolean("enabled")) { Slimefun.getLogger().log(Level.INFO, "Registering Ore Gen: " + resource.getName()); SlimefunPlugin.getUtilities().resources.put(resource.getName(), resource); - SlimefunPlugin.getUtilities().resource_configs.put(resource.getName(), cfg); + SlimefunPlugin.getUtilities().resourceConfigs.put(resource.getName(), cfg); } } @@ -44,7 +46,7 @@ public final class OreGenSystem { return 0; } else { - int supply = SlimefunPlugin.getUtilities().resource_configs.get(resource.getName()).getInt("spawn-rates." + biome.toString()); + int supply = SlimefunPlugin.getUtilities().resourceConfigs.get(resource.getName()).getInt("spawn-rates." + biome.toString()); return supply > 0 ? (supply + ThreadLocalRandom.current().nextInt(3)): 0; } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/GPS/Elevator.java b/src/main/java/me/mrCookieSlime/Slimefun/GPS/Elevator.java index 73cde4281..d915c38df 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/GPS/Elevator.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/GPS/Elevator.java @@ -30,7 +30,7 @@ public final class Elevator { pl.closeInventory(); pl.sendMessage(""); pl.sendMessage(ChatColor.translateAlternateColorCodes('&', "&4&l>> &ePlease enter a Name for this Floor in your Chat!")); - pl.sendMessage(ChatColor.translateAlternateColorCodes('&', "&4&l>> &e(Chat Colors are supported!")); + pl.sendMessage(ChatColor.translateAlternateColorCodes('&', "&4&l>> &e(Chat Colors are supported!)")); pl.sendMessage(""); ChatInput.waitForPlayer(SlimefunPlugin.instance, pl, message -> { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/GPS/GPSNetwork.java b/src/main/java/me/mrCookieSlime/Slimefun/GPS/GPSNetwork.java index 485368c45..ee94563d6 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/GPS/GPSNetwork.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/GPS/GPSNetwork.java @@ -18,16 +18,16 @@ import org.bukkit.entity.Player; import org.bukkit.inventory.ItemStack; import io.github.thebusybiscuit.cscorelib2.chat.ChatInput; +import io.github.thebusybiscuit.cscorelib2.config.Config; import io.github.thebusybiscuit.cscorelib2.math.DoubleHandler; -import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config; +import io.github.thebusybiscuit.cscorelib2.skull.SkullItem; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.ChestMenu; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.Item.CustomItem; -import me.mrCookieSlime.CSCoreLibPlugin.general.World.CustomSkull; import me.mrCookieSlime.Slimefun.SlimefunPlugin; -import me.mrCookieSlime.Slimefun.api.BlockStorage; -import me.mrCookieSlime.Slimefun.api.Slimefun; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.gps.GPSTransmitter; +import me.mrCookieSlime.Slimefun.api.BlockStorage; +import me.mrCookieSlime.Slimefun.api.Slimefun; public class GPSNetwork { @@ -84,18 +84,18 @@ public class GPSNetwork { } try { - menu.addItem(2, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjBjOWMxYTAyMmY0MGI3M2YxNGI0Y2JhMzdjNzE4YzZhNTMzZjNhMjg2NGI2NTM2ZDVmNDU2OTM0Y2MxZiJ9fX0="), "&7Transmitter Overview &e(Selected)")); + menu.addItem(2, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjBjOWMxYTAyMmY0MGI3M2YxNGI0Y2JhMzdjNzE4YzZhNTMzZjNhMjg2NGI2NTM2ZDVmNDU2OTM0Y2MxZiJ9fX0="), "&7Transmitter Overview &e(Selected)")); menu.addMenuClickHandler(2, (pl, slot, item, action) -> false ); int complexity = getNetworkComplexity(p.getUniqueId()); - menu.addItem(4, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZGRjZmJhNThmYWYxZjY0ODQ3ODg0MTExODIyYjY0YWZhMjFkN2ZjNjJkNDQ4MWYxNGYzZjNiY2I2MzMwIn19fQ=="), "&7Network Info", "", "&8\u21E8 &7Status: " + (complexity > 0 ? "&2&lONLINE": "&4&lOFFLINE"), "&8\u21E8 &7Complexity: &r" + complexity)); + menu.addItem(4, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZGRjZmJhNThmYWYxZjY0ODQ3ODg0MTExODIyYjY0YWZhMjFkN2ZjNjJkNDQ4MWYxNGYzZjNiY2I2MzMwIn19fQ=="), "&7Network Info", "", "&8\u21E8 &7Status: " + (complexity > 0 ? "&2&lONLINE": "&4&lOFFLINE"), "&8\u21E8 &7Complexity: &r" + complexity)); menu.addMenuClickHandler(4, (pl, slot, item, action) -> false ); - menu.addItem(6, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYzljODg4MWU0MjkxNWE5ZDI5YmI2MWExNmZiMjZkMDU5OTEzMjA0ZDI2NWRmNWI0MzliM2Q3OTJhY2Q1NiJ9fX0="), "&7Waypoint Overview &r(Select)")); + menu.addItem(6, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYzljODg4MWU0MjkxNWE5ZDI5YmI2MWExNmZiMjZkMDU5OTEzMjA0ZDI2NWRmNWI0MzliM2Q3OTJhY2Q1NiJ9fX0="), "&7Waypoint Overview &r(Select)")); menu.addMenuClickHandler(6, (pl, slot, item, action) -> { openWaypointControlPanel(pl); return false; @@ -106,14 +106,14 @@ public class GPSNetwork { if (index >= inventory.length) break; SlimefunItem sfi = BlockStorage.check(l); - if (!(sfi instanceof GPSTransmitter)) continue; - - int slot = inventory[index]; - - menu.addItem(slot, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjBjOWMxYTAyMmY0MGI3M2YxNGI0Y2JhMzdjNzE4YzZhNTMzZjNhMjg2NGI2NTM2ZDVmNDU2OTM0Y2MxZiJ9fX0="), "&bGPS Transmitter", "&8\u21E8 &7World: &r" + l.getWorld().getName(), "&8\u21E8 &7X: &r" + l.getX(), "&8\u21E8 &7Y: &r" + l.getY(), "&8\u21E8 &7Z: &r" + l.getZ(), "", "&8\u21E8 &7Signal Strength: &r" + ((GPSTransmitter) sfi).getMultiplier(l.getBlockY()), "&8\u21E8 &7Ping: &r" + DoubleHandler.fixDouble(1000D / l.getY()) + "ms")); - menu.addMenuClickHandler(slot, (pl, slotn, item, action) -> false); - - index++; + if (sfi instanceof GPSTransmitter) { + int slot = inventory[index]; + + menu.addItem(slot, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjBjOWMxYTAyMmY0MGI3M2YxNGI0Y2JhMzdjNzE4YzZhNTMzZjNhMjg2NGI2NTM2ZDVmNDU2OTM0Y2MxZiJ9fX0="), "&bGPS Transmitter", "&8\u21E8 &7World: &r" + l.getWorld().getName(), "&8\u21E8 &7X: &r" + l.getX(), "&8\u21E8 &7Y: &r" + l.getY(), "&8\u21E8 &7Z: &r" + l.getZ(), "", "&8\u21E8 &7Signal Strength: &r" + ((GPSTransmitter) sfi).getMultiplier(l.getBlockY()), "&8\u21E8 &7Ping: &r" + DoubleHandler.fixDouble(1000D / l.getY()) + "ms")); + menu.addMenuClickHandler(slot, (pl, slotn, item, action) -> false); + + index++; + } } } catch(Exception x) { Slimefun.getLogger().log(Level.SEVERE, "An Error occured while creating the GPS Transmitter Panel for Slimefun " + Slimefun.getVersion(), x); @@ -126,16 +126,16 @@ public class GPSNetwork { Location l = entry.getValue(); if (entry.getKey().startsWith("&4Deathpoint")) { - return CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMWFlMzg1NWY5NTJjZDRhMDNjMTQ4YTk0NmUzZjgxMmE1OTU1YWQzNWNiY2I1MjYyN2VhNGFjZDQ3ZDMwODEifX19"); + return SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMWFlMzg1NWY5NTJjZDRhMDNjMTQ4YTk0NmUzZjgxMmE1OTU1YWQzNWNiY2I1MjYyN2VhNGFjZDQ3ZDMwODEifX19"); } else if (l.getWorld().getEnvironment() == Environment.NETHER) { - return CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZDgzNTcxZmY1ODlmMWE1OWJiMDJiODA4MDBmYzczNjExNmUyN2MzZGNmOWVmZWJlZGU4Y2YxZmRkZSJ9fX0="); + return SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZDgzNTcxZmY1ODlmMWE1OWJiMDJiODA4MDBmYzczNjExNmUyN2MzZGNmOWVmZWJlZGU4Y2YxZmRkZSJ9fX0="); } else if (l.getWorld().getEnvironment() == Environment.THE_END) { - return CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYzZjYWM1OWIyYWFlNDg5YWEwNjg3YjVkODAyYjI1NTVlYjE0YTQwYmQ2MmIyMWViMTE2ZmE1NjljZGI3NTYifX19"); + return SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYzZjYWM1OWIyYWFlNDg5YWEwNjg3YjVkODAyYjI1NTVlYjE0YTQwYmQ2MmIyMWViMTE2ZmE1NjljZGI3NTYifX19"); } else { - return CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYzljODg4MWU0MjkxNWE5ZDI5YmI2MWExNmZiMjZkMDU5OTEzMjA0ZDI2NWRmNWI0MzliM2Q3OTJhY2Q1NiJ9fX0="); + return SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYzljODg4MWU0MjkxNWE5ZDI5YmI2MWExNmZiMjZkMDU5OTEzMjA0ZDI2NWRmNWI0MzliM2Q3OTJhY2Q1NiJ9fX0="); } } @@ -147,17 +147,17 @@ public class GPSNetwork { } try { - menu.addItem(2, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjBjOWMxYTAyMmY0MGI3M2YxNGI0Y2JhMzdjNzE4YzZhNTMzZjNhMjg2NGI2NTM2ZDVmNDU2OTM0Y2MxZiJ9fX0="), "&7Transmitter Overview &r(Select)")); + menu.addItem(2, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjBjOWMxYTAyMmY0MGI3M2YxNGI0Y2JhMzdjNzE4YzZhNTMzZjNhMjg2NGI2NTM2ZDVmNDU2OTM0Y2MxZiJ9fX0="), "&7Transmitter Overview &r(Select)")); menu.addMenuClickHandler(2, (pl, slot, item, action) -> { openTransmitterControlPanel(pl); return false; }); int complexity = getNetworkComplexity(p.getUniqueId()); - menu.addItem(4, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZGRjZmJhNThmYWYxZjY0ODQ3ODg0MTExODIyYjY0YWZhMjFkN2ZjNjJkNDQ4MWYxNGYzZjNiY2I2MzMwIn19fQ=="), "&7Network Info", "", "&8\u21E8 &7Status: " + (complexity > 0 ? "&2&lONLINE": "&4&lOFFLINE"), "&8\u21E8 &7Complexity: &r" + complexity)); + menu.addItem(4, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZGRjZmJhNThmYWYxZjY0ODQ3ODg0MTExODIyYjY0YWZhMjFkN2ZjNjJkNDQ4MWYxNGYzZjNiY2I2MzMwIn19fQ=="), "&7Network Info", "", "&8\u21E8 &7Status: " + (complexity > 0 ? "&2&lONLINE": "&4&lOFFLINE"), "&8\u21E8 &7Complexity: &r" + complexity)); menu.addMenuClickHandler(4, (pl, slot, item, action) -> false); - menu.addItem(6, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYzljODg4MWU0MjkxNWE5ZDI5YmI2MWExNmZiMjZkMDU5OTEzMjA0ZDI2NWRmNWI0MzliM2Q3OTJhY2Q1NiJ9fX0="), "&7Waypoint Overview &e(Selected)")); + menu.addItem(6, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYzljODg4MWU0MjkxNWE5ZDI5YmI2MWExNmZiMjZkMDU5OTEzMjA0ZDI2NWRmNWI0MzliM2Q3OTJhY2Q1NiJ9fX0="), "&7Waypoint Overview &e(Selected)")); menu.addMenuClickHandler(6, (pl, slot, item, action) -> false); int index = 0; @@ -256,7 +256,7 @@ public class GPSNetwork { } try { - menu.addItem(4, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYzljODg4MWU0MjkxNWE5ZDI5YmI2MWExNmZiMjZkMDU5OTEzMjA0ZDI2NWRmNWI0MzliM2Q3OTJhY2Q1NiJ9fX0="), "&7Waypoint Overview &e(Select a Destination)")); + menu.addItem(4, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYzljODg4MWU0MjkxNWE5ZDI5YmI2MWExNmZiMjZkMDU5OTEzMjA0ZDI2NWRmNWI0MzliM2Q3OTJhY2Q1NiJ9fX0="), "&7Waypoint Overview &e(Select a Destination)")); menu.addMenuClickHandler(4, (pl, slot, item, action) -> false); final Location source = new Location(b.getWorld(), b.getX() + 0.5D, b.getY() + 2D, b.getZ() + 0.5D); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/GPS/TeleportationSequence.java b/src/main/java/me/mrCookieSlime/Slimefun/GPS/TeleportationSequence.java index 6be8211d7..5a2f8c770 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/GPS/TeleportationSequence.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/GPS/TeleportationSequence.java @@ -82,7 +82,7 @@ public final class TeleportationSequence { } destination.getWorld().spawnParticle(Particle.PORTAL,new Location(destination.getWorld(), destination.getX(), destination.getY() + 1, destination.getZ()),progress * 2, 0.2F, 0.8F, 0.2F ); - destination.getWorld().playSound(destination, Sound.ENTITY_BLAZE_DEATH, 1F, 1.4F); + destination.getWorld().playSound(destination, Sound.BLOCK_BEACON_ACTIVATE, 1F, 1F); SlimefunPlugin.getUtilities().teleporterUsers.remove(uuid); } else { @@ -93,7 +93,7 @@ public final class TeleportationSequence { subtitle.send(TitleType.SUBTITLE, p); source.getWorld().spawnParticle(Particle.PORTAL, source, progress * 2, 0.2F, 0.8F, 0.2F); - source.getWorld().playSound(source, Sound.UI_BUTTON_CLICK, 1F, 0.6F); + source.getWorld().playSound(source, Sound.BLOCK_BEACON_AMBIENT, 1F, 0.6F); Bukkit.getScheduler().scheduleSyncDelayedTask(SlimefunPlugin.instance, () -> updateProgress(uuid, speed, progress + speed, source, destination, resistance), 10L); } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Lists/Categories.java b/src/main/java/me/mrCookieSlime/Slimefun/Lists/Categories.java index f2caf432b..30ddc0e92 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Lists/Categories.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Lists/Categories.java @@ -1,14 +1,12 @@ package me.mrCookieSlime.Slimefun.Lists; -import org.bukkit.Color; import org.bukkit.Material; -import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.Item.CustomArmor; +import io.github.thebusybiscuit.slimefun4.core.utils.ChatUtils; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.Item.CustomItem; import me.mrCookieSlime.Slimefun.Objects.Category; import me.mrCookieSlime.Slimefun.Objects.LockedCategory; import me.mrCookieSlime.Slimefun.Objects.SeasonalCategory; -import me.mrCookieSlime.Slimefun.utils.Christmas; /** * Built-in categories. @@ -23,29 +21,29 @@ public final class Categories { private static final String LORE = "&a> Click to open"; - public static final Category WEAPONS = new Category(new CustomItem(Material.GOLDEN_SWORD, "&7Weapons", "", LORE), 1); + public static final Category WEAPONS = new Category(new CustomItem(SlimefunItems.BLADE_OF_VAMPIRES, "&7Weapons", "", LORE), 1); + public static final Category TOOLS = new Category(new CustomItem(SlimefunItems.AUTO_SMELT_PICKAXE, "&7Tools", "", LORE), 1); public static final Category PORTABLE = new Category(new CustomItem(SlimefunItems.BACKPACK_MEDIUM, "&7Items", "", LORE), 1); - public static final Category FOOD = new Category(new CustomItem(Material.APPLE, "&7Food", "", LORE), 2); + public static final Category FOOD = new Category(new CustomItem(SlimefunItems.FORTUNE_COOKIE, "&7Food", "", LORE), 2); public static final Category MACHINES_1 = new Category(new CustomItem(Material.SMITHING_TABLE, "&7Basic Machines", "", LORE), 1); public static final LockedCategory ELECTRICITY = new LockedCategory(new CustomItem(SlimefunItems.NUCLEAR_REACTOR, "&bEnergy and Electricity", "", LORE), 4, MACHINES_1); public static final LockedCategory GPS = new LockedCategory(new CustomItem(SlimefunItems.GPS_TRANSMITTER, "&bGPS-based Machines", "", LORE), 4, MACHINES_1); - public static final Category ARMOR = new Category(new CustomItem(Material.IRON_CHESTPLATE, "&7Armor", "", LORE), 2); + public static final Category ARMOR = new Category(new CustomItem(SlimefunItems.DAMASCUS_STEEL_CHESTPLATE, "&7Armor", "", LORE), 2); public static final Category LUMPS_AND_MAGIC = new Category(new CustomItem(SlimefunItems.RUNE_ENDER, "&7Magical Items", "", LORE), 2); - public static final Category MAGIC = new Category(new CustomItem(Material.ELYTRA, "&7Magical Gadgets", "", LORE), 3); + public static final Category MAGIC = new Category(new CustomItem(SlimefunItems.INFUSED_ELYTRA, "&7Magical Gadgets", "", LORE), 3); public static final Category MISC = new Category(new CustomItem(SlimefunItems.CAN, "&7Miscellaneous", "", LORE), 2); - public static final Category TECH = new Category(new CustomArmor(new CustomItem(Material.LEATHER_CHESTPLATE, "&7Technical Gadgets", "", LORE), Color.SILVER), 3); + public static final Category TECH = new Category(new CustomItem(SlimefunItems.STEEL_JETPACK, "&7Technical Gadgets", "", LORE), 3); public static final Category RESOURCES = new Category(new CustomItem(SlimefunItems.SYNTHETIC_SAPPHIRE, "&7Resources", "", LORE), 1); public static final Category CARGO = new LockedCategory(new CustomItem(SlimefunItems.CARGO_MANAGER, "&cCargo Management", "", LORE), 4, MACHINES_1); public static final Category TECH_MISC = new Category(new CustomItem(SlimefunItems.HEATING_COIL, "&7Technical Components", "", LORE), 2); public static final Category MAGIC_ARMOR = new Category(new CustomItem(SlimefunItems.ENDER_HELMET, "&7Magical Armor", "", LORE), 2); - public static final Category TALISMANS_1 = new Category(new CustomItem(Material.EMERALD, "&7Talismans - &aTier I", "", LORE), 2); - public static final LockedCategory TALISMANS_2 = new LockedCategory(new CustomItem(Material.EMERALD, "&7Talismans - &aTier II", "", LORE), 3, TALISMANS_1); - public static final Category TOOLS = new Category(new CustomItem(Material.GOLDEN_PICKAXE, "&7Tools", "", LORE), 1); + public static final Category TALISMANS_1 = new Category(new CustomItem(SlimefunItems.TALISMAN, "&7Talismans - &aTier I", "", LORE), 2); + public static final LockedCategory TALISMANS_2 = new LockedCategory(new CustomItem(SlimefunItems.ENDER_TALISMAN, "&7Talismans - &aTier II", "", LORE), 3, TALISMANS_1); // Seasonal Categories - public static final SeasonalCategory CHRISTMAS = new SeasonalCategory(12, 1, new CustomItem(Material.NETHER_STAR, Christmas.color("Christmas"), "", "&c> Click to help &aSanta")); - public static final SeasonalCategory VALENTINES_DAY = new SeasonalCategory(2, 2, new CustomItem(Material.POPPY, "&dValentine's Day", "", "&d> Click to celebrate Love")); - public static final SeasonalCategory EASTER = new SeasonalCategory(4, 2, new CustomItem(Material.EGG, "&6Easter", "", "&a> Click to paint some Eggs")); + public static final SeasonalCategory CHRISTMAS = new SeasonalCategory(12, 1, new CustomItem(Material.NETHER_STAR, ChatUtils.christmas("Christmas") + " &7(December)", "", "&c> Click to help &aSanta")); + public static final SeasonalCategory VALENTINES_DAY = new SeasonalCategory(2, 2, new CustomItem(Material.POPPY, "&dValentine's Day" + " &7(February)", "", "&d> Click to celebrate Love")); + public static final SeasonalCategory EASTER = new SeasonalCategory(4, 2, new CustomItem(Material.EGG, "&6Easter" + " &7(April)", "", "&a> Click to paint some Eggs")); public static final SeasonalCategory BIRTHDAY = new SeasonalCategory(10, 1, new CustomItem(Material.FIREWORK_ROCKET, "&a&lTheBusyBiscuit's Birthday &7(26th October)", "", "&a> Click to celebrate with me")); } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Lists/RecipeType.java b/src/main/java/me/mrCookieSlime/Slimefun/Lists/RecipeType.java index 20e2cbeff..33dc5f96a 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Lists/RecipeType.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Lists/RecipeType.java @@ -95,7 +95,7 @@ public class RecipeType { public static ItemStack getRecipeOutput(SlimefunItem machine, ItemStack input) { List recipes = (machine instanceof SlimefunMachine ? ((SlimefunMachine) machine).getRecipes(): ((SlimefunGadget) machine).getRecipes()); - return recipes.get(((getRecipeInputs(machine).indexOf(input) * 2) + 1))[0]; + return recipes.get(((getRecipeInputs(machine).indexOf(input) * 2) + 1))[0].clone(); } public static ItemStack getRecipeOutputList(SlimefunItem machine, ItemStack[] input) { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Lists/SlimefunItems.java b/src/main/java/me/mrCookieSlime/Slimefun/Lists/SlimefunItems.java index d6f614db2..912ffbfb8 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Lists/SlimefunItems.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Lists/SlimefunItems.java @@ -4,7 +4,6 @@ import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; -import java.util.logging.Level; import org.bukkit.ChatColor; import org.bukkit.Color; @@ -18,11 +17,10 @@ import org.bukkit.inventory.meta.ItemMeta; import org.bukkit.potion.PotionEffect; import org.bukkit.potion.PotionEffectType; +import io.github.thebusybiscuit.cscorelib2.skull.SkullItem; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.Item.CustomItem; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.Item.CustomPotion; -import me.mrCookieSlime.CSCoreLibPlugin.general.World.CustomSkull; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.items.StormStaff; -import me.mrCookieSlime.Slimefun.api.Slimefun; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; import me.mrCookieSlime.Slimefun.utils.Christmas; import me.mrCookieSlime.Slimefun.utils.MachineTier; @@ -157,7 +155,7 @@ public final class SlimefunItems { public static final ItemStack CHRISTMAS_APPLE_PIE = new CustomItem(Material.PUMPKIN_PIE, "&rApple Pie"); public static final ItemStack CHRISTMAS_HOT_CHOCOLATE = new CustomPotion("&6Hot Chocolate", Color.MAROON, new PotionEffect(PotionEffectType.SATURATION, 14, 0), "", "&7&oRestores &b&o" + "7.0" + " &7&oHunger"); public static final ItemStack CHRISTMAS_CAKE = new CustomItem(Material.PUMPKIN_PIE, Christmas.color("Christmas Cake")); - public static final ItemStack CHRISTMAS_CARAMEL = new CustomItem(Material.BRICKS, "&6Caramel"); + public static final ItemStack CHRISTMAS_CARAMEL = new CustomItem(Material.BRICK, "&6Caramel"); public static final ItemStack CHRISTMAS_CARAMEL_APPLE = new CustomItem(Material.APPLE, "&6Caramel Apple"); public static final ItemStack CHRISTMAS_CHOCOLATE_APPLE = new CustomItem(Material.APPLE, "&6Chocolate Apple"); public static final ItemStack CHRISTMAS_PRESENT = new CustomItem(Material.CHEST, Christmas.color("Christmas Present"), "&7From: &emrCookieSlime", "&7To: &eYou", "", "&eRight Click&7 to open"); @@ -462,6 +460,8 @@ public final class SlimefunItems { /* Talisman */ public static final ItemStack TALISMAN = new SlimefunItemStack("COMMON_TALISMAN", Material.EMERALD, "&6Common Talisman"); + public static final ItemStack ENDER_TALISMAN = new SlimefunItemStack("ENDER_TALISMAN", Material.EMERALD, "&5Ender Talisman"); + public static final ItemStack TALISMAN_ANVIL = new SlimefunItemStack("ANVIL_TALISMAN", Material.EMERALD, "&aTalisman of the Anvil", "", "&rEach Talisman can prevent", "&r1 Tool from breaking, but will then", "&rbe consumed", "", "&4&lWARNING:", "&4This Talisman does not work on", "&4Tools which are too powerful", "&4due to their complexity"); public static final ItemStack TALISMAN_MINER = new SlimefunItemStack("MINER_TALISMAN", Material.EMERALD, "&aTalisman of the Miner", "", "&rWhile you have this Talisman", "&rin your Inventory it has", "&ra 20% chance of doubling", "&rall Ores you mine"); public static final ItemStack TALISMAN_HUNTER = new SlimefunItemStack("HUNTER_TALISMAN", Material.EMERALD, "&aTalisman of the Hunter", "", "&rWhile you have this Talisman", "&rin your Inventory it has", "&ra 20% chance of doubling", "&rall Drops from Mobs you kill"); @@ -543,6 +543,7 @@ public final class SlimefunItems { public static final ItemStack SOULBOUND_AXE = new SlimefunItemStack("SOULBOUND_AXE", Material.DIAMOND_AXE, "&cSoulbound Axe"); public static final ItemStack SOULBOUND_SHOVEL = new SlimefunItemStack("SOULBOUND_SHOVEL", Material.DIAMOND_SHOVEL, "&cSoulbound Shovel"); public static final ItemStack SOULBOUND_HOE = new SlimefunItemStack("SOULBOUND_HOE", Material.DIAMOND_HOE, "&cSoulbound Hoe"); + public static final ItemStack SOULBOUND_TRIDENT = new SlimefunItemStack("SOULBOUND_TRIDENT", Material.TRIDENT, "&cSoulbound Trident"); public static final ItemStack SOULBOUND_HELMET = new SlimefunItemStack("SOULBOUND_HELMET", Material.DIAMOND_HELMET, "&cSoulbound Helmet"); public static final ItemStack SOULBOUND_CHESTPLATE = new SlimefunItemStack("SOULBOUND_CHESTPLATE", Material.DIAMOND_CHESTPLATE, "&cSoulbound Chestplate"); @@ -726,6 +727,9 @@ public final class SlimefunItems { public static final ItemStack ELECTRIC_SMELTERY = new SlimefunItemStack("ELECTRIC_SMELTERY", Material.FURNACE, "&cElectric Smeltery", "", "&4Alloys-Only, doesn't smelt Dust into Ingots", "", MachineTier.END_GAME.and(MachineType.MACHINE), "&8\u21E8 &7Speed: 1x", "&8\u21E8 &e\u26A1 &720 J/s"); public static final ItemStack ELECTRIC_SMELTERY_2 = new SlimefunItemStack("ELECTRIC_SMELTERY_2", Material.FURNACE, "&cElectric Smeltery &7- &eII", "", "&4Alloys-Only, doesn't smelt Dust into Ingots", "", MachineTier.END_GAME.and(MachineType.MACHINE), "&8\u21E8 &7Speed: 3x", "&8\u21E8 &e\u26A1 &740 J/s"); + public static final ItemStack ELECTRIC_PRESS = new SlimefunItemStack("ELECTRIC_PRESS", "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvOGQ1Y2Y5MmJjNzllYzE5ZjQxMDY0NDFhZmZmZjE0MDZhMTM2NzAxMGRjYWZiMTk3ZGQ5NGNmY2ExYTZkZTBmYyJ9fX0=", "&eElectric Press", "", MachineTier.MEDIUM.and(MachineType.MACHINE), "&8\u21E8 &7Speed: 1x", "&8\u21E8 &e\u26A1 &716 J/s"); + public static final ItemStack ELECTRIC_PRESS_2 = new SlimefunItemStack("ELECTRIC_PRESS_2", "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvOGQ1Y2Y5MmJjNzllYzE5ZjQxMDY0NDFhZmZmZjE0MDZhMTM2NzAxMGRjYWZiMTk3ZGQ5NGNmY2ExYTZkZTBmYyJ9fX0=", "&eElectric Press &7- &eII", "", MachineTier.END_GAME.and(MachineType.MACHINE), "&8\u21E8 &7Speed: 3x", "&8\u21E8 &e\u26A1 &740 J/s"); + public static final ItemStack ELECTRIFIED_CRUCIBLE = new SlimefunItemStack("ELECTRIFIED_CRUCIBLE", Material.RED_TERRACOTTA, "&cElectrified Crucible", "", MachineTier.END_GAME.and(MachineType.MACHINE), "&8\u21E8 &7Speed: 1x", "&8\u21E8 &e\u26A1 &748 J/s"); public static final ItemStack ELECTRIFIED_CRUCIBLE_2 = new SlimefunItemStack("ELECTRIFIED_CRUCIBLE_2", Material.RED_TERRACOTTA, "&cElectrified Crucible &7- &eII", "", MachineTier.END_GAME.and(MachineType.MACHINE), "&8\u21E8 &7Speed: 2x", "&8\u21E8 &e\u26A1 &780 J/s"); public static final ItemStack ELECTRIFIED_CRUCIBLE_3 = new SlimefunItemStack("ELECTRIFIED_CRUCIBLE_3", Material.RED_TERRACOTTA, "&cElectrified Crucible &7- &eIII", "", MachineTier.END_GAME.and(MachineType.MACHINE), "&8\u21E8 &7Speed: 4x", "&8\u21E8 &e\u26A1 &7120 J/s"); @@ -757,7 +761,7 @@ public final class SlimefunItems { public static final ItemStack AUTO_BREEDER = new SlimefunItemStack("AUTO_BREEDER", Material.HAY_BLOCK, "&eAuto-Breeder", "", "&rRuns on &aOrganic Food", "", MachineTier.END_GAME.and(MachineType.MACHINE), "&8\u21E8 &e\u26A1 &71024 J Buffer", "&8\u21E8 &e\u26A1 &760 J/Animal"); - public static final ItemStack ORGANIC_FOOD = new CustomItem(getSkull("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjQzOWUzZjVhY2JlZTliZTRjNDI1OTI4OWQ2ZDlmMzVjNjM1ZmZhNjYxMTE0Njg3YjNlYTZkZGE4Yzc5In19fQ=="), "&aOrganic Food", "&7Content: &9X"); + public static final ItemStack ORGANIC_FOOD = new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjQzOWUzZjVhY2JlZTliZTRjNDI1OTI4OWQ2ZDlmMzVjNjM1ZmZhNjYxMTE0Njg3YjNlYTZkZGE4Yzc5In19fQ=="), "&aOrganic Food", "&7Content: &9X"); public static final ItemStack WHEAT_ORGANIC_FOOD = new SlimefunItemStack("ORGANIC_FOOD_WHEAT", "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjQzOWUzZjVhY2JlZTliZTRjNDI1OTI4OWQ2ZDlmMzVjNjM1ZmZhNjYxMTE0Njg3YjNlYTZkZGE4Yzc5In19fQ==", "&aOrganic Food", "&7Content: &9Wheat"); public static final ItemStack CARROT_ORGANIC_FOOD = new SlimefunItemStack("ORGANIC_FOOD_CARROT", "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjQzOWUzZjVhY2JlZTliZTRjNDI1OTI4OWQ2ZDlmMzVjNjM1ZmZhNjYxMTE0Njg3YjNlYTZkZGE4Yzc5In19fQ==", "&aOrganic Food", "&7Content: &9Carrots"); public static final ItemStack POTATO_ORGANIC_FOOD = new SlimefunItemStack("ORGANIC_FOOD_POTATO", "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjQzOWUzZjVhY2JlZTliZTRjNDI1OTI4OWQ2ZDlmMzVjNjM1ZmZhNjYxMTE0Njg3YjNlYTZkZGE4Yzc5In19fQ==", "&aOrganic Food", "&7Content: &9Potatoes"); @@ -767,7 +771,7 @@ public final class SlimefunItems { public static final ItemStack APPLE_ORGANIC_FOOD = new SlimefunItemStack("ORGANIC_FOOD_APPLE", "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjQzOWUzZjVhY2JlZTliZTRjNDI1OTI4OWQ2ZDlmMzVjNjM1ZmZhNjYxMTE0Njg3YjNlYTZkZGE4Yzc5In19fQ==", "&aOrganic Food", "&7Content: &9Apple"); public static final ItemStack SWEET_BERRIES_ORGANIC_FOOD = new SlimefunItemStack("ORGANIC_FOOD_SWEET_BERRIES", "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjQzOWUzZjVhY2JlZTliZTRjNDI1OTI4OWQ2ZDlmMzVjNjM1ZmZhNjYxMTE0Njg3YjNlYTZkZGE4Yzc5In19fQ==", "&aOrganic Food", "&7Content: &9Sweet Berries"); - public static final ItemStack FERTILIZER = new CustomItem(getSkull("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjQzOWUzZjVhY2JlZTliZTRjNDI1OTI4OWQ2ZDlmMzVjNjM1ZmZhNjYxMTE0Njg3YjNlYTZkZGE4Yzc5In19fQ=="), "&aOrganic Fertilizer", "&7Content: &9X"); + public static final ItemStack FERTILIZER = new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjQzOWUzZjVhY2JlZTliZTRjNDI1OTI4OWQ2ZDlmMzVjNjM1ZmZhNjYxMTE0Njg3YjNlYTZkZGE4Yzc5In19fQ=="), "&aOrganic Fertilizer", "&7Content: &9X"); public static final ItemStack WHEAT_FERTILIZER = new SlimefunItemStack("FERTILIZER_WHEAT", "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjQzOWUzZjVhY2JlZTliZTRjNDI1OTI4OWQ2ZDlmMzVjNjM1ZmZhNjYxMTE0Njg3YjNlYTZkZGE4Yzc5In19fQ==", "&aOrganic Fertilizer", "&7Content: &9Wheat"); public static final ItemStack CARROT_FERTILIZER = new SlimefunItemStack("FERTILIZER_CARROT", "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjQzOWUzZjVhY2JlZTliZTRjNDI1OTI4OWQ2ZDlmMzVjNjM1ZmZhNjYxMTE0Njg3YjNlYTZkZGE4Yzc5In19fQ==", "&aOrganic Fertilizer", "&7Content: &9Carrots"); public static final ItemStack POTATO_FERTILIZER = new SlimefunItemStack("FERTILIZER_POTATO", "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYjQzOWUzZjVhY2JlZTliZTRjNDI1OTI4OWQ2ZDlmMzVjNjM1ZmZhNjYxMTE0Njg3YjNlYTZkZGE4Yzc5In19fQ==", "&aOrganic Fertilizer", "&7Content: &9Potatoes"); @@ -830,19 +834,8 @@ public final class SlimefunItems { // ChestTerminal Addon - public static final ItemStack CHEST_TERMINAL = new CustomItem(getSkull("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvN2E0NGZmM2E1ZjQ5YzY5Y2FiNjc2YmFkOGQ5OGEwNjNmYTc4Y2ZhNjE5MTZmZGVmM2UyNjc1NTdmZWMxODI4MyJ9fX0="), "&3CT Access Terminal", "&7If this Block is connected to a", "&7Cargo Network, it will allow you to remotely", "&7interact with any Items supplied by", "&7Nodes tuned into the ChestTerminal Channel"); - public static final ItemStack CT_IMPORT_BUS = new CustomItem(getSkull("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTEzZGIyZTdlNzJlYTQ0MzJlZWZiZDZlNThhODVlYWEyNDIzZjgzZTY0MmNhNDFhYmM2YTkzMTc3NTdiODg5In19fQ=="), "&3CT Import Bus", "&7If this Block is connected to a", "&7Cargo Network, it will pull any Items from", "&7the Inventory it is attached to and place it", "&7into the CT Network Channel"); - public static final ItemStack CT_EXPORT_BUS = new CustomItem(getSkull("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTEzZGIyZTdlNzJlYTQ0MzJlZWZiZDZlNThhODVlYWEyNDIzZjgzZTY0MmNhNDFhYmM2YTkzMTc3NTdiODg5In19fQ=="), "&3CT Export Bus", "&7If this Block is connected to a", "&7Cargo Network, it will pull any Items from", "&7the CT Network Channel and place these", "&7into the Inventory it is attached to"); - - private static ItemStack getSkull(String texture) { - try { - return CustomSkull.getItem(texture); - } - catch(Exception x) { - Slimefun.getLogger().log(Level.SEVERE, "An Error occured while initializing the Items for Slimefun " + Slimefun.getVersion(), x); - - return new ItemStack(Material.PLAYER_HEAD); - } - } + public static final ItemStack CHEST_TERMINAL = new SlimefunItemStack("CHEST_TERMINAL", "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvN2E0NGZmM2E1ZjQ5YzY5Y2FiNjc2YmFkOGQ5OGEwNjNmYTc4Y2ZhNjE5MTZmZGVmM2UyNjc1NTdmZWMxODI4MyJ9fX0=", "&3CT Access Terminal", "&7If this Block is connected to a", "&7Cargo Network, it will allow you to remotely", "&7interact with any Items supplied by", "&7Nodes tuned into the ChestTerminal Channel"); + public static final ItemStack CT_IMPORT_BUS = new SlimefunItemStack("CT_IMPORT_BUS", "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTEzZGIyZTdlNzJlYTQ0MzJlZWZiZDZlNThhODVlYWEyNDIzZjgzZTY0MmNhNDFhYmM2YTkzMTc3NTdiODg5In19fQ==", "&3CT Import Bus", "&7If this Block is connected to a", "&7Cargo Network, it will pull any Items from", "&7the Inventory it is attached to and place it", "&7into the CT Network Channel"); + public static final ItemStack CT_EXPORT_BUS = new SlimefunItemStack("CT_EXPORT_BUS", "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTEzZGIyZTdlNzJlYTQ0MzJlZWZiZDZlNThhODVlYWEyNDIzZjgzZTY0MmNhNDFhYmM2YTkzMTc3NTdiODg5In19fQ==", "&3CT Export Bus", "&7If this Block is connected to a", "&7Cargo Network, it will pull any Items from", "&7the CT Network Channel and place these", "&7into the Inventory it is attached to"); } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/LockedCategory.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/LockedCategory.java index 53c72e2ba..505618460 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/LockedCategory.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/LockedCategory.java @@ -111,7 +111,6 @@ public class LockedCategory extends Category { * * @since 4.0 */ - @SuppressWarnings("deprecation") public boolean hasUnlocked(Player p) { return hasUnlocked(p, PlayerProfile.get(p)); } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/Research.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/Research.java index 02219fd94..8f80ff3f5 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/Research.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/Research.java @@ -13,9 +13,9 @@ import org.bukkit.Sound; import org.bukkit.command.CommandSender; import org.bukkit.entity.Player; +import io.github.thebusybiscuit.slimefun4.api.events.ResearchUnlockEvent; import me.mrCookieSlime.CSCoreLibPlugin.general.Particles.FireworkShow; import me.mrCookieSlime.Slimefun.SlimefunPlugin; -import me.mrCookieSlime.Slimefun.Events.ResearchUnlockEvent; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem; import me.mrCookieSlime.Slimefun.Setup.ResearchSetup; import me.mrCookieSlime.Slimefun.api.PlayerProfile; @@ -228,16 +228,15 @@ public class Research { * @since 4.0 */ public void unlock(final Player p, boolean instant) { - Slimefun.runSync(() -> { - p.playSound(p.getLocation(), Sound.ENTITY_BAT_TAKEOFF, 0.7F, 1F); - SlimefunPlugin.getLocal().sendMessage(p, "messages.research.progress", true, msg -> msg.replace("%research%", getName()).replace("%progress%", "0%")); - }, 10L); + if (!instant) { + Slimefun.runSync(() -> { + p.playSound(p.getLocation(), Sound.ENTITY_BAT_TAKEOFF, 0.7F, 1F); + SlimefunPlugin.getLocal().sendMessage(p, "messages.research.progress", true, msg -> msg.replace("%research%", getName()).replace("%progress%", "0%")); + }, 10L); + } PlayerProfile.get(p, profile -> { if (!profile.hasUnlocked(this)) { - ResearchUnlockEvent event = new ResearchUnlockEvent(p, this); - Bukkit.getPluginManager().callEvent(event); - Runnable runnable = () -> { profile.setResearched(this, true); SlimefunPlugin.getLocal().sendMessage(p, "messages.unlocked", true, msg -> msg.replace("%research%", getName())); @@ -247,29 +246,34 @@ public class Research { } }; - if (!event.isCancelled()) { - if (instant) { - runnable.run(); - } - else if (!SlimefunPlugin.getUtilities().researching.contains(p.getUniqueId())){ - SlimefunPlugin.getUtilities().researching.add(p.getUniqueId()); - SlimefunPlugin.getLocal().sendMessage(p, "messages.research.start", true, msg -> msg.replace("%research%", getName())); - - for (int i = 1; i < research_progress.length + 1; i++) { - int j = i; + Slimefun.runSync(() -> { + ResearchUnlockEvent event = new ResearchUnlockEvent(p, this); + Bukkit.getPluginManager().callEvent(event); + + if (!event.isCancelled()) { + if (instant) { + runnable.run(); + } + else if (!SlimefunPlugin.getUtilities().researching.contains(p.getUniqueId())){ + SlimefunPlugin.getUtilities().researching.add(p.getUniqueId()); + SlimefunPlugin.getLocal().sendMessage(p, "messages.research.start", true, msg -> msg.replace("%research%", getName())); + + for (int i = 1; i < research_progress.length + 1; i++) { + int j = i; + + Slimefun.runSync(() -> { + p.playSound(p.getLocation(), Sound.ENTITY_BAT_TAKEOFF, 0.7F, 1F); + SlimefunPlugin.getLocal().sendMessage(p, "messages.research.progress", true, msg -> msg.replace("%research%", getName()).replace("%progress%", research_progress[j - 1] + "%")); + }, i * 20L); + } Slimefun.runSync(() -> { - p.playSound(p.getLocation(), Sound.ENTITY_BAT_TAKEOFF, 0.7F, 1F); - SlimefunPlugin.getLocal().sendMessage(p, "messages.research.progress", true, msg -> msg.replace("%research%", getName()).replace("%progress%", research_progress[j - 1] + "%")); - }, i * 20L); + runnable.run(); + SlimefunPlugin.getUtilities().researching.remove(p.getUniqueId()); + }, (research_progress.length + 1) * 20L); } - - Slimefun.runSync(() -> { - runnable.run(); - SlimefunPlugin.getUtilities().researching.remove(p.getUniqueId()); - }, (research_progress.length + 1) * 20L); } - } + }); } }); } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/HandledBlock.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/HandledBlock.java index b910c7c79..4ac053824 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/HandledBlock.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/HandledBlock.java @@ -2,6 +2,7 @@ package me.mrCookieSlime.Slimefun.Objects.SlimefunItem; import org.bukkit.inventory.ItemStack; +import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; import me.mrCookieSlime.Slimefun.Lists.RecipeType; import me.mrCookieSlime.Slimefun.Objects.Category; @@ -11,4 +12,8 @@ public class HandledBlock extends SlimefunItem { super(category, item, id, recipeType, recipe); } + public HandledBlock(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) { + super(category, item, recipeType, recipe); + } + } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/MultiTool.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/MultiTool.java index 2356aaae2..2f15feb3d 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/MultiTool.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/MultiTool.java @@ -12,22 +12,49 @@ import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class MultiTool extends DamagableChargableItem { + private static final String PREFIX = "mode."; + private List modes; - public MultiTool(ItemStack item, String id, RecipeType recipeType, ItemStack[] recipe, String[] keys, Object[] values) { - super(Categories.TECH, item, id, recipeType, recipe, "Multi Tool", keys, values); + public MultiTool(SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe, String... items) { + super(Categories.TECH, item, recipeType, recipe, "Multi Tool", getKeys(items), getValues(items)); } - public MultiTool(SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe, String[] keys, Object[] values) { - super(Categories.TECH, item, recipeType, recipe, "Multi Tool", keys, values); + private static String[] getKeys(String... items) { + String[] keys = new String[items.length * 2]; + + for (int i = 0; i < items.length; i++) { + keys[i * 2] = PREFIX + i + ".enabled"; + keys[i * 2 + 1] = PREFIX + i + ".item"; + } + + return keys; } + private static Object[] getValues(String... items) { + Object[] values = new Object[items.length * 2]; + + for (int i = 0; i < items.length; i++) { + values[i * 2] = true; + values[i * 2 + 1] = items[i]; + } + + return values; + } + @Override public void postRegister() { List list = new ArrayList<>(); - for (int i = 0; i < 50; i++) { - if (Slimefun.getItemValue(this.getID(), "mode." + i + ".enabled") != null && (boolean) Slimefun.getItemValue(this.getID(), "mode." + i + ".enabled")) list.add(i); + + int i = 0; + + while (Slimefun.getItemValue(this.getID(), PREFIX + i + ".enabled") != null) { + if ((boolean) Slimefun.getItemValue(this.getID(), PREFIX + i + ".enabled")) { + list.add(i); + } + i++; } + this.modes = list; } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SlimefunItem.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SlimefunItem.java index f00c1cdbb..85baeda9c 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SlimefunItem.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SlimefunItem.java @@ -2,6 +2,7 @@ package me.mrCookieSlime.Slimefun.Objects.SlimefunItem; import java.util.ArrayList; import java.util.Arrays; +import java.util.Collection; import java.util.HashSet; import java.util.List; import java.util.Optional; @@ -13,9 +14,11 @@ import org.bukkit.Bukkit; import org.bukkit.ChatColor; import org.bukkit.World; import org.bukkit.entity.EntityType; +import org.bukkit.entity.Player; import org.bukkit.inventory.ItemStack; import io.github.thebusybiscuit.cscorelib2.inventory.ItemUtils; +import io.github.thebusybiscuit.slimefun4.api.items.Placeable; import me.mrCookieSlime.Slimefun.SlimefunPlugin; import me.mrCookieSlime.Slimefun.Lists.RecipeType; import me.mrCookieSlime.Slimefun.Lists.SlimefunItems; @@ -33,7 +36,7 @@ import me.mrCookieSlime.Slimefun.api.energy.EnergyNet; import me.mrCookieSlime.Slimefun.api.energy.EnergyNetComponent; import me.mrCookieSlime.Slimefun.api.energy.EnergyTicker; -public class SlimefunItem { +public class SlimefunItem implements Placeable { private String id; private ItemState state; @@ -139,8 +142,7 @@ public class SlimefunItem { * @since 4.1.11 */ public String getPermission() { return permission; } - public List getNoPermissionTooltip() { return noPermissionTooltip; } - public boolean isTicking() { return ticking; } + public List getNoPermissionTooltip() { return noPermissionTooltip; } /** * @since 4.1.11, rename of {@link #getTicker()}. @@ -312,8 +314,8 @@ public class SlimefunItem { return sfi; } } - if (SlimefunManager.isItemSimiliar(item, SlimefunItems.BROKEN_SPAWNER, false)) return getByID("BROKEN_SPAWNER"); - if (SlimefunManager.isItemSimiliar(item, SlimefunItems.REPAIRED_SPAWNER, false)) return getByID("REINFORCED_SPAWNER"); + if (SlimefunManager.isItemSimilar(item, SlimefunItems.BROKEN_SPAWNER, false)) return getByID("BROKEN_SPAWNER"); + if (SlimefunManager.isItemSimilar(item, SlimefunItems.REPAIRED_SPAWNER, false)) return getByID("REINFORCED_SPAWNER"); return null; } @@ -327,11 +329,11 @@ public class SlimefunItem { } } - if (this instanceof ChargableItem && SlimefunManager.isItemSimiliar(item, this.item, false)) return true; - else if (this instanceof DamagableChargableItem && SlimefunManager.isItemSimiliar(item, this.item, false)) return true; - else if (this instanceof ChargedItem && SlimefunManager.isItemSimiliar(item, this.item, false)) return true; - else if (this instanceof SlimefunBackpack && SlimefunManager.isItemSimiliar(item, this.item, false)) return true; - else return SlimefunManager.isItemSimiliar(item, this.item, true); + if (this instanceof ChargableItem && SlimefunManager.isItemSimilar(item, this.item, false)) return true; + else if (this instanceof DamagableChargableItem && SlimefunManager.isItemSimilar(item, this.item, false)) return true; + else if (this instanceof ChargedItem && SlimefunManager.isItemSimilar(item, this.item, false)) return true; + else if (this instanceof SlimefunBackpack && SlimefunManager.isItemSimilar(item, this.item, false)) return true; + else return SlimefunManager.isItemSimilar(item, this.item, true); } public void load() { @@ -481,7 +483,7 @@ public class SlimefunItem { ItemStack[] recipe = sfi.getRecipe(); for (int i = 0; i < 9; i++) { - if (SlimefunManager.isItemSimiliar(recipe[i], old, true)) recipe[i] = stack; + if (SlimefunManager.isItemSimilar(recipe[i], old, true)) recipe[i] = stack; } sfi.setRecipe(recipe); } @@ -612,8 +614,22 @@ public class SlimefunItem { itemhandlers.stream().filter(c::isInstance).map(c::cast).forEach(callable); } + public boolean isTicking() { + return ticking; + } + @Override public String toString() { return "SlimefunItem: " + id + " (" + state + ", vanilla=" + !addon + ")"; } + + @Override + public Collection getDrops() { + return Arrays.asList(item.clone()); + } + + @Override + public Collection getDrops(Player p) { + return getDrops(); + } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SoulboundBackpack.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SoulboundBackpack.java index d1d6a3b10..28e8b5d32 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SoulboundBackpack.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SoulboundBackpack.java @@ -4,9 +4,10 @@ import org.bukkit.inventory.ItemStack; import me.mrCookieSlime.Slimefun.Lists.RecipeType; import me.mrCookieSlime.Slimefun.Objects.Category; +import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.interfaces.Soulbound; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; -public class SoulboundBackpack extends SlimefunBackpack { +public class SoulboundBackpack extends SlimefunBackpack implements Soulbound { public SoulboundBackpack(int size, Category category, SlimefunItemStack item, ItemStack[] recipe) { super(size, category, item, RecipeType.MAGIC_WORKBENCH, recipe); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/abstractItems/AContainer.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/abstractItems/AContainer.java index 41c40b7c6..f9b9f00c6 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/abstractItems/AContainer.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/abstractItems/AContainer.java @@ -125,6 +125,8 @@ public abstract class AContainer extends SlimefunItem implements InventoryBlock List displayRecipes = new ArrayList<>(recipes.size() * 2); for (MachineRecipe recipe: recipes) { + if (recipe.getInput().length != 1) continue; + displayRecipes.add(recipe.getInput()[0]); displayRecipes.add(recipe.getOutput()[0]); } @@ -192,7 +194,10 @@ public abstract class AContainer extends SlimefunItem implements InventoryBlock } else { inv.replaceExistingItem(22, new CustomItem(new ItemStack(Material.BLACK_STAINED_GLASS_PANE), " ")); - pushItems(b, processing.get(b).getOutput().clone()); + + for (ItemStack output: processing.get(b).getOutput()) { + inv.pushItem(output.clone(), getOutputSlots()); + } progress.remove(b); processing.remove(b); @@ -205,7 +210,7 @@ public abstract class AContainer extends SlimefunItem implements InventoryBlock for (MachineRecipe recipe: recipes) { for (ItemStack input: recipe.getInput()) { for (int slot: getInputSlots()) { - if (SlimefunManager.isItemSimiliar(inv.getItemInSlot(slot), input, true)) { + if (SlimefunManager.isItemSimilar(inv.getItemInSlot(slot), input, true)) { found.put(slot, input.getAmount()); break; } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/abstractItems/AGenerator.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/abstractItems/AGenerator.java index f28ca219c..2ebd7a84b 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/abstractItems/AGenerator.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/abstractItems/AGenerator.java @@ -188,9 +188,9 @@ public abstract class AGenerator extends SlimefunItem implements RecipeDisplayIt } else { ItemStack fuel = processing.get(l).getInput(); - if (SlimefunManager.isItemSimiliar(fuel, new ItemStack(Material.LAVA_BUCKET), true) - || SlimefunManager.isItemSimiliar(fuel, SlimefunItems.BUCKET_OF_FUEL, true) - || SlimefunManager.isItemSimiliar(fuel, SlimefunItems.BUCKET_OF_OIL, true)) { + if (SlimefunManager.isItemSimilar(fuel, new ItemStack(Material.LAVA_BUCKET), true) + || SlimefunManager.isItemSimilar(fuel, SlimefunItems.BUCKET_OF_FUEL, true) + || SlimefunManager.isItemSimilar(fuel, SlimefunItems.BUCKET_OF_OIL, true)) { inv.pushItem(new ItemStack(Material.BUCKET), getOutputSlots()); } inv.replaceExistingItem(22, new CustomItem(new ItemStack(Material.BLACK_STAINED_GLASS_PANE), " ")); @@ -226,7 +226,7 @@ public abstract class AGenerator extends SlimefunItem implements RecipeDisplayIt private MachineFuel findRecipe(BlockMenu menu, Map found) { for (MachineFuel recipe: recipes) { for (int slot: getInputSlots()) { - if (SlimefunManager.isItemSimiliar(menu.getItemInSlot(slot), recipe.getInput(), true)) { + if (SlimefunManager.isItemSimilar(menu.getItemInSlot(slot), recipe.getInput(), true)) { found.put(slot, recipe.getInput().getAmount()); return recipe; } @@ -260,8 +260,7 @@ public abstract class AGenerator extends SlimefunItem implements RecipeDisplayIt item.setItemMeta(im); list.add(item); } - - if (list.size() % 2 != 0) list.add(null); + return list; } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/abstractItems/AReactor.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/abstractItems/AReactor.java index c3c646b38..cd1eb70bd 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/abstractItems/AReactor.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/abstractItems/AReactor.java @@ -283,7 +283,7 @@ public abstract class AReactor extends SlimefunItem implements RecipeDisplayItem if (coolant) { if (port != null) { for (int slot: getCoolantSlots()) { - if (SlimefunManager.isItemSimiliar(port.getItemInSlot(slot), getCoolant(), true)) { + if (SlimefunManager.isItemSimilar(port.getItemInSlot(slot), getCoolant(), true)) { port.replaceExistingItem(slot, menu.pushItem(port.getItemInSlot(slot), getCoolantSlots())); } } @@ -291,7 +291,7 @@ public abstract class AReactor extends SlimefunItem implements RecipeDisplayItem boolean explosion = true; for (int slot: getCoolantSlots()) { - if (SlimefunManager.isItemSimiliar(menu.getItemInSlot(slot), getCoolant(), true)) { + if (SlimefunManager.isItemSimilar(menu.getItemInSlot(slot), getCoolant(), true)) { menu.replaceExistingItem(slot, InvUtils.decreaseItem(menu.getItemInSlot(slot), 1)); ReactorHologram.update(l, "&b\u2744 &7100%"); explosion = false; @@ -372,7 +372,7 @@ public abstract class AReactor extends SlimefunItem implements RecipeDisplayItem private void restockFuel(BlockMenu menu, BlockMenu port) { for (int slot: getFuelSlots()) { for (MachineFuel recipe: recipes) { - if (SlimefunManager.isItemSimiliar(port.getItemInSlot(slot), recipe.getInput(), true) && menu.fits(new CustomItem(port.getItemInSlot(slot), 1), getFuelSlots())) { + if (SlimefunManager.isItemSimilar(port.getItemInSlot(slot), recipe.getInput(), true) && menu.fits(new CustomItem(port.getItemInSlot(slot), 1), getFuelSlots())) { port.replaceExistingItem(slot, menu.pushItem(port.getItemInSlot(slot), getFuelSlots())); return; } @@ -383,7 +383,7 @@ public abstract class AReactor extends SlimefunItem implements RecipeDisplayItem private MachineFuel findRecipe(BlockMenu menu, Map found) { for (MachineFuel recipe: recipes) { for (int slot: getInputSlots()) { - if (SlimefunManager.isItemSimiliar(menu.getItemInSlot(slot), recipe.getInput(), true)) { + if (SlimefunManager.isItemSimilar(menu.getItemInSlot(slot), recipe.getInput(), true)) { found.put(slot, recipe.getInput().getAmount()); return recipe; } @@ -426,8 +426,7 @@ public abstract class AReactor extends SlimefunItem implements RecipeDisplayItem item.setItemMeta(im); list.add(item); } - - if (list.size() % 2 != 0) list.add(null); + return list; } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/abstractItems/MachineFuel.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/abstractItems/MachineFuel.java index ad14d4ff4..5e05b4e3e 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/abstractItems/MachineFuel.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/abstractItems/MachineFuel.java @@ -4,18 +4,18 @@ import org.bukkit.inventory.ItemStack; public class MachineFuel { - private int seconds; + private int ticks; private ItemStack fuel; private ItemStack output; public MachineFuel(int seconds, ItemStack fuel) { - this.seconds = seconds * 2; + this.ticks = seconds * 2; this.fuel = fuel; this.output = null; } public MachineFuel(int seconds, ItemStack fuel, ItemStack output) { - this.seconds = seconds * 2; + this.ticks = seconds * 2; this.fuel = fuel; this.output = output; } @@ -29,7 +29,7 @@ public class MachineFuel { } public int getTicks() { - return seconds; + return ticks; } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/DietCookie.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/DietCookie.java index 158ae6600..f1ddbaa50 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/DietCookie.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/DietCookie.java @@ -9,7 +9,6 @@ import me.mrCookieSlime.Slimefun.Lists.RecipeType; import me.mrCookieSlime.Slimefun.Objects.Category; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SimpleSlimefunItem; import me.mrCookieSlime.Slimefun.Objects.handlers.ItemConsumptionHandler; -import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class DietCookie extends SimpleSlimefunItem { @@ -21,7 +20,7 @@ public class DietCookie extends SimpleSlimefunItem { @Override public ItemConsumptionHandler getItemHandler() { return (e, p, item) -> { - if (SlimefunManager.isItemSimiliar(item, getItem(), true)) { + if (isItem(item)) { p.sendMessage(ChatColor.YELLOW + "You feel so light..."); p.playSound(p.getLocation(), Sound.ENTITY_GENERIC_EAT, 1, 1); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/EnderBackpack.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/EnderBackpack.java index 2f33a489b..4c0ddf7e3 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/EnderBackpack.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/EnderBackpack.java @@ -4,11 +4,9 @@ import org.bukkit.Sound; import org.bukkit.inventory.ItemStack; import me.mrCookieSlime.Slimefun.Lists.RecipeType; -import me.mrCookieSlime.Slimefun.Lists.SlimefunItems; import me.mrCookieSlime.Slimefun.Objects.Category; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SimpleSlimefunItem; import me.mrCookieSlime.Slimefun.Objects.handlers.ItemInteractionHandler; -import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class EnderBackpack extends SimpleSlimefunItem { @@ -20,7 +18,7 @@ public class EnderBackpack extends SimpleSlimefunItem { @Override public ItemInteractionHandler getItemHandler() { return (e, p, item) -> { - if (SlimefunManager.isItemSimiliar(item, SlimefunItems.ENDER_BACKPACK, true)) { + if (isItem(item)) { e.setCancelled(true); p.openInventory(p.getEnderChest()); p.getWorld().playSound(p.getLocation(), Sound.ENTITY_ENDERMAN_TELEPORT, 1, 1); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/FortuneCookie.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/FortuneCookie.java index 6d282c8b8..5d645bc76 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/FortuneCookie.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/FortuneCookie.java @@ -11,7 +11,6 @@ import me.mrCookieSlime.Slimefun.Lists.RecipeType; import me.mrCookieSlime.Slimefun.Objects.Category; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SimpleSlimefunItem; import me.mrCookieSlime.Slimefun.Objects.handlers.ItemConsumptionHandler; -import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class FortuneCookie extends SimpleSlimefunItem { @@ -25,7 +24,7 @@ public class FortuneCookie extends SimpleSlimefunItem { @Override public ItemConsumptionHandler getItemHandler() { return (e, p, item) -> { - if (SlimefunManager.isItemSimiliar(item, getItem(), true)) { + if (isItem(item)) { List messages = SlimefunPlugin.getLocal().getMessages("messages.fortune-cookie"); String message = messages.get(random.nextInt(messages.size())); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/GoldPan.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/GoldPan.java index 8b157816e..749629406 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/GoldPan.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/GoldPan.java @@ -1,15 +1,13 @@ package me.mrCookieSlime.Slimefun.Objects.SlimefunItem.items; -import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import java.util.Random; -import java.util.concurrent.ThreadLocalRandom; import org.bukkit.Effect; import org.bukkit.Material; import org.bukkit.inventory.ItemStack; +import io.github.thebusybiscuit.cscorelib2.collections.RandomizedSet; import io.github.thebusybiscuit.cscorelib2.protection.ProtectableAction; import me.mrCookieSlime.Slimefun.SlimefunPlugin; import me.mrCookieSlime.Slimefun.Lists.RecipeType; @@ -24,11 +22,8 @@ import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class GoldPan extends SimpleSlimefunItem implements RecipeDisplayItem { private final List recipes; - - private int chanceSiftedOre; - private int chanceFlint; - private int chanceClay; - private int chanceIronNuggets; + private final RandomizedSet randomizer = new RandomizedSet<>(); + private int weights; public GoldPan(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) { super(category, item, recipeType, recipe, new String[] {"chance.FLINT", "chance.CLAY", "chance.SIFTED_ORE", "chance.IRON_NUGGET"}, new Integer[] {40, 20, 35, 5}); @@ -43,30 +38,33 @@ public class GoldPan extends SimpleSlimefunItem implemen @Override public void postRegister() { - chanceSiftedOre = (int) Slimefun.getItemValue(getID(), "chance.SIFTED_ORE"); - chanceClay = (int) Slimefun.getItemValue(getID(), "chance.CLAY"); - chanceFlint = (int) Slimefun.getItemValue(getID(), "chance.FLINT"); - chanceIronNuggets = (int) Slimefun.getItemValue(getID(), "chance.IRON_NUGGET"); + add(SlimefunItems.SIFTED_ORE, (int) Slimefun.getItemValue(getID(), "chance.SIFTED_ORE")); + add(new ItemStack(Material.CLAY_BALL), (int) Slimefun.getItemValue(getID(), "chance.CLAY")); + add(new ItemStack(Material.FLINT), (int) Slimefun.getItemValue(getID(), "chance.FLINT")); + add(new ItemStack(Material.IRON_NUGGET), (int) Slimefun.getItemValue(getID(), "chance.IRON_NUGGET")); + + if (weights < 100) { + add(new ItemStack(Material.AIR), 100 - weights); + } } + private void add(ItemStack item, int chance) { + randomizer.add(item, chance); + weights += chance; + } + @Override public ItemInteractionHandler getItemHandler() { return (e, p, item) -> { if (isItem(item)) { if (e.getClickedBlock() != null && e.getClickedBlock().getType() == Material.GRAVEL && SlimefunPlugin.getProtectionManager().hasPermission(p, e.getClickedBlock().getLocation(), ProtectableAction.BREAK_BLOCK)) { - List drops = new ArrayList<>(); - Random random = ThreadLocalRandom.current(); - - if (random.nextInt(100) < chanceSiftedOre) drops.add(SlimefunItems.SIFTED_ORE); - else if (random.nextInt(100) < chanceClay) drops.add(new ItemStack(Material.CLAY_BALL)); - else if (random.nextInt(100) < chanceFlint) drops.add(new ItemStack(Material.FLINT)); - else if (random.nextInt(100) < chanceIronNuggets) drops.add(new ItemStack(Material.IRON_NUGGET)); - + ItemStack output = randomizer.getRandom(); + e.getClickedBlock().getWorld().playEffect(e.getClickedBlock().getLocation(), Effect.STEP_SOUND, e.getClickedBlock().getType()); e.getClickedBlock().setType(Material.AIR); - for (ItemStack drop: drops) { - e.getClickedBlock().getWorld().dropItemNaturally(e.getClickedBlock().getLocation(), drop); + if (output.getType() != Material.AIR) { + e.getClickedBlock().getWorld().dropItemNaturally(e.getClickedBlock().getLocation(), output.clone()); } } e.setCancelled(true); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/GrapplingHook.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/GrapplingHook.java index 58157de85..bf119a11f 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/GrapplingHook.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/GrapplingHook.java @@ -18,7 +18,6 @@ import me.mrCookieSlime.Slimefun.Lists.RecipeType; import me.mrCookieSlime.Slimefun.Objects.Category; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SimpleSlimefunItem; import me.mrCookieSlime.Slimefun.Objects.handlers.ItemInteractionHandler; -import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; import me.mrCookieSlime.Slimefun.api.Slimefun; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; import me.mrCookieSlime.Slimefun.utils.Utilities; @@ -36,7 +35,7 @@ public class GrapplingHook extends SimpleSlimefunItem { Utilities utilities = SlimefunPlugin.getUtilities(); return (e, p, item) -> { - if (SlimefunManager.isItemSimiliar(item, getItem(), true)) { + if (isItem(item)) { UUID uuid = p.getUniqueId(); if (e.getClickedBlock() == null && !utilities.jumpState.containsKey(uuid)) { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/HerculesPickaxe.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/HerculesPickaxe.java index df4eca36a..31b47e13c 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/HerculesPickaxe.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/HerculesPickaxe.java @@ -9,7 +9,6 @@ import me.mrCookieSlime.Slimefun.Lists.SlimefunItems; import me.mrCookieSlime.Slimefun.Objects.Category; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SimpleSlimefunItem; import me.mrCookieSlime.Slimefun.Objects.handlers.BlockBreakHandler; -import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class HerculesPickaxe extends SimpleSlimefunItem { @@ -26,7 +25,7 @@ public class HerculesPickaxe extends SimpleSlimefunItem { @Override public BlockBreakHandler getItemHandler() { return (e, item, fortune, drops) -> { - if (SlimefunManager.isItemSimiliar(item, SlimefunItems.HERCULES_PICKAXE, true) && e.getBlock().getType().toString().endsWith("_ORE")) { + if (isItem(item) && e.getBlock().getType().toString().endsWith("_ORE")) { if (e.getBlock().getType() == Material.IRON_ORE) { drops.add(new CustomItem(SlimefunItems.IRON_DUST, 2)); } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/InfernalBonemeal.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/InfernalBonemeal.java index b766c52dc..0062f5e68 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/InfernalBonemeal.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/InfernalBonemeal.java @@ -11,7 +11,6 @@ import me.mrCookieSlime.Slimefun.Lists.RecipeType; import me.mrCookieSlime.Slimefun.Objects.Category; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SimpleSlimefunItem; import me.mrCookieSlime.Slimefun.Objects.handlers.ItemInteractionHandler; -import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class InfernalBonemeal extends SimpleSlimefunItem { @@ -23,7 +22,7 @@ public class InfernalBonemeal extends SimpleSlimefunItem @Override public ItemInteractionHandler getItemHandler() { return (e, p, item) -> { - if (SlimefunManager.isItemSimiliar(item, getItem(), true)) { + if (isItem(item)) { if (e.getClickedBlock() != null && e.getClickedBlock().getType() == Material.NETHER_WART) { Ageable ageable = (Ageable) e.getClickedBlock().getBlockData(); if (ageable.getAge() < ageable.getMaximumAge()) { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/KnowledgeTome.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/KnowledgeTome.java index 2689d5aa7..302238289 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/KnowledgeTome.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/KnowledgeTome.java @@ -10,13 +10,11 @@ import org.bukkit.Sound; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.ItemMeta; -import io.github.thebusybiscuit.cscorelib2.inventory.ItemUtils; import me.mrCookieSlime.Slimefun.Lists.RecipeType; import me.mrCookieSlime.Slimefun.Objects.Category; import me.mrCookieSlime.Slimefun.Objects.Research; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SimpleSlimefunItem; import me.mrCookieSlime.Slimefun.Objects.handlers.ItemInteractionHandler; -import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; import me.mrCookieSlime.Slimefun.api.PlayerProfile; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; @@ -29,26 +27,26 @@ public class KnowledgeTome extends SimpleSlimefunItem { @Override public ItemInteractionHandler getItemHandler() { return (e, p, item) -> { - if (SlimefunManager.isItemSimiliar(item, getItem(), true)) { - List lore = item.getItemMeta().getLore(); - lore.set(0, ChatColor.translateAlternateColorCodes('&', "&7Owner: &b" + p.getName())); - lore.set(1, ChatColor.BLACK + "" + p.getUniqueId()); + if (isItem(item)) { ItemMeta im = item.getItemMeta(); - im.setLore(lore); - item.setItemMeta(im); - p.getEquipment().setItemInMainHand(item); - p.getWorld().playSound(p.getLocation(), Sound.ENTITY_PLAYER_LEVELUP, 1F, 1F); - return true; - } - else if (SlimefunManager.isItemSimiliar(item, getItem(), false)) { - PlayerProfile.get(p, profile -> { - PlayerProfile.fromUUID(UUID.fromString(ChatColor.stripColor(item.getItemMeta().getLore().get(1))), owner -> { + List lore = im.getLore(); + if (lore.get(1).isEmpty()) { + lore.set(0, ChatColor.translateAlternateColorCodes('&', "&7Owner: &b" + p.getName())); + lore.set(1, ChatColor.BLACK + "" + p.getUniqueId()); + im.setLore(lore); + item.setItemMeta(im); + p.getWorld().playSound(p.getLocation(), Sound.ENTITY_PLAYER_LEVELUP, 1F, 1F); + } else { + UUID uuid = UUID.fromString(ChatColor.stripColor(item.getItemMeta().getLore().get(1))); + if (p.getUniqueId().equals(uuid)) + return true; + PlayerProfile.get(p, profile -> PlayerProfile.fromUUID(uuid, owner -> { Set researches = owner.getResearches(); - researches.forEach(research -> profile.setResearched(research, true)); - }); - }); - - if (p.getGameMode() != GameMode.CREATIVE) ItemUtils.consumeItem(item, false); + researches.forEach(research -> research.unlock(p, true)); + })); + if (p.getGameMode() != GameMode.CREATIVE) + item.setAmount(item.getAmount() - 1); + } return true; } else return false; diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/LumberAxe.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/LumberAxe.java index 3c2638169..f458df373 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/LumberAxe.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/LumberAxe.java @@ -16,7 +16,6 @@ import me.mrCookieSlime.Slimefun.Objects.Category; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SimpleSlimefunItem; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.interfaces.NotPlaceable; import me.mrCookieSlime.Slimefun.Objects.handlers.BlockBreakHandler; -import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class LumberAxe extends SimpleSlimefunItem implements NotPlaceable { @@ -33,7 +32,7 @@ public class LumberAxe extends SimpleSlimefunItem implements @Override public BlockBreakHandler getItemHandler() { return (e, item, fortune, drops) -> { - if (SlimefunManager.isItemSimiliar(e.getPlayer().getInventory().getItemInMainHand(), getItem(), true)) { + if (isItem(item)) { if (MaterialCollections.getAllLogs().contains(e.getBlock().getType())) { List logs = Vein.find(e.getBlock(), 100, b -> MaterialCollections.getAllLogs().contains(b.getType())); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/MagicEyeOfEnder.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/MagicEyeOfEnder.java index 50f2cbe05..d811a2331 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/MagicEyeOfEnder.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/MagicEyeOfEnder.java @@ -24,7 +24,12 @@ public class MagicEyeOfEnder extends SimpleSlimefunItem if (isItem(item)) { e.getParentEvent().setCancelled(true); - if (p.getInventory().getHelmet() != null && p.getInventory().getChestplate() != null && p.getInventory().getLeggings() != null && p.getInventory().getBoots() != null && SlimefunManager.isItemSimiliar(p.getInventory().getHelmet(), SlimefunItems.ENDER_HELMET, true) && SlimefunManager.isItemSimiliar(p.getInventory().getChestplate(), SlimefunItems.ENDER_CHESTPLATE, true) && SlimefunManager.isItemSimiliar(p.getInventory().getLeggings(), SlimefunItems.ENDER_LEGGINGS, true) && SlimefunManager.isItemSimiliar(p.getInventory().getBoots(), SlimefunItems.ENDER_BOOTS, true)) { + if ( + SlimefunManager.isItemSimilar(p.getInventory().getHelmet(), SlimefunItems.ENDER_HELMET, true) && + SlimefunManager.isItemSimilar(p.getInventory().getChestplate(), SlimefunItems.ENDER_CHESTPLATE, true) && + SlimefunManager.isItemSimilar(p.getInventory().getLeggings(), SlimefunItems.ENDER_LEGGINGS, true) && + SlimefunManager.isItemSimilar(p.getInventory().getBoots(), SlimefunItems.ENDER_BOOTS, true) + ) { p.launchProjectile(EnderPearl.class); p.getWorld().playSound(p.getLocation(), Sound.ENTITY_ENDERMAN_TELEPORT, 1, 1); } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/MonsterJerky.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/MonsterJerky.java index d75975c57..be1902540 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/MonsterJerky.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/MonsterJerky.java @@ -9,7 +9,6 @@ import me.mrCookieSlime.Slimefun.Lists.RecipeType; import me.mrCookieSlime.Slimefun.Objects.Category; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SimpleSlimefunItem; import me.mrCookieSlime.Slimefun.Objects.handlers.ItemConsumptionHandler; -import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class MonsterJerky extends SimpleSlimefunItem { @@ -21,7 +20,7 @@ public class MonsterJerky extends SimpleSlimefunItem { @Override public ItemConsumptionHandler getItemHandler() { return (e, p, item) -> { - if (SlimefunManager.isItemSimiliar(item, getItem(), true)) { + if (isItem(item)) { SlimefunPlugin.instance.getServer().getScheduler().runTaskLater(SlimefunPlugin.instance, () -> { if (p.hasPotionEffect(PotionEffectType.HUNGER)) { p.removePotionEffect(PotionEffectType.HUNGER); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/NetherGoldPan.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/NetherGoldPan.java index 85a4ce3cb..6cf4753fc 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/NetherGoldPan.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/NetherGoldPan.java @@ -1,15 +1,13 @@ package me.mrCookieSlime.Slimefun.Objects.SlimefunItem.items; -import java.util.ArrayList; import java.util.Arrays; import java.util.List; -import java.util.Random; -import java.util.concurrent.ThreadLocalRandom; import org.bukkit.Effect; import org.bukkit.Material; import org.bukkit.inventory.ItemStack; +import io.github.thebusybiscuit.cscorelib2.collections.RandomizedSet; import io.github.thebusybiscuit.cscorelib2.protection.ProtectableAction; import me.mrCookieSlime.Slimefun.SlimefunPlugin; import me.mrCookieSlime.Slimefun.Lists.RecipeType; @@ -23,13 +21,8 @@ import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class NetherGoldPan extends SimpleSlimefunItem implements RecipeDisplayItem { private final List recipes; - - private int chanceQuartz; - private int chanceGoldNuggets; - private int chanceNetherWart; - private int chanceBlazePowder; - private int chanceGlowstoneDust; - private int chanceGhastTear; + private final RandomizedSet randomizer = new RandomizedSet<>(); + private int weights; public NetherGoldPan(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) { super(category, item, recipeType, recipe, @@ -49,12 +42,21 @@ public class NetherGoldPan extends SimpleSlimefunItem im @Override public void postRegister() { - chanceQuartz = (int) Slimefun.getItemValue(getID(), "chance.QUARTZ"); - chanceGoldNuggets = (int) Slimefun.getItemValue(getID(), "chance.GOLD_NUGGET"); - chanceNetherWart = (int) Slimefun.getItemValue(getID(), "chance.NETHER_WART"); - chanceBlazePowder = (int) Slimefun.getItemValue(getID(), "chance.BLAZE_POWDER"); - chanceGlowstoneDust = (int) Slimefun.getItemValue(getID(), "chance.GLOWSTONE_DUST"); - chanceGhastTear = (int) Slimefun.getItemValue(getID(), "chance.GHAST_TEAR"); + add(new ItemStack(Material.QUARTZ), (int) Slimefun.getItemValue(getID(), "chance.QUARTZ")); + add(new ItemStack(Material.GOLD_NUGGET), (int) Slimefun.getItemValue(getID(), "chance.GOLD_NUGGET")); + add(new ItemStack(Material.NETHER_WART), (int) Slimefun.getItemValue(getID(), "chance.NETHER_WART")); + add(new ItemStack(Material.BLAZE_POWDER), (int) Slimefun.getItemValue(getID(), "chance.BLAZE_POWDER")); + add(new ItemStack(Material.GLOWSTONE_DUST), (int) Slimefun.getItemValue(getID(), "chance.GLOWSTONE_DUST")); + add(new ItemStack(Material.GHAST_TEAR), (int) Slimefun.getItemValue(getID(), "chance.GHAST_TEAR")); + + if (weights < 100) { + add(new ItemStack(Material.AIR), 100 - weights); + } + } + + private void add(ItemStack item, int chance) { + randomizer.add(item, chance); + weights += chance; } @Override @@ -62,21 +64,13 @@ public class NetherGoldPan extends SimpleSlimefunItem im return (e, p, item) -> { if (isItem(item)) { if (e.getClickedBlock() != null && e.getClickedBlock().getType() == Material.SOUL_SAND && SlimefunPlugin.getProtectionManager().hasPermission(p, e.getClickedBlock().getLocation(), ProtectableAction.BREAK_BLOCK)) { - List drops = new ArrayList<>(); - Random random = ThreadLocalRandom.current(); - - if (random.nextInt(100) < chanceQuartz) drops.add(new ItemStack(Material.QUARTZ)); - else if (random.nextInt(100) < chanceGoldNuggets) drops.add(new ItemStack(Material.GOLD_NUGGET)); - else if (random.nextInt(100) < chanceNetherWart) drops.add(new ItemStack(Material.NETHER_WART)); - else if (random.nextInt(100) < chanceBlazePowder) drops.add(new ItemStack(Material.BLAZE_POWDER)); - else if (random.nextInt(100) < chanceGlowstoneDust) drops.add(new ItemStack(Material.GLOWSTONE_DUST)); - else if (random.nextInt(100) < chanceGhastTear) drops.add(new ItemStack(Material.GHAST_TEAR)); + ItemStack output = randomizer.getRandom(); e.getClickedBlock().getWorld().playEffect(e.getClickedBlock().getLocation(), Effect.STEP_SOUND, e.getClickedBlock().getType()); e.getClickedBlock().setType(Material.AIR); - for (ItemStack drop: drops) { - e.getClickedBlock().getWorld().dropItemNaturally(e.getClickedBlock().getLocation(), drop); + if (output.getType() != Material.AIR) { + e.getClickedBlock().getWorld().dropItemNaturally(e.getClickedBlock().getLocation(), output.clone()); } } e.setCancelled(true); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/PickaxeOfContainment.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/PickaxeOfContainment.java index 47f81c2e7..116f872a6 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/PickaxeOfContainment.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/PickaxeOfContainment.java @@ -14,7 +14,6 @@ import me.mrCookieSlime.Slimefun.Lists.SlimefunItems; import me.mrCookieSlime.Slimefun.Objects.Category; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SimpleSlimefunItem; import me.mrCookieSlime.Slimefun.Objects.handlers.BlockBreakHandler; -import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; import me.mrCookieSlime.Slimefun.api.BlockStorage; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; @@ -32,7 +31,7 @@ public class PickaxeOfContainment extends SimpleSlimefunItem @Override public BlockBreakHandler getItemHandler() { return (e, item, fortune, drops) -> { - if (SlimefunManager.isItemSimiliar(item, getItem(), true)) { + if (isItem(item)) { // Refactored it into this so we don't need to call e.getBlock() all the time. Block b = e.getBlock(); if (b.getType() != Material.SPAWNER) return true; diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/PortableCrafter.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/PortableCrafter.java index 3e4a6dc6a..4735ecf79 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/PortableCrafter.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/PortableCrafter.java @@ -4,11 +4,9 @@ import org.bukkit.Sound; import org.bukkit.inventory.ItemStack; import me.mrCookieSlime.Slimefun.Lists.RecipeType; -import me.mrCookieSlime.Slimefun.Lists.SlimefunItems; import me.mrCookieSlime.Slimefun.Objects.Category; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SimpleSlimefunItem; import me.mrCookieSlime.Slimefun.Objects.handlers.ItemInteractionHandler; -import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class PortableCrafter extends SimpleSlimefunItem { @@ -20,7 +18,7 @@ public class PortableCrafter extends SimpleSlimefunItem @Override public ItemInteractionHandler getItemHandler() { return (e, p, item) -> { - if (SlimefunManager.isItemSimiliar(item, SlimefunItems.PORTABLE_CRAFTER, true)) { + if (isItem(item)) { p.openWorkbench(p.getLocation(), true); p.getWorld().playSound(p.getLocation(), Sound.BLOCK_WOODEN_BUTTON_CLICK_ON, 1, 1); return true; diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/PortableDustbin.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/PortableDustbin.java index 94cb6efa6..ad46e16df 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/PortableDustbin.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/PortableDustbin.java @@ -6,11 +6,9 @@ import org.bukkit.Sound; import org.bukkit.inventory.ItemStack; import me.mrCookieSlime.Slimefun.Lists.RecipeType; -import me.mrCookieSlime.Slimefun.Lists.SlimefunItems; import me.mrCookieSlime.Slimefun.Objects.Category; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SimpleSlimefunItem; import me.mrCookieSlime.Slimefun.Objects.handlers.ItemInteractionHandler; -import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class PortableDustbin extends SimpleSlimefunItem { @@ -22,7 +20,7 @@ public class PortableDustbin extends SimpleSlimefunItem @Override public ItemInteractionHandler getItemHandler() { return (e, p, item) -> { - if (SlimefunManager.isItemSimiliar(item, SlimefunItems.PORTABLE_DUSTBIN, true)) { + if (isItem(item)) { e.setCancelled(true); p.openInventory(Bukkit.createInventory(null, 9 * 3, ChatColor.DARK_RED + "Delete Items")); p.playSound(p.getLocation(), Sound.BLOCK_ANVIL_LAND, 1, 1); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/SoulboundRune.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/SoulboundRune.java index e327aec36..36fa4e09b 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/SoulboundRune.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/SoulboundRune.java @@ -38,7 +38,7 @@ public class SoulboundRune extends SimpleSlimefunItem { public ItemDropHandler getItemHandler() { return (e, p, i) -> { ItemStack item = i.getItemStack(); - if (SlimefunManager.isItemSimiliar(item, SlimefunItems.RUNE_SOULBOUND, true)) { + if (isItem(item)) { if (!Slimefun.hasUnlocked(p, SlimefunItems.RUNE_SOULBOUND, true)) { return true; @@ -50,8 +50,9 @@ public class SoulboundRune extends SimpleSlimefunItem { Location l = i.getLocation(); Collection entites = l.getWorld().getNearbyEntities(l, 1.5, 1.5, 1.5, - entity -> entity instanceof Item && !SlimefunManager.isItemSoulbound(((Item) entity).getItemStack()) && - !SlimefunManager.isItemSimiliar(((Item) entity).getItemStack(), SlimefunItems.RUNE_SOULBOUND, true) + entity -> entity instanceof Item && + !SlimefunManager.isItemSoulbound(((Item) entity).getItemStack()) && + !SlimefunManager.isItemSimilar(((Item) entity).getItemStack(), SlimefunItems.RUNE_SOULBOUND, true) ); if (entites.isEmpty()) return; @@ -68,7 +69,7 @@ public class SoulboundRune extends SimpleSlimefunItem { // This lightning is just an effect, it deals no damage. l.getWorld().strikeLightningEffect(l); - Bukkit.getScheduler().scheduleSyncDelayedTask(SlimefunPlugin.instance, () -> { + Slimefun.runSync(() -> { // Being sure entities are still valid and not picked up or whatsoever. if (i.isValid() && ent.isValid()) { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/StormStaff.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/StormStaff.java index 60c84d439..a2793d8e3 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/StormStaff.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/StormStaff.java @@ -21,7 +21,6 @@ import me.mrCookieSlime.Slimefun.Lists.SlimefunItems; import me.mrCookieSlime.Slimefun.Objects.Category; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SimpleSlimefunItem; import me.mrCookieSlime.Slimefun.Objects.handlers.ItemInteractionHandler; -import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class StormStaff extends SimpleSlimefunItem { @@ -49,9 +48,7 @@ public class StormStaff extends SimpleSlimefunItem { @Override public ItemInteractionHandler getItemHandler() { return (e, p, item) -> { - //Not checking if lores equals because we need a special one for that. - if (SlimefunManager.isItemSimiliar(item, getItem(), false)) { - + if (isItem(item)) { if (!item.hasItemMeta()) return false; ItemMeta itemMeta = item.getItemMeta(); if (!itemMeta.hasLore()) return false; diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/SwordOfBeheading.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/SwordOfBeheading.java index 6fdd3f3a2..7f463bb42 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/SwordOfBeheading.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/SwordOfBeheading.java @@ -16,7 +16,6 @@ import me.mrCookieSlime.Slimefun.Lists.RecipeType; import me.mrCookieSlime.Slimefun.Objects.Category; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SimpleSlimefunItem; import me.mrCookieSlime.Slimefun.Objects.handlers.EntityKillHandler; -import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; import me.mrCookieSlime.Slimefun.api.Slimefun; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; @@ -42,7 +41,7 @@ public class SwordOfBeheading extends SimpleSlimefunItem { @Override public EntityKillHandler getItemHandler() { return (e, entity, killer, item) -> { - if (SlimefunManager.isItemSimiliar(item, getItem(), true)) { + if (isItem(item)) { if (e.getEntity() instanceof Zombie) { if (random.nextInt(100) < chanceZombie) { e.getDrops().add(new ItemStack(Material.ZOMBIE_HEAD)); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/WindStaff.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/WindStaff.java index 6e7df86c6..d3a1e1406 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/WindStaff.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/WindStaff.java @@ -13,7 +13,6 @@ import me.mrCookieSlime.Slimefun.Lists.RecipeType; import me.mrCookieSlime.Slimefun.Objects.Category; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SimpleSlimefunItem; import me.mrCookieSlime.Slimefun.Objects.handlers.ItemInteractionHandler; -import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class WindStaff extends SimpleSlimefunItem { @@ -25,7 +24,7 @@ public class WindStaff extends SimpleSlimefunItem { @Override public ItemInteractionHandler getItemHandler() { return (e, p, item) -> { - if (SlimefunManager.isItemSimiliar(item, getItem(), true)) { + if (isItem(item)) { if (p.getFoodLevel() >= 2) { if (p.getInventory().getItemInMainHand().getType() != Material.SHEARS && p.getGameMode() != GameMode.CREATIVE) { FoodLevelChangeEvent event = new FoodLevelChangeEvent(p, p.getFoodLevel() - 2); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/Composter.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/Composter.java index d1bf4f7a3..27537be0b 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/Composter.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/Composter.java @@ -71,7 +71,7 @@ public class Composter extends SlimefunGadget { SlimefunItem machine = SlimefunItem.getByID(id); for (ItemStack convert: RecipeType.getRecipeInputs(machine)) { - if (convert != null && SlimefunManager.isItemSimiliar(input, convert, true)) { + if (convert != null && SlimefunManager.isItemSimilar(input, convert, true)) { ItemStack removing = input.clone(); removing.setAmount(convert.getAmount()); p.getInventory().removeItem(removing); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/Crucible.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/Crucible.java index 9de5300b0..3fb9dc79e 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/Crucible.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/Crucible.java @@ -3,19 +3,17 @@ package me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines; import java.util.LinkedList; import java.util.List; -import org.bukkit.Bukkit; import org.bukkit.Material; import org.bukkit.Sound; import org.bukkit.Tag; import org.bukkit.block.Block; import org.bukkit.block.BlockFace; import org.bukkit.block.data.Levelled; -import org.bukkit.entity.Player; +import org.bukkit.block.data.Waterlogged; import org.bukkit.inventory.ItemStack; import io.github.thebusybiscuit.cscorelib2.materials.MaterialCollections; import io.github.thebusybiscuit.cscorelib2.protection.ProtectableAction; -import me.mrCookieSlime.CSCoreLibPlugin.events.ItemUseEvent; import me.mrCookieSlime.Slimefun.SlimefunPlugin; import me.mrCookieSlime.Slimefun.Lists.RecipeType; import me.mrCookieSlime.Slimefun.Objects.Category; @@ -24,6 +22,7 @@ import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem; import me.mrCookieSlime.Slimefun.Objects.handlers.ItemInteractionHandler; import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; import me.mrCookieSlime.Slimefun.api.BlockStorage; +import me.mrCookieSlime.Slimefun.api.Slimefun; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class Crucible extends SlimefunGadget { @@ -59,59 +58,91 @@ public class Crucible extends SlimefunGadget { return items.toArray(new ItemStack[0]); } + @Override public void preRegister() { - addItemHandler(new ItemInteractionHandler() { + addItemHandler((ItemInteractionHandler) (e, p, item) -> { + if (e.getClickedBlock() != null) { + String id = BlockStorage.checkID(e.getClickedBlock()); + if (id != null && id.equals("CRUCIBLE")) { + if (p.hasPermission("slimefun.inventory.bypass") || SlimefunPlugin.getProtectionManager().hasPermission(p, e.getClickedBlock().getLocation(), ProtectableAction.ACCESS_INVENTORIES)) { + final ItemStack input = p.getInventory().getItemInMainHand(); + final Block block = e.getClickedBlock().getRelative(BlockFace.UP); + SlimefunItem machine = SlimefunItem.getByID(id); - @Override - public boolean onRightClick(ItemUseEvent e, final Player p, ItemStack item) { - if (e.getClickedBlock() != null) { - String id = BlockStorage.checkID(e.getClickedBlock()); - if (id != null && id.equals("CRUCIBLE")) { - if (p.hasPermission("slimefun.inventory.bypass") || SlimefunPlugin.getProtectionManager().hasPermission(p, e.getClickedBlock().getLocation(), ProtectableAction.ACCESS_INVENTORIES)) { - final ItemStack input = p.getInventory().getItemInMainHand(); - final Block block = e.getClickedBlock().getRelative(BlockFace.UP); - SlimefunItem machine = SlimefunItem.getByID(id); - - for (ItemStack convert: RecipeType.getRecipeInputs(machine)) { - if (input != null && SlimefunManager.isItemSimiliar(input, convert, true)) { - e.setCancelled(true); - ItemStack removing = input.clone(); - removing.setAmount(convert.getAmount()); - - p.getInventory().removeItem(removing); + for (ItemStack convert: RecipeType.getRecipeInputs(machine)) { + if (SlimefunManager.isItemSimilar(input, convert, true)) { + e.setCancelled(true); - for (int i = 1; i < 9; i++) {int j = 8 - i; - Bukkit.getScheduler().runTaskLater(SlimefunPlugin.instance, () -> { - if (input.getType() == Material.COBBLESTONE || input.getType() == Material.TERRACOTTA || MaterialCollections.getAllTerracottaColors().contains(input.getType())) { - block.setType(Material.LAVA); - Levelled le = (Levelled) block.getBlockData(); - le.setLevel(j); - block.setBlockData(le, false); - block.getWorld().playSound(block.getLocation(), Sound.BLOCK_LAVA_POP, 1F, 1F); - } - else if (Tag.LEAVES.isTagged(input.getType())) { - block.setType(Material.WATER); - Levelled le = (Levelled) block.getBlockData(); - le.setLevel(j); - block.setBlockData(le, false); - block.getWorld().playSound(block.getLocation(), Sound.ENTITY_PLAYER_SPLASH, 1F, 1F); - } - }, i*50L); + ItemStack removing = input.clone(); + removing.setAmount(convert.getAmount()); + p.getInventory().removeItem(removing); + + boolean water = Tag.LEAVES.isTagged(input.getType()); + if (block.getType() == (water ? Material.WATER : Material.LAVA)) { + int level = ((Levelled) block.getBlockData()).getLevel(); + if (level > 7) + level -= 8; + if (level == 0) { + block.getWorld().playSound(block.getLocation(), water ? Sound.ENTITY_PLAYER_SPLASH : Sound.BLOCK_LAVA_POP, 1F, 1F); + } else { + int finalLevel = 7 - level; + Slimefun.runSync(() -> runPostTask(block, water ? Sound.ENTITY_PLAYER_SPLASH : Sound.BLOCK_LAVA_POP, finalLevel), 50L); } - + return true; + } else if (block.getType() == (water ? Material.LAVA : Material.WATER)) { + int level = ((Levelled) block.getBlockData()).getLevel(); + block.setType(level == 0 || level == 8 ? Material.OBSIDIAN : Material.STONE); + block.getWorld().playSound(block.getLocation(), Sound.BLOCK_LAVA_EXTINGUISH, 1F, 1F); return true; } + + Slimefun.runSync(() -> { + if (!block.getType().isAir()) { + if (water) { + if (block.getBlockData() instanceof Waterlogged) { + Waterlogged wl = (Waterlogged) block.getBlockData(); + wl.setWaterlogged(true); + block.setBlockData(wl, false); + block.getWorld().playSound(block.getLocation(), Sound.ENTITY_PLAYER_SPLASH, 1F, 1F); + return; + } + block.getWorld().playSound(block.getLocation(), Sound.BLOCK_METAL_BREAK, 1F, 1F); + return; + } + if (BlockStorage.hasBlockInfo(block)) + BlockStorage.clearBlockInfo(block); + block.getWorld().playSound(block.getLocation(), Sound.BLOCK_LAVA_EXTINGUISH, 1F, 1F); + } + block.setType(water ? Material.WATER : Material.LAVA); + runPostTask(block, water ? Sound.ENTITY_PLAYER_SPLASH : Sound.BLOCK_LAVA_POP, 1); + }, 50L); + + return true; } - SlimefunPlugin.getLocal().sendMessage(p, "machines.wrong-item", true); - return true; } + SlimefunPlugin.getLocal().sendMessage(p, "machines.wrong-item", true); return true; } + return true; } - return false; } + return false; }); } + private void runPostTask(Block block, Sound sound, int times) { + if (!(block.getBlockData() instanceof Levelled)) { + block.getWorld().playSound(block.getLocation(), Sound.BLOCK_METAL_BREAK, 1F, 1F); + return; + } + block.getWorld().playSound(block.getLocation(), sound, 1F, 1F); + int level = 8 - times; + Levelled le = (Levelled) block.getBlockData(); + le.setLevel(level); + block.setBlockData(le, false); + if (times < 8) + Slimefun.runSync(() -> runPostTask(block, sound, times + 1), 50L); + } + } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/ReactorAccessPort.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/ReactorAccessPort.java index a58158613..8f6f0f02e 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/ReactorAccessPort.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/ReactorAccessPort.java @@ -76,8 +76,8 @@ public class ReactorAccessPort extends SlimefunItem { @Override public int[] getSlotsAccessedByItemTransport(BlockMenu menu, ItemTransportFlow flow, ItemStack item) { if (flow == ItemTransportFlow.INSERT) { - if (SlimefunManager.isItemSimiliar(item, SlimefunItems.REACTOR_COOLANT_CELL, true)) return getCoolantSlots(); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.NETHER_ICE_COOLANT_CELL, true)) return getCoolantSlots(); + if (SlimefunManager.isItemSimilar(item, SlimefunItems.REACTOR_COOLANT_CELL, true)) return getCoolantSlots(); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.NETHER_ICE_COOLANT_CELL, true)) return getCoolantSlots(); else return getFuelSlots(); } else return getOutputSlots(); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AnimalGrowthAccelerator.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AnimalGrowthAccelerator.java index 5342e0e46..e50d6cc96 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AnimalGrowthAccelerator.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AnimalGrowthAccelerator.java @@ -90,7 +90,7 @@ public class AnimalGrowthAccelerator extends SlimefunItem implements InventoryBl protected void tick(Block b) { for (Entity n : b.getWorld().getNearbyEntities(b.getLocation(), 3.0, 3.0, 3.0, n -> n instanceof Ageable && n.isValid() && !((Ageable) n).isAdult())) { for (int slot: getInputSlots()) { - if (SlimefunManager.isItemSimiliar(BlockStorage.getInventory(b).getItemInSlot(slot), SlimefunItems.ORGANIC_FOOD, false)) { + if (SlimefunManager.isItemSimilar(BlockStorage.getInventory(b).getItemInSlot(slot), SlimefunItems.ORGANIC_FOOD, false)) { if (ChargableBlock.getCharge(b) < energyConsumption) return; ChargableBlock.addCharge(b, -energyConsumption); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutoAnvil.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutoAnvil.java index 488b613a6..2b98d2bf2 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutoAnvil.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutoAnvil.java @@ -66,7 +66,7 @@ public abstract class AutoAnvil extends AContainer { } else { menu.replaceExistingItem(22, new CustomItem(new ItemStack(Material.BLACK_STAINED_GLASS_PANE), " ")); - pushItems(b, processing.get(b).getOutput()); + menu.pushItem(processing.get(b).getOutput()[0].clone(), getOutputSlots()); progress.remove(b); processing.remove(b); @@ -80,7 +80,7 @@ public abstract class AutoAnvil extends AContainer { ItemStack item = menu.getItemInSlot(slot); if (item != null && item.getType().getMaxDurability() > 0 && ((Damageable) item.getItemMeta()).getDamage() > 0) { - if (SlimefunManager.isItemSimiliar(target, SlimefunItems.DUCT_TAPE, true)) { + if (SlimefunManager.isItemSimilar(target, SlimefunItems.DUCT_TAPE, true)) { ItemStack newItem = item.clone(); short durability = (short) (((Damageable) newItem.getItemMeta()).getDamage() - (item.getType().getMaxDurability() / getRepairFactor())); if (durability < 0) durability = 0; @@ -94,7 +94,7 @@ public abstract class AutoAnvil extends AContainer { } if (recipe != null) { - if (!fits(b, recipe.getOutput())) return; + if (!menu.fits(recipe.getOutput()[0], getOutputSlots())) return; for (int slot: getInputSlots()) { menu.replaceExistingItem(slot, InvUtils.decreaseItem(menu.getItemInSlot(slot), 1)); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutoBreeder.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutoBreeder.java index 815b50894..7aacfe0a4 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutoBreeder.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutoBreeder.java @@ -83,7 +83,7 @@ public class AutoBreeder extends SlimefunItem implements InventoryBlock { protected void tick(Block b) { for (Entity n : b.getWorld().getNearbyEntities(b.getLocation(), 4.0, 2.0, 4.0, n -> n instanceof Animals && n.isValid() && ((Animals) n).isAdult() && !((Animals) n).isLoveMode())) { for (int slot : getInputSlots()) { - if (SlimefunManager.isItemSimiliar(BlockStorage.getInventory(b).getItemInSlot(slot), SlimefunItems.ORGANIC_FOOD, false)) { + if (SlimefunManager.isItemSimilar(BlockStorage.getInventory(b).getItemInSlot(slot), SlimefunItems.ORGANIC_FOOD, false)) { if (ChargableBlock.getCharge(b) < energyConsumption) return; ChargableBlock.addCharge(b, -energyConsumption); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutoDisenchanter.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutoDisenchanter.java index d51b88385..c8454ca91 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutoDisenchanter.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutoDisenchanter.java @@ -5,7 +5,6 @@ import java.util.HashSet; import java.util.Map; import java.util.Set; -import me.mrCookieSlime.Slimefun.Events.AutoDisenchantEvent; import org.bukkit.Bukkit; import org.bukkit.Material; import org.bukkit.block.Block; @@ -32,6 +31,8 @@ import me.mrCookieSlime.Slimefun.utils.MachineHelper; import org.bukkit.inventory.meta.ItemMeta; import org.bukkit.inventory.meta.Repairable; +import io.github.thebusybiscuit.slimefun4.api.events.AutoDisenchantEvent; + public class AutoDisenchanter extends AContainer { public AutoDisenchanter(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) { @@ -82,7 +83,7 @@ public class AutoDisenchanter extends AContainer { Map enchantments = new HashMap<>(); Set enchantments2 = new HashSet<>(); - for (int slot: getInputSlots()) { + for (int slot : getInputSlots()) { ItemStack target = menu.getItemInSlot(slot == getInputSlots()[0] ? getInputSlots()[1]: getInputSlots()[0]); ItemStack item = menu.getItemInSlot(slot); @@ -107,16 +108,18 @@ public class AutoDisenchanter extends AContainer { if (item != null && target != null && target.getType() == Material.BOOK) { int amount = 0; - for (Map.Entry e: item.getEnchantments().entrySet()) { + for (Map.Entry e : item.getEnchantments().entrySet()) { enchantments.put(e.getKey(), e.getValue()); amount++; } + if (SlimefunPlugin.getHooks().isEmeraldEnchantsInstalled()) { - for (ItemEnchantment enchantment: EmeraldEnchants.getInstance().getRegistry().getEnchantments(item)) { + for (ItemEnchantment enchantment : EmeraldEnchants.getInstance().getRegistry().getEnchantments(item)) { amount++; enchantments2.add(enchantment); } } + if (amount > 0) { ItemStack newItem = item.clone(); newItem.setAmount(1); @@ -133,13 +136,14 @@ public class AutoDisenchanter extends AContainer { EnchantmentStorageMeta meta = (EnchantmentStorageMeta) book.getItemMeta(); - for (Map.Entry e: enchantments.entrySet()) { + for (Map.Entry e : enchantments.entrySet()) { newItem.removeEnchantment(e.getKey()); meta.addStoredEnchant(e.getKey(), e.getValue(), true); } + book.setItemMeta(meta); - for (ItemEnchantment e: enchantments2) { + for (ItemEnchantment e : enchantments2) { EmeraldEnchants.getInstance().getRegistry().applyEnchantment(book, e.getEnchantment(), e.getLevel()); EmeraldEnchants.getInstance().getRegistry().applyEnchantment(newItem, e.getEnchantment(), 0); } @@ -153,7 +157,7 @@ public class AutoDisenchanter extends AContainer { if (recipe != null) { if (!fits(b, recipe.getOutput())) return; - for (int slot: getInputSlots()) { + for (int slot : getInputSlots()) { menu.replaceExistingItem(slot, InvUtils.decreaseItem(menu.getItemInSlot(slot), 1)); } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutoDrier.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutoDrier.java index 69e790a43..0d1cc6d73 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutoDrier.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutoDrier.java @@ -120,7 +120,7 @@ public class AutoDrier extends AContainer implements RecipeDisplayItem { ItemStack output = null; for (int i = 0; i < recipeList.size(); i += 2) { - if (SlimefunManager.isItemSimiliar(item, recipeList.get(i), true)) { + if (SlimefunManager.isItemSimilar(item, recipeList.get(i), true)) { output = recipeList.get(i + 1); } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutomatedCraftingChamber.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutomatedCraftingChamber.java index 4259b664c..93ac9de05 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutomatedCraftingChamber.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutomatedCraftingChamber.java @@ -212,8 +212,8 @@ public abstract class AutomatedCraftingChamber extends SlimefunItem implements I if (SlimefunPlugin.getUtilities().automatedCraftingChamberRecipes.containsKey(input)) { ItemStack output = SlimefunPlugin.getUtilities().automatedCraftingChamberRecipes.get(input).clone(); - if (fits(b, output)) { - pushItems(b, output); + if (menu.fits(output, getOutputSlots())) { + menu.pushItem(output, getOutputSlots()); ChargableBlock.addCharge(b, -getEnergyConsumption()); for (int j = 0; j < 9; j++) { if (menu.getItemInSlot(getInputSlots()[j]) != null) menu.replaceExistingItem(getInputSlots()[j], InvUtils.decreaseItem(menu.getItemInSlot(getInputSlots()[j]), 1)); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/CropGrowthAccelerator.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/CropGrowthAccelerator.java index 0e70eb6f1..1789b0f3d 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/CropGrowthAccelerator.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/CropGrowthAccelerator.java @@ -105,7 +105,7 @@ public abstract class CropGrowthAccelerator extends SlimefunItem implements Inve protected void tick(Block b) { if (work(b) > 0) { for (int slot : getInputSlots()) { - if (SlimefunManager.isItemSimiliar(BlockStorage.getInventory(b).getItemInSlot(slot), SlimefunItems.FERTILIZER, false)) { + if (SlimefunManager.isItemSimilar(BlockStorage.getInventory(b).getItemInSlot(slot), SlimefunItems.FERTILIZER, false)) { BlockStorage.getInventory(b).replaceExistingItem(slot, InvUtils.decreaseItem(BlockStorage.getInventory(b).getItemInSlot(slot), 1)); break; } @@ -121,7 +121,7 @@ public abstract class CropGrowthAccelerator extends SlimefunItem implements Inve Block block = b.getRelative(x, 0, z); if (crops.containsKey(block.getType()) && ((Ageable) block.getBlockData()).getAge() < crops.get(block.getType())) { for (int slot : getInputSlots()) { - if (SlimefunManager.isItemSimiliar(BlockStorage.getInventory(b).getItemInSlot(slot), SlimefunItems.FERTILIZER, false)) { + if (SlimefunManager.isItemSimilar(BlockStorage.getInventory(b).getItemInSlot(slot), SlimefunItems.FERTILIZER, false)) { if (work > (getSpeed() - 1) || ChargableBlock.getCharge(b) < getEnergyConsumption()) return work; ChargableBlock.addCharge(b, -getEnergyConsumption()); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricDustWasher.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricDustWasher.java index 5ff440beb..dcadb222a 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricDustWasher.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricDustWasher.java @@ -59,7 +59,7 @@ public abstract class ElectricDustWasher extends AContainer { ChargableBlock.addCharge(b, -getEnergyConsumption()); menu.replaceExistingItem(22, new CustomItem(new ItemStack(Material.BLACK_STAINED_GLASS_PANE), " ")); - pushItems(b, processing.get(b).getOutput()); + menu.pushItem(processing.get(b).getOutput()[0].clone(), getOutputSlots()); progress.remove(b); processing.remove(b); @@ -69,7 +69,7 @@ public abstract class ElectricDustWasher extends AContainer { ItemStack[] items = SlimefunPlugin.getUtilities().oreWasherOutputs; for (int slot: getInputSlots()) { - if (SlimefunManager.isItemSimiliar(menu.getItemInSlot(slot), SlimefunItems.SIFTED_ORE, true)) { + if (SlimefunManager.isItemSimilar(menu.getItemInSlot(slot), SlimefunItems.SIFTED_ORE, true)) { if (!SlimefunPlugin.getSettings().legacyDustWasher) { boolean emptySlot = false; @@ -84,15 +84,15 @@ public abstract class ElectricDustWasher extends AContainer { ItemStack adding = items[new Random().nextInt(items.length)]; MachineRecipe r = new MachineRecipe(4 / getSpeed(), new ItemStack[0], new ItemStack[] {adding}); - if (SlimefunPlugin.getSettings().legacyDustWasher && !fits(b, r.getOutput())) return; + if (SlimefunPlugin.getSettings().legacyDustWasher && !menu.fits(r.getOutput()[0], getOutputSlots())) return; menu.replaceExistingItem(slot, InvUtils.decreaseItem(menu.getItemInSlot(slot), 1)); processing.put(b, r); progress.put(b, r.getTicks()); break; } - else if (SlimefunManager.isItemSimiliar(menu.getItemInSlot(slot), SlimefunItems.PULVERIZED_ORE, true)) { + else if (SlimefunManager.isItemSimilar(menu.getItemInSlot(slot), SlimefunItems.PULVERIZED_ORE, true)) { MachineRecipe r = new MachineRecipe(4 / getSpeed(), new ItemStack[0], new ItemStack[] {SlimefunItems.PURE_ORE_CLUSTER}); - if (!fits(b, r.getOutput())) return; + if (!menu.fits(r.getOutput()[0], getOutputSlots())) return; menu.replaceExistingItem(slot, InvUtils.decreaseItem(menu.getItemInSlot(slot), 1)); processing.put(b, r); progress.put(b, r.getTicks()); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricGoldPan.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricGoldPan.java index 51a094c84..445642067 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricGoldPan.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricGoldPan.java @@ -2,12 +2,12 @@ package me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric; import java.util.Arrays; import java.util.List; -import java.util.Random; import org.bukkit.Material; import org.bukkit.block.Block; import org.bukkit.inventory.ItemStack; +import io.github.thebusybiscuit.cscorelib2.collections.RandomizedSet; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.InvUtils; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.Item.CustomItem; import me.mrCookieSlime.Slimefun.Lists.RecipeType; @@ -18,6 +18,7 @@ import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.abstractItems.MachineRecip import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.interfaces.RecipeDisplayItem; import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; import me.mrCookieSlime.Slimefun.api.BlockStorage; +import me.mrCookieSlime.Slimefun.api.Slimefun; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; import me.mrCookieSlime.Slimefun.api.energy.ChargableBlock; import me.mrCookieSlime.Slimefun.api.inventory.BlockMenu; @@ -25,22 +26,55 @@ import me.mrCookieSlime.Slimefun.utils.MachineHelper; public abstract class ElectricGoldPan extends AContainer implements RecipeDisplayItem { - private Random random = new Random(); + private final RandomizedSet randomizer = new RandomizedSet<>(); + private final RandomizedSet randomizerNether = new RandomizedSet<>(); private final List displayRecipes = Arrays.asList( - new ItemStack(Material.GRAVEL), - SlimefunItems.SIFTED_ORE, - - new ItemStack(Material.GRAVEL), - new ItemStack(Material.FLINT), - - new ItemStack(Material.GRAVEL), - new ItemStack(Material.CLAY_BALL) + new ItemStack(Material.GRAVEL), new ItemStack(Material.FLINT), + new ItemStack(Material.GRAVEL), SlimefunItems.SIFTED_ORE, + new ItemStack(Material.GRAVEL), new ItemStack(Material.CLAY_BALL), + new ItemStack(Material.GRAVEL), new ItemStack(Material.IRON_NUGGET), + + new ItemStack(Material.SOUL_SAND), new ItemStack(Material.QUARTZ), + new ItemStack(Material.SOUL_SAND), new ItemStack(Material.GOLD_NUGGET), + new ItemStack(Material.SOUL_SAND), new ItemStack(Material.NETHER_WART), + new ItemStack(Material.SOUL_SAND), new ItemStack(Material.BLAZE_POWDER), + new ItemStack(Material.SOUL_SAND), new ItemStack(Material.GLOWSTONE_DUST), + new ItemStack(Material.SOUL_SAND), new ItemStack(Material.GHAST_TEAR) ); public ElectricGoldPan(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) { super(category, item, recipeType, recipe); } + + @Override + public void postRegister() { + super.postRegister(); + + String goldPan = "GOLD_PAN"; + String netherGoldPan = "NETHER_GOLD_PAN"; + + add(false, SlimefunItems.SIFTED_ORE, (int) Slimefun.getItemValue(goldPan, "chance.SIFTED_ORE")); + add(false, new ItemStack(Material.CLAY_BALL), (int) Slimefun.getItemValue(goldPan, "chance.CLAY")); + add(false, new ItemStack(Material.FLINT), (int) Slimefun.getItemValue(goldPan, "chance.FLINT")); + add(false, new ItemStack(Material.IRON_NUGGET), (int) Slimefun.getItemValue(goldPan, "chance.IRON_NUGGET")); + + add(true, new ItemStack(Material.QUARTZ), (int) Slimefun.getItemValue(netherGoldPan, "chance.QUARTZ")); + add(true, new ItemStack(Material.GOLD_NUGGET), (int) Slimefun.getItemValue(netherGoldPan, "chance.GOLD_NUGGET")); + add(true, new ItemStack(Material.NETHER_WART), (int) Slimefun.getItemValue(netherGoldPan, "chance.NETHER_WART")); + add(true, new ItemStack(Material.BLAZE_POWDER), (int) Slimefun.getItemValue(netherGoldPan, "chance.BLAZE_POWDER")); + add(true, new ItemStack(Material.GLOWSTONE_DUST), (int) Slimefun.getItemValue(netherGoldPan, "chance.GLOWSTONE_DUST")); + add(true, new ItemStack(Material.GHAST_TEAR), (int) Slimefun.getItemValue(netherGoldPan, "chance.GHAST_TEAR")); + } + + private void add(boolean nether, ItemStack item, int chance) { + if (nether) { + randomizerNether.add(item, chance); + } + else { + randomizer.add(item, chance); + } + } @Override public String getInventoryTitle() { @@ -74,7 +108,7 @@ public abstract class ElectricGoldPan extends AContainer implements RecipeDispla ChargableBlock.addCharge(b, -getEnergyConsumption()); menu.replaceExistingItem(22, new CustomItem(new ItemStack(Material.BLACK_STAINED_GLASS_PANE), " ")); - pushItems(b, processing.get(b).getOutput()); + menu.pushItem(processing.get(b).getOutput()[0].clone(), getOutputSlots()); progress.remove(b); processing.remove(b); @@ -82,13 +116,23 @@ public abstract class ElectricGoldPan extends AContainer implements RecipeDispla } else { for (int slot: getInputSlots()) { - if (SlimefunManager.isItemSimiliar(menu.getItemInSlot(slot), new ItemStack(Material.GRAVEL), true)) { - ItemStack output = SlimefunItems.SIFTED_ORE; - if (random.nextInt(100) < 16) output = new ItemStack(Material.FLINT); - if (random.nextInt(100) < 16) output = new ItemStack(Material.CLAY_BALL); + if (SlimefunManager.isItemSimilar(menu.getItemInSlot(slot), new ItemStack(Material.GRAVEL), true)) { + ItemStack output = randomizer.getRandom(); MachineRecipe r = new MachineRecipe(3 / getSpeed(), new ItemStack[0], new ItemStack[] {output}); - if (!fits(b, r.getOutput())) return; + if (!menu.fits(output, getOutputSlots())) return; + + menu.replaceExistingItem(slot, InvUtils.decreaseItem(menu.getItemInSlot(slot), 1)); + processing.put(b, r); + progress.put(b, r.getTicks()); + break; + } + else if (SlimefunManager.isItemSimilar(menu.getItemInSlot(slot), new ItemStack(Material.SOUL_SAND), true)) { + ItemStack output = randomizerNether.getRandom(); + + MachineRecipe r = new MachineRecipe(4 / getSpeed(), new ItemStack[0], new ItemStack[] {output}); + if (!menu.fits(output, getOutputSlots())) return; + menu.replaceExistingItem(slot, InvUtils.decreaseItem(menu.getItemInSlot(slot), 1)); processing.put(b, r); progress.put(b, r.getTicks()); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricPress.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricPress.java new file mode 100644 index 000000000..07b9c6ad1 --- /dev/null +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricPress.java @@ -0,0 +1,56 @@ +package me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric; + +import org.bukkit.Material; +import org.bukkit.inventory.ItemStack; + +import io.github.thebusybiscuit.cscorelib2.item.CustomItem; +import me.mrCookieSlime.Slimefun.Lists.RecipeType; +import me.mrCookieSlime.Slimefun.Lists.SlimefunItems; +import me.mrCookieSlime.Slimefun.Objects.Category; +import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.abstractItems.AContainer; +import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.abstractItems.MachineRecipe; +import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.interfaces.RecipeDisplayItem; +import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; + +public abstract class ElectricPress extends AContainer implements RecipeDisplayItem { + + public ElectricPress(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) { + super(category, item, recipeType, recipe); + } + + @Override + public void registerDefaultRecipes() { + registerRecipe(new MachineRecipe(4, new ItemStack[] {new CustomItem(SlimefunItems.STONE_CHUNK, 3)}, new ItemStack[] {new ItemStack(Material.COBBLESTONE)})); + registerRecipe(new MachineRecipe(4, new ItemStack[] {new ItemStack(Material.FLINT, 6)}, new ItemStack[] {new ItemStack(Material.COBBLESTONE)})); + + registerRecipe(new MachineRecipe(6, new ItemStack[] {SlimefunItems.COPPER_INGOT}, new ItemStack[] {new CustomItem(SlimefunItems.COPPER_WIRE, 3)})); + registerRecipe(new MachineRecipe(16, new ItemStack[] {new CustomItem(SlimefunItems.STEEL_INGOT, 8)}, new ItemStack[] {SlimefunItems.STEEL_PLATE})); + registerRecipe(new MachineRecipe(18, new ItemStack[] {new CustomItem(SlimefunItems.REINFORCED_ALLOY_INGOT, 8)}, new ItemStack[] {SlimefunItems.REINFORCED_PLATE})); + + registerRecipe(new MachineRecipe(8, new ItemStack[] {new ItemStack(Material.NETHER_WART)}, new ItemStack[] {new CustomItem(SlimefunItems.MAGIC_LUMP_1, 2)})); + registerRecipe(new MachineRecipe(10, new ItemStack[] {new CustomItem(SlimefunItems.MAGIC_LUMP_1, 4)}, new ItemStack[] {SlimefunItems.MAGIC_LUMP_2})); + registerRecipe(new MachineRecipe(12, new ItemStack[] {new CustomItem(SlimefunItems.MAGIC_LUMP_2, 4)}, new ItemStack[] {SlimefunItems.MAGIC_LUMP_3})); + + registerRecipe(new MachineRecipe(10, new ItemStack[] {new ItemStack(Material.ENDER_EYE)}, new ItemStack[] {new CustomItem(SlimefunItems.ENDER_LUMP_1, 2)})); + registerRecipe(new MachineRecipe(12, new ItemStack[] {new CustomItem(SlimefunItems.ENDER_LUMP_1, 4)}, new ItemStack[] {SlimefunItems.ENDER_LUMP_2})); + registerRecipe(new MachineRecipe(14, new ItemStack[] {new CustomItem(SlimefunItems.ENDER_LUMP_2, 4)}, new ItemStack[] {SlimefunItems.ENDER_LUMP_3})); + + registerRecipe(new MachineRecipe(18, new ItemStack[] {new CustomItem(SlimefunItems.TINY_URANIUM, 9)}, new ItemStack[] {SlimefunItems.SMALL_URANIUM})); + registerRecipe(new MachineRecipe(24, new ItemStack[] {new CustomItem(SlimefunItems.SMALL_URANIUM, 4)}, new ItemStack[] {SlimefunItems.URANIUM})); + } + + @Override + public String getInventoryTitle() { + return "&eElectric Press"; + } + + @Override + public ItemStack getProgressBar() { + return new ItemStack(Material.IRON_HOE); + } + + @Override + public String getMachineIdentifier() { + return "ELECTRIC_PRESS"; + } +} diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricSmeltery.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricSmeltery.java index b8abd4704..293597d5b 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricSmeltery.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricSmeltery.java @@ -58,7 +58,7 @@ public abstract class ElectricSmeltery extends AContainer { List slots = new ArrayList<>(); for (int slot : getInputSlots()) { - if (SlimefunManager.isItemSimiliar(menu.getItemInSlot(slot), item, true)) { + if (SlimefunManager.isItemSimilar(menu.getItemInSlot(slot), item, true)) { slots.add(slot); } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/FluidPump.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/FluidPump.java index f9da89eb2..d7a49a850 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/FluidPump.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/FluidPump.java @@ -93,7 +93,7 @@ public class FluidPump extends SlimefunItem implements InventoryBlock { if (output != null && ChargableBlock.getCharge(b) >= energyConsumption) { BlockMenu menu = BlockStorage.getInventory(b); for (int slot : getInputSlots()) { - if (SlimefunManager.isItemSimiliar(menu.getItemInSlot(slot), new ItemStack(Material.BUCKET), true)) { + if (SlimefunManager.isItemSimilar(menu.getItemInSlot(slot), new ItemStack(Material.BUCKET), true)) { if (!menu.fits(output, getOutputSlots())) return; ChargableBlock.addCharge(b, -energyConsumption); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/HeatedPressureChamber.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/HeatedPressureChamber.java index 1c67cd270..a56ce33d4 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/HeatedPressureChamber.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/HeatedPressureChamber.java @@ -62,7 +62,7 @@ public abstract class HeatedPressureChamber extends AContainer { List slots = new ArrayList<>(); for (int slot: getInputSlots()) { - if (SlimefunManager.isItemSimiliar(menu.getItemInSlot(slot), item, true)) { + if (SlimefunManager.isItemSimilar(menu.getItemInSlot(slot), item, true)) { slots.add(slot); } } @@ -180,7 +180,7 @@ public abstract class HeatedPressureChamber extends AContainer { for (MachineRecipe recipe: recipes) { for (ItemStack input: recipe.getInput()) { for (int slot: getInputSlots()) { - if (SlimefunManager.isItemSimiliar(menu.getItemInSlot(slot), input, true)) { + if (SlimefunManager.isItemSimilar(menu.getItemInSlot(slot), input, true)) { found.put(slot, input.getAmount()); break; } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/Refinery.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/Refinery.java index bd7c28231..1d582210a 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/Refinery.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/Refinery.java @@ -71,7 +71,7 @@ public abstract class Refinery extends AContainer implements RecipeDisplayItem { } else { for (int slot: getInputSlots()) { - if (SlimefunManager.isItemSimiliar(BlockStorage.getInventory(b).getItemInSlot(slot), SlimefunItems.BUCKET_OF_OIL, true)) { + if (SlimefunManager.isItemSimilar(BlockStorage.getInventory(b).getItemInSlot(slot), SlimefunItems.BUCKET_OF_OIL, true)) { MachineRecipe r = new MachineRecipe(40, new ItemStack[0], new ItemStack[] {SlimefunItems.BUCKET_OF_FUEL}); if (!fits(b, r.getOutput())) return; BlockStorage.getInventory(b).replaceExistingItem(slot, InvUtils.decreaseItem(BlockStorage.getInventory(b).getItemInSlot(slot), 1)); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/WitherAssembler.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/WitherAssembler.java index 1f2870d94..19000c38b 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/WitherAssembler.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/WitherAssembler.java @@ -98,7 +98,7 @@ public class WitherAssembler extends SlimefunItem { @Override public int[] getSlotsAccessedByItemTransport(BlockMenu menu, ItemTransportFlow flow, ItemStack item) { if (flow == ItemTransportFlow.INSERT) { - if (SlimefunManager.isItemSimiliar(item, new ItemStack(Material.SOUL_SAND), true)) return getSoulSandSlots(); + if (SlimefunManager.isItemSimilar(item, new ItemStack(Material.SOUL_SAND), true)) return getSoulSandSlots(); else return getWitherSkullSlots(); } else return new int[0]; @@ -194,7 +194,7 @@ public class WitherAssembler extends SlimefunItem { int skulls = 0; for (int slot : getSoulSandSlots()) { - if (SlimefunManager.isItemSimiliar(BlockStorage.getInventory(b).getItemInSlot(slot), new ItemStack(Material.SOUL_SAND), true)) { + if (SlimefunManager.isItemSimilar(BlockStorage.getInventory(b).getItemInSlot(slot), new ItemStack(Material.SOUL_SAND), true)) { soulsand = soulsand + BlockStorage.getInventory(b).getItemInSlot(slot).getAmount(); if (soulsand > 3) { soulsand = 4; @@ -204,7 +204,7 @@ public class WitherAssembler extends SlimefunItem { } for (int slot : getWitherSkullSlots()) { - if (SlimefunManager.isItemSimiliar(BlockStorage.getInventory(b).getItemInSlot(slot), new ItemStack(Material.WITHER_SKELETON_SKULL), true)) { + if (SlimefunManager.isItemSimilar(BlockStorage.getInventory(b).getItemInSlot(slot), new ItemStack(Material.WITHER_SKELETON_SKULL), true)) { skulls = skulls + BlockStorage.getInventory(b).getItemInSlot(slot).getAmount(); if (skulls > 2) { skulls = 3; @@ -215,7 +215,7 @@ public class WitherAssembler extends SlimefunItem { if (soulsand > 3 && skulls > 2) { for (int slot : getSoulSandSlots()) { - if (SlimefunManager.isItemSimiliar(BlockStorage.getInventory(b).getItemInSlot(slot), new ItemStack(Material.SOUL_SAND), true)) { + if (SlimefunManager.isItemSimilar(BlockStorage.getInventory(b).getItemInSlot(slot), new ItemStack(Material.SOUL_SAND), true)) { final int amount = BlockStorage.getInventory(b).getItemInSlot(slot).getAmount(); if (amount >= soulsand) { BlockStorage.getInventory(b).replaceExistingItem(slot, InvUtils.decreaseItem(BlockStorage.getInventory(b).getItemInSlot(slot), soulsand)); @@ -229,7 +229,7 @@ public class WitherAssembler extends SlimefunItem { } for (int slot : getWitherSkullSlots()) { - if (SlimefunManager.isItemSimiliar(BlockStorage.getInventory(b).getItemInSlot(slot), new ItemStack(Material.WITHER_SKELETON_SKULL), true)) { + if (SlimefunManager.isItemSimilar(BlockStorage.getInventory(b).getItemInSlot(slot), new ItemStack(Material.WITHER_SKELETON_SKULL), true)) { final int amount = BlockStorage.getInventory(b).getItemInSlot(slot).getAmount(); if (amount >= skulls) { BlockStorage.getInventory(b).replaceExistingItem(slot, InvUtils.decreaseItem(BlockStorage.getInventory(b).getItemInSlot(slot), skulls)); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/generators/BioGenerator.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/generators/BioGenerator.java index 281098806..d759788f2 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/generators/BioGenerator.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/generators/BioGenerator.java @@ -45,19 +45,20 @@ public abstract class BioGenerator extends AGenerator { registerFuel(new MachineFuel(20, new ItemStack(Material.DRIED_KELP_BLOCK))); registerFuel(new MachineFuel(1, new ItemStack(Material.SEAGRASS))); registerFuel(new MachineFuel(2, new ItemStack(Material.SEA_PICKLE))); + registerFuel(new MachineFuel(2, new ItemStack(Material.SWEET_BERRIES))); // Leaves - for(Material m: Tag.LEAVES.getValues()) { + for(Material m : Tag.LEAVES.getValues()) { registerFuel(new MachineFuel(1, new ItemStack(m))); } // Saplings - for (Material m: Tag.SAPLINGS.getValues()) { + for (Material m : Tag.SAPLINGS.getValues()) { registerFuel(new MachineFuel(1, new ItemStack(m))); } // Small Flowers (formally just dandelions and poppies. - for (Material m: Tag.SMALL_FLOWERS.getValues()) { + for (Material m : Tag.SMALL_FLOWERS.getValues()) { registerFuel(new MachineFuel(1, new ItemStack(m))); } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/generators/CoalGenerator.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/generators/CoalGenerator.java index 23aeb17ce..c049ff358 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/generators/CoalGenerator.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/generators/CoalGenerator.java @@ -22,17 +22,17 @@ public abstract class CoalGenerator extends AGenerator { registerFuel(new MachineFuel(12, new ItemStack(Material.BLAZE_ROD))); // Coals - for (Material mat: Tag.ITEMS_COALS.getValues()) { + for (Material mat : Tag.ITEMS_COALS.getValues()) { registerFuel(new MachineFuel(8, new ItemStack(mat))); } // Logs - for (Material mat: Tag.LOGS.getValues()) { + for (Material mat : Tag.LOGS.getValues()) { registerFuel(new MachineFuel(2, new ItemStack(mat))); } // Wooden Planks - for (Material mat: Tag.PLANKS.getValues()) { + for (Material mat : Tag.PLANKS.getValues()) { registerFuel(new MachineFuel(1, new ItemStack(mat))); } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/geo/GEOMiner.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/geo/GEOMiner.java index eabe919ab..3c70437be 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/geo/GEOMiner.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/geo/GEOMiner.java @@ -115,7 +115,6 @@ public abstract class GEOMiner extends AContainer implements InventoryBlock, Rec } } - if (displayRecipes.size() % 2 != 0) displayRecipes.add(null); return displayRecipes; } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/geo/OilPump.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/geo/OilPump.java index dd55c5df7..569230191 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/geo/OilPump.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/geo/OilPump.java @@ -101,7 +101,7 @@ public abstract class OilPump extends AContainer { if (supplies > 0) { for (int slot: getInputSlots()) { - if (SlimefunManager.isItemSimiliar(inv.getItemInSlot(slot), new ItemStack(Material.BUCKET), true)) { + if (SlimefunManager.isItemSimilar(inv.getItemInSlot(slot), new ItemStack(Material.BUCKET), true)) { MachineRecipe r = new MachineRecipe(26, new ItemStack[0], new ItemStack[] {SlimefunItems.BUCKET_OF_OIL}); if (!inv.fits(SlimefunItems.BUCKET_OF_OIL, getOutputSlots())) { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/ArmorForge.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/ArmorForge.java index e2f801e78..cf43a72ec 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/ArmorForge.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/ArmorForge.java @@ -44,7 +44,7 @@ public class ArmorForge extends MultiBlockMachine { for (int i = 0; i < inputs.size(); i++) { boolean craft = true; for (int j = 0; j < inv.getContents().length; j++) { - if (!SlimefunManager.isItemSimiliar(inv.getContents()[j], inputs.get(i)[j], true)) { + if (!SlimefunManager.isItemSimilar(inv.getContents()[j], inputs.get(i)[j], true)) { craft = false; break; } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/AutomatedPanningMachine.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/AutomatedPanningMachine.java index 0b4d262e4..36a564e17 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/AutomatedPanningMachine.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/AutomatedPanningMachine.java @@ -1,8 +1,5 @@ package me.mrCookieSlime.Slimefun.Objects.SlimefunItem.multiblocks; -import java.util.Random; -import java.util.concurrent.ThreadLocalRandom; - import org.bukkit.Effect; import org.bukkit.GameMode; import org.bukkit.Material; @@ -13,6 +10,7 @@ import org.bukkit.entity.Player; import org.bukkit.inventory.Inventory; import org.bukkit.inventory.ItemStack; +import io.github.thebusybiscuit.cscorelib2.collections.RandomizedSet; import io.github.thebusybiscuit.cscorelib2.inventory.ItemUtils; import io.github.thebusybiscuit.cscorelib2.scheduling.TaskQueue; import me.mrCookieSlime.Slimefun.SlimefunPlugin; @@ -23,19 +21,11 @@ import me.mrCookieSlime.Slimefun.api.Slimefun; public class AutomatedPanningMachine extends MultiBlockMachine { - // Gold Pan - private int chanceSiftedOre; - private int chanceFlint; - private int chanceClay; - private int chanceIronNuggets; + private final RandomizedSet randomizer = new RandomizedSet<>(); + private int weights; - // Nether Gold Pan - private int chanceQuartz; - private int chanceGoldNuggets; - private int chanceNetherWart; - private int chanceBlazePowder; - private int chanceGlowstoneDust; - private int chanceGhastTear; + private final RandomizedSet randomizerNether = new RandomizedSet<>(); + private int weightsNether; public AutomatedPanningMachine() { super( @@ -66,29 +56,51 @@ public class AutomatedPanningMachine extends MultiBlockMachine { String goldPan = "GOLD_PAN"; String netherGoldPan = "NETHER_GOLD_PAN"; - chanceSiftedOre = (int) Slimefun.getItemValue(goldPan, "chance.SIFTED_ORE"); - chanceClay = (int) Slimefun.getItemValue(goldPan, "chance.CLAY"); - chanceFlint = (int) Slimefun.getItemValue(goldPan, "chance.FLINT"); - chanceIronNuggets = (int) Slimefun.getItemValue(goldPan, "chance.IRON_NUGGET"); + add(false, SlimefunItems.SIFTED_ORE, (int) Slimefun.getItemValue(goldPan, "chance.SIFTED_ORE")); + add(false, new ItemStack(Material.CLAY_BALL), (int) Slimefun.getItemValue(goldPan, "chance.CLAY")); + add(false, new ItemStack(Material.FLINT), (int) Slimefun.getItemValue(goldPan, "chance.FLINT")); + add(false, new ItemStack(Material.IRON_NUGGET), (int) Slimefun.getItemValue(goldPan, "chance.IRON_NUGGET")); - chanceQuartz = (int) Slimefun.getItemValue(netherGoldPan, "chance.QUARTZ"); - chanceGoldNuggets = (int) Slimefun.getItemValue(netherGoldPan, "chance.GOLD_NUGGET"); - chanceNetherWart = (int) Slimefun.getItemValue(netherGoldPan, "chance.NETHER_WART"); - chanceBlazePowder = (int) Slimefun.getItemValue(netherGoldPan, "chance.BLAZE_POWDER"); - chanceGlowstoneDust = (int) Slimefun.getItemValue(netherGoldPan, "chance.GLOWSTONE_DUST"); - chanceGhastTear = (int) Slimefun.getItemValue(netherGoldPan, "chance.GHAST_TEAR"); + if (weights < 100) { + add(false, new ItemStack(Material.AIR), 100 - weights); + } + + add(true, new ItemStack(Material.QUARTZ), (int) Slimefun.getItemValue(netherGoldPan, "chance.QUARTZ")); + add(true, new ItemStack(Material.GOLD_NUGGET), (int) Slimefun.getItemValue(netherGoldPan, "chance.GOLD_NUGGET")); + add(true, new ItemStack(Material.NETHER_WART), (int) Slimefun.getItemValue(netherGoldPan, "chance.NETHER_WART")); + add(true, new ItemStack(Material.BLAZE_POWDER), (int) Slimefun.getItemValue(netherGoldPan, "chance.BLAZE_POWDER")); + add(true, new ItemStack(Material.GLOWSTONE_DUST), (int) Slimefun.getItemValue(netherGoldPan, "chance.GLOWSTONE_DUST")); + add(true, new ItemStack(Material.GHAST_TEAR), (int) Slimefun.getItemValue(netherGoldPan, "chance.GHAST_TEAR")); + + + if (weightsNether < 100) { + add(true, new ItemStack(Material.AIR), 100 - weightsNether); + } + } + + private void add(boolean nether, ItemStack item, int chance) { + if (nether) { + randomizerNether.add(item, chance); + weightsNether += chance; + } + else { + randomizer.add(item, chance); + weights += chance; + } } @Override public void onInteract(Player p, Block b) { final ItemStack input = p.getInventory().getItemInMainHand(); - if (SlimefunManager.isItemSimiliar(input, new ItemStack(Material.GRAVEL), true) || SlimefunManager.isItemSimiliar(input, new ItemStack(Material.SOUL_SAND), true)) { + if (SlimefunManager.isItemSimilar(input, new ItemStack(Material.GRAVEL), true) || SlimefunManager.isItemSimilar(input, new ItemStack(Material.SOUL_SAND), true)) { final Material block = input.getType(); - if (p.getGameMode() != GameMode.CREATIVE) ItemUtils.consumeItem(input, false); + if (p.getGameMode() != GameMode.CREATIVE) { + ItemUtils.consumeItem(input, false); + } - ItemStack output = getRandomDrop(ThreadLocalRandom.current(), block); + ItemStack output = getRandomDrop(block); TaskQueue queue = new TaskQueue(); queue.thenRepeatEvery(20, 5, () -> @@ -96,14 +108,14 @@ public class AutomatedPanningMachine extends MultiBlockMachine { ); queue.thenRun(20, () -> { - if (output != null) { + if (output.getType() != Material.AIR) { Inventory outputChest = findOutputChest(b.getRelative(BlockFace.DOWN), output); if (outputChest != null) { - outputChest.addItem(output); + outputChest.addItem(output.clone()); } else { - b.getWorld().dropItemNaturally(b.getLocation(), output); + b.getWorld().dropItemNaturally(b.getLocation(), output.clone()); } p.getWorld().playSound(p.getLocation(), Sound.ENTITY_ARROW_HIT_PLAYER, 1F, 1F); @@ -120,42 +132,15 @@ public class AutomatedPanningMachine extends MultiBlockMachine { } } - private ItemStack getRandomDrop(Random random, Material input) { + private ItemStack getRandomDrop(Material input) { if (input == Material.GRAVEL) { - if (random.nextInt(100) < chanceSiftedOre) { - return SlimefunItems.SIFTED_ORE; - } - else if (random.nextInt(100) < chanceClay) { - return new ItemStack(Material.CLAY_BALL); - } - else if (random.nextInt(100) < chanceFlint) { - return new ItemStack(Material.FLINT); - } - else if (random.nextInt(100) < chanceIronNuggets) { - return new ItemStack(Material.IRON_NUGGET); - } + return randomizer.getRandom(); } else if (input == Material.SOUL_SAND) { - if (random.nextInt(100) < chanceQuartz) { - return new ItemStack(Material.QUARTZ); - } - else if (random.nextInt(100) < chanceGoldNuggets) { - return new ItemStack(Material.GOLD_NUGGET); - } - else if (random.nextInt(100) < chanceNetherWart) { - return new ItemStack(Material.NETHER_WART); - } - else if (random.nextInt(100) < chanceBlazePowder) { - return new ItemStack(Material.BLAZE_POWDER); - } - else if (random.nextInt(100) < chanceGlowstoneDust) { - return new ItemStack(Material.GLOWSTONE_DUST); - } - else if (random.nextInt(100) < chanceGhastTear) { - return new ItemStack(Material.GHAST_TEAR); - } + return randomizerNether.getRandom(); } - return null; + + return new ItemStack(Material.AIR); } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/Compressor.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/Compressor.java index f2359207e..63294b1c5 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/Compressor.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/Compressor.java @@ -48,7 +48,7 @@ public class Compressor extends MultiBlockMachine { Inventory inv = disp.getInventory(); for (ItemStack current: inv.getContents()) { for (ItemStack convert: RecipeType.getRecipeInputs(this)) { - if (convert != null && SlimefunManager.isItemSimiliar(current, convert, true)) { + if (convert != null && SlimefunManager.isItemSimilar(current, convert, true)) { final ItemStack adding = RecipeType.getRecipeOutput(this, convert); Inventory outputInv = findOutputInventory(adding, dispBlock, inv); if (outputInv != null) { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/EnhancedCraftingTable.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/EnhancedCraftingTable.java index ad5e3781c..13bac965e 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/EnhancedCraftingTable.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/EnhancedCraftingTable.java @@ -55,9 +55,9 @@ public class EnhancedCraftingTable extends MultiBlockMachine { for (int i = 0; i < inputs.size(); i++) { boolean craft = true; for (int j = 0; j < inv.getContents().length; j++) { - if (!SlimefunManager.isItemSimiliar(inv.getContents()[j], inputs.get(i)[j], true)) { + if (!SlimefunManager.isItemSimilar(inv.getContents()[j], inputs.get(i)[j], true)) { if (SlimefunItem.getByItem(inputs.get(i)[j]) instanceof SlimefunBackpack) { - if (!SlimefunManager.isItemSimiliar(inv.getContents()[j], inputs.get(i)[j], false)) { + if (!SlimefunManager.isItemSimilar(inv.getContents()[j], inputs.get(i)[j], false)) { craft = false; break; } @@ -73,6 +73,7 @@ public class EnhancedCraftingTable extends MultiBlockMachine { final ItemStack adding = RecipeType.getRecipeOutputList(this, inputs.get(i)).clone(); if (Slimefun.hasUnlocked(p, adding, true)) { Inventory inv2 = Bukkit.createInventory(null, 9, "test"); + for (int j = 0; j < inv.getContents().length; j++) { inv2.setItem(j, inv.getContents()[j] != null ? (inv.getContents()[j].getAmount() > 1 ? new CustomItem(inv.getContents()[j], inv.getContents()[j].getAmount() - 1): null): null); } @@ -81,6 +82,7 @@ public class EnhancedCraftingTable extends MultiBlockMachine { if (outputInv != null) { SlimefunItem sfItem = SlimefunItem.getByItem(adding); + if (sfItem instanceof SlimefunBackpack) { ItemStack backpack = null; diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/GrindStone.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/GrindStone.java index 0b8b78692..22402962f 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/GrindStone.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/GrindStone.java @@ -31,10 +31,11 @@ public class GrindStone extends MultiBlockMachine { new ItemStack(Material.BLAZE_ROD), new ItemStack(Material.BLAZE_POWDER, 4), new ItemStack(Material.BONE), new ItemStack(Material.BONE_MEAL, 4), new ItemStack(Material.GRAVEL), new ItemStack(Material.FLINT), - new ItemStack(Material.NETHER_WART), new CustomItem(SlimefunItems.MAGIC_LUMP_1, 2), new ItemStack(Material.ENDER_EYE), new CustomItem(SlimefunItems.ENDER_LUMP_1, 2), new ItemStack(Material.COBBLESTONE), new ItemStack(Material.GRAVEL), - new ItemStack(Material.WHEAT), SlimefunItems.WHEAT_FLOUR, + new ItemStack(Material.ANDESITE), new ItemStack(Material.GRAVEL), + new ItemStack(Material.DIORITE), new ItemStack(Material.GRAVEL), + new ItemStack(Material.GRANITE), new ItemStack(Material.GRAVEL), new ItemStack(Material.DIRT), SlimefunItems.STONE_CHUNK, new ItemStack(Material.SANDSTONE), new ItemStack(Material.SAND, 4), new ItemStack(Material.RED_SANDSTONE), new ItemStack(Material.RED_SAND, 4) @@ -56,7 +57,7 @@ public class GrindStone extends MultiBlockMachine { for (ItemStack current: inv.getContents()) { for (ItemStack convert: RecipeType.getRecipeInputs(this)) { - if (convert != null && SlimefunManager.isItemSimiliar(current, convert, true)) { + if (convert != null && SlimefunManager.isItemSimilar(current, convert, true)) { ItemStack output = RecipeType.getRecipeOutput(this, convert); Inventory outputInv = findOutputInventory(output, dispBlock, inv); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/Juicer.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/Juicer.java index 8c7b665f9..274076b2a 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/Juicer.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/Juicer.java @@ -45,7 +45,7 @@ public class Juicer extends MultiBlockMachine { Inventory inv = disp.getInventory(); for (ItemStack current: inv.getContents()) { for (ItemStack convert: RecipeType.getRecipeInputs(this)) { - if (convert != null && SlimefunManager.isItemSimiliar(current, convert, true)) { + if (convert != null && SlimefunManager.isItemSimilar(current, convert, true)) { ItemStack adding = RecipeType.getRecipeOutput(this, convert); Inventory outputInv = findOutputInventory(adding, dispBlock, inv); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/MagicWorkbench.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/MagicWorkbench.java index 16e721648..e6dbc03fb 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/MagicWorkbench.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/MagicWorkbench.java @@ -58,9 +58,9 @@ public class MagicWorkbench extends MultiBlockMachine { for (int i = 0; i < inputs.size(); i++) { boolean craft = true; for (int j = 0; j < inv.getContents().length; j++) { - if (!SlimefunManager.isItemSimiliar(inv.getContents()[j], inputs.get(i)[j], true)) { + if (!SlimefunManager.isItemSimilar(inv.getContents()[j], inputs.get(i)[j], true)) { if (SlimefunItem.getByItem(inputs.get(i)[j]) instanceof SlimefunBackpack) { - if (!SlimefunManager.isItemSimiliar(inv.getContents()[j], inputs.get(i)[j], false)) { + if (!SlimefunManager.isItemSimilar(inv.getContents()[j], inputs.get(i)[j], false)) { craft = false; break; } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/OreCrusher.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/OreCrusher.java index 7c9459950..25963640d 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/OreCrusher.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/OreCrusher.java @@ -60,7 +60,7 @@ public class OreCrusher extends MultiBlockMachine { Inventory inv = disp.getInventory(); for (ItemStack current: inv.getContents()) { for (ItemStack convert: RecipeType.getRecipeInputs(this)) { - if (convert != null && SlimefunManager.isItemSimiliar(current, convert, true)) { + if (convert != null && SlimefunManager.isItemSimilar(current, convert, true)) { ItemStack adding = RecipeType.getRecipeOutput(this, convert); Inventory outputInv = findOutputInventory(adding, dispBlock, inv); if (outputInv != null) { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/OreWasher.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/OreWasher.java index ac749e265..56b055c4e 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/OreWasher.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/OreWasher.java @@ -50,7 +50,7 @@ public class OreWasher extends MultiBlockMachine { for (ItemStack current: inv.getContents()) { if (current != null) { - if (SlimefunManager.isItemSimiliar(current, SlimefunItems.SIFTED_ORE, true)) { + if (SlimefunManager.isItemSimilar(current, SlimefunItems.SIFTED_ORE, true)) { ItemStack adding = items[new Random().nextInt(items.length)]; Inventory outputInv = null; @@ -77,7 +77,7 @@ public class OreWasher extends MultiBlockMachine { return; } - else if (SlimefunManager.isItemSimiliar(current, new ItemStack(Material.SAND, 4), false)) { + else if (SlimefunManager.isItemSimilar(current, new ItemStack(Material.SAND, 4), false)) { ItemStack adding = SlimefunItems.SALT; Inventory outputInv = findOutputInventory(adding, dispBlock, inv); @@ -93,7 +93,7 @@ public class OreWasher extends MultiBlockMachine { return; } - else if (SlimefunManager.isItemSimiliar(current, SlimefunItems.PULVERIZED_ORE, true)) { + else if (SlimefunManager.isItemSimilar(current, SlimefunItems.PULVERIZED_ORE, true)) { ItemStack adding = SlimefunItems.PURE_ORE_CLUSTER; Inventory outputInv = findOutputInventory(adding, dispBlock, inv); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/PressureChamber.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/PressureChamber.java index 1f882c924..afb9a9cc5 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/PressureChamber.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/PressureChamber.java @@ -55,7 +55,7 @@ public class PressureChamber extends MultiBlockMachine { for (ItemStack current: inv.getContents()) { for (ItemStack convert: RecipeType.getRecipeInputs(this)) { - if (convert != null && SlimefunManager.isItemSimiliar(current, convert, true)) { + if (convert != null && SlimefunManager.isItemSimilar(current, convert, true)) { final ItemStack adding = RecipeType.getRecipeOutput(this, convert); Inventory outputInv = findOutputInventory(adding, dispBlock, inv); if (outputInv != null) { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/Smeltery.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/Smeltery.java index db3bd86c7..b9dd7578b 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/Smeltery.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/Smeltery.java @@ -73,11 +73,11 @@ public class Smeltery extends MultiBlockMachine { for (ItemStack converting: inputs.get(i)) { if (converting != null) { for (int j = 0; j < inv.getContents().length; j++) { - if (j == (inv.getContents().length - 1) && !SlimefunManager.isItemSimiliar(converting, inv.getContents()[j], true)) { + if (j == (inv.getContents().length - 1) && !SlimefunManager.isItemSimilar(converting, inv.getContents()[j], true)) { craft = false; break; } - else if (SlimefunManager.isItemSimiliar(inv.getContents()[j], converting, true)) break; + else if (SlimefunManager.isItemSimilar(inv.getContents()[j], converting, true)) break; } } } @@ -89,7 +89,7 @@ public class Smeltery extends MultiBlockMachine { if (outputInv != null) { for (ItemStack removing: inputs.get(i)) { if (removing != null) { - InvUtils.removeItem(inv, removing.getAmount(), true, stack -> SlimefunManager.isItemSimiliar(stack, removing, true)); + InvUtils.removeItem(inv, removing.getAmount(), true, stack -> SlimefunManager.isItemSimilar(stack, removing, true)); } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/tasks/ArmorTask.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/tasks/ArmorTask.java index f24049fab..4af0bdacc 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/tasks/ArmorTask.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/tasks/ArmorTask.java @@ -71,7 +71,7 @@ public class ArmorTask implements Runnable { } } - if (SlimefunManager.isItemSimiliar(p.getInventory().getHelmet(), SlimefunItems.SOLAR_HELMET, true) + if (SlimefunManager.isItemSimilar(p.getInventory().getHelmet(), SlimefunItems.SOLAR_HELMET, true) && Slimefun.hasUnlocked(p, SlimefunItem.getByID("SOLAR_HELMET"), true) && (p.getWorld().getTime() < 12300 || p.getWorld().getTime() > 23850) && p.getEyeLocation().getBlock().getLightFromSky() == 15) @@ -83,10 +83,10 @@ public class ArmorTask implements Runnable { if (SlimefunManager.containsSimilarItem(p.getInventory(), radioactive, true)) { // Check if player is wearing the hazmat suit // If so, break the loop - if (SlimefunManager.isItemSimiliar(SlimefunItems.SCUBA_HELMET, p.getInventory().getHelmet(), true) && - SlimefunManager.isItemSimiliar(SlimefunItems.HAZMATSUIT_CHESTPLATE, p.getInventory().getChestplate(), true) && - SlimefunManager.isItemSimiliar(SlimefunItems.HAZMATSUIT_LEGGINGS, p.getInventory().getLeggings(), true) && - SlimefunManager.isItemSimiliar(SlimefunItems.RUBBER_BOOTS, p.getInventory().getBoots(), true)) { + if (SlimefunManager.isItemSimilar(SlimefunItems.SCUBA_HELMET, p.getInventory().getHelmet(), true) && + SlimefunManager.isItemSimilar(SlimefunItems.HAZMATSUIT_CHESTPLATE, p.getInventory().getChestplate(), true) && + SlimefunManager.isItemSimilar(SlimefunItems.HAZMATSUIT_LEGGINGS, p.getInventory().getLeggings(), true) && + SlimefunManager.isItemSimilar(SlimefunItems.RUBBER_BOOTS, p.getInventory().getBoots(), true)) { break; } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Setup/CSCoreLibLoader.java b/src/main/java/me/mrCookieSlime/Slimefun/Setup/CSCoreLibLoader.java index 4f36b7fe8..1ff6d7349 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Setup/CSCoreLibLoader.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Setup/CSCoreLibLoader.java @@ -18,6 +18,7 @@ import com.google.gson.JsonArray; import com.google.gson.JsonObject; import com.google.gson.JsonParser; +@Deprecated public class CSCoreLibLoader { private Plugin plugin; diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Setup/MiscSetup.java b/src/main/java/me/mrCookieSlime/Slimefun/Setup/MiscSetup.java index 2e581ae3f..8bde5eac9 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Setup/MiscSetup.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Setup/MiscSetup.java @@ -177,15 +177,15 @@ public final class MiscSetup { for (ItemStack i: input) { if (i != null) { inputs.add(i); - if (SlimefunManager.isItemSimiliar(i, SlimefunItems.ALUMINUM_DUST, true)) dust = true; - if (SlimefunManager.isItemSimiliar(i, SlimefunItems.COPPER_DUST, true)) dust = true; - if (SlimefunManager.isItemSimiliar(i, SlimefunItems.GOLD_DUST, true)) dust = true; - if (SlimefunManager.isItemSimiliar(i, SlimefunItems.IRON_DUST, true)) dust = true; - if (SlimefunManager.isItemSimiliar(i, SlimefunItems.LEAD_DUST, true)) dust = true; - if (SlimefunManager.isItemSimiliar(i, SlimefunItems.MAGNESIUM_DUST, true)) dust = true; - if (SlimefunManager.isItemSimiliar(i, SlimefunItems.SILVER_DUST, true)) dust = true; - if (SlimefunManager.isItemSimiliar(i, SlimefunItems.TIN_DUST, true)) dust = true; - if (SlimefunManager.isItemSimiliar(i, SlimefunItems.ZINC_DUST, true)) dust = true; + if (SlimefunManager.isItemSimilar(i, SlimefunItems.ALUMINUM_DUST, true)) dust = true; + if (SlimefunManager.isItemSimilar(i, SlimefunItems.COPPER_DUST, true)) dust = true; + if (SlimefunManager.isItemSimilar(i, SlimefunItems.GOLD_DUST, true)) dust = true; + if (SlimefunManager.isItemSimilar(i, SlimefunItems.IRON_DUST, true)) dust = true; + if (SlimefunManager.isItemSimilar(i, SlimefunItems.LEAD_DUST, true)) dust = true; + if (SlimefunManager.isItemSimilar(i, SlimefunItems.MAGNESIUM_DUST, true)) dust = true; + if (SlimefunManager.isItemSimilar(i, SlimefunItems.SILVER_DUST, true)) dust = true; + if (SlimefunManager.isItemSimilar(i, SlimefunItems.TIN_DUST, true)) dust = true; + if (SlimefunManager.isItemSimilar(i, SlimefunItems.ZINC_DUST, true)) dust = true; } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Setup/ResearchSetup.java b/src/main/java/me/mrCookieSlime/Slimefun/Setup/ResearchSetup.java index 865f16dda..91bcb4254 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Setup/ResearchSetup.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Setup/ResearchSetup.java @@ -125,7 +125,7 @@ public final class ResearchSetup { Slimefun.registerResearch(new Research(122, "Armored Jet Boots", 27), SlimefunItems.ARMORED_JETBOOTS); Slimefun.registerResearch(new Research(123, "Seismic Axe", 29), SlimefunItems.SEISMIC_AXE); Slimefun.registerResearch(new Research(124, "Pickaxe of Vein Mining", 29), SlimefunItems.PICKAXE_OF_VEIN_MINING); - Slimefun.registerResearch(new Research(125, "Soulbound Weapons", 29), SlimefunItems.SOULBOUND_SWORD, SlimefunItems.SOULBOUND_BOW); + Slimefun.registerResearch(new Research(125, "Soulbound Weapons", 29), SlimefunItems.SOULBOUND_SWORD, SlimefunItems.SOULBOUND_BOW, SlimefunItems.SOULBOUND_TRIDENT); Slimefun.registerResearch(new Research(126, "Soulbound Tools", 29), SlimefunItems.SOULBOUND_PICKAXE, SlimefunItems.SOULBOUND_AXE, SlimefunItems.SOULBOUND_SHOVEL, SlimefunItems.SOULBOUND_HOE); Slimefun.registerResearch(new Research(127, "Soulbound Armor", 29), SlimefunItems.SOULBOUND_HELMET, SlimefunItems.SOULBOUND_CHESTPLATE, SlimefunItems.SOULBOUND_LEGGINGS, SlimefunItems.SOULBOUND_BOOTS); Slimefun.registerResearch(new Research(129, "Delicious Drinks", 29), SlimefunItems.JUICER, SlimefunItems.APPLE_JUICE, SlimefunItems.MELON_JUICE, SlimefunItems.CARROT_JUICE, SlimefunItems.PUMPKIN_JUICE, SlimefunItems.SWEET_BERRY_JUICE); @@ -247,5 +247,6 @@ public final class ResearchSetup { Slimefun.registerResearch(new Research(249, "Totem of Undying", 36), SlimefunItems.TOTEM_OF_UNDYING); Slimefun.registerResearch(new Research(250, "Charging Bench", 8), SlimefunItems.CHARGING_BENCH); Slimefun.registerResearch(new Research(251, "Nether Gold Pan", 8), SlimefunItems.NETHER_GOLD_PAN); + Slimefun.registerResearch(new Research(252, "Electric Press", 16), SlimefunItems.ELECTRIC_PRESS, SlimefunItems.ELECTRIC_PRESS_2); } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Setup/SlimefunManager.java b/src/main/java/me/mrCookieSlime/Slimefun/Setup/SlimefunManager.java index 8e1234779..289eed4fa 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Setup/SlimefunManager.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Setup/SlimefunManager.java @@ -2,6 +2,7 @@ package me.mrCookieSlime.Slimefun.Setup; import java.util.ArrayList; import java.util.List; +import java.util.Optional; import org.bukkit.ChatColor; import org.bukkit.Material; @@ -10,6 +11,7 @@ import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.ItemMeta; import org.bukkit.potion.PotionEffect; +import io.github.thebusybiscuit.cscorelib2.item.ImmutableItemMeta; import me.mrCookieSlime.EmeraldEnchants.EmeraldEnchants; import me.mrCookieSlime.EmeraldEnchants.ItemEnchantment; import me.mrCookieSlime.Slimefun.SlimefunPlugin; @@ -21,6 +23,7 @@ import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunArmorPiece; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.VanillaItem; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.interfaces.Soulbound; +import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public final class SlimefunManager { @@ -73,30 +76,80 @@ public final class SlimefunManager { } + @Deprecated public static boolean isItemSimiliar(ItemStack item, ItemStack sfitem, boolean lore) { + return isItemSimilar(item, sfitem, lore); + } + + public static boolean isItemSimilar(ItemStack item, ItemStack sfitem, boolean checkLore) { if (item == null) return sfitem == null; if (sfitem == null) return false; + + if (item instanceof SlimefunItemStack && sfitem instanceof SlimefunItemStack) { + return ((SlimefunItemStack) item).getItemID().equals(((SlimefunItemStack) sfitem).getItemID()); + } if (item.getType() == sfitem.getType() && item.getAmount() >= sfitem.getAmount()) { if (item.hasItemMeta() && sfitem.hasItemMeta()) { - if (item.getItemMeta().hasDisplayName() && sfitem.getItemMeta().hasDisplayName()) { - if (item.getItemMeta().getDisplayName().equals(sfitem.getItemMeta().getDisplayName())) { - if (lore) { - if (item.getItemMeta().hasLore() && sfitem.getItemMeta().hasLore()) { - return equalsLore(item.getItemMeta().getLore(), sfitem.getItemMeta().getLore()); + ItemMeta itemMeta = item.getItemMeta(); + ItemMeta sfitemMeta = sfitem.getItemMeta(); + + if (sfitem instanceof SlimefunItemStack) { + Optional id = SlimefunPlugin.getItemDataService().getItemData(itemMeta); + + if (id.isPresent()) { + return id.get().equals(((SlimefunItemStack) sfitem).getItemID()); + } + + ImmutableItemMeta meta = ((SlimefunItemStack) sfitem).getImmutableMeta(); + + Optional displayName = meta.getDisplayName(); + + if (itemMeta.hasDisplayName() && displayName.isPresent()) { + if (itemMeta.getDisplayName().equals(displayName.get())) { + Optional> itemLore = meta.getLore(); + + if (checkLore) { + if (itemMeta.hasLore() && itemLore.isPresent()) { + return equalsLore(itemMeta.getLore(), itemLore.get()); + } + else return !itemMeta.hasLore() && !itemLore.isPresent(); } - else return !item.getItemMeta().hasLore() && !sfitem.getItemMeta().hasLore(); + else return true; + } + else return false; + } + else if (!itemMeta.hasDisplayName() && !displayName.isPresent()) { + Optional> itemLore = meta.getLore(); + + if (checkLore) { + if (itemMeta.hasLore() && itemLore.isPresent()) { + return equalsLore(itemMeta.getLore(), itemLore.get()); + } + else return !itemMeta.hasLore() && !itemLore.isPresent(); } else return true; } else return false; } - else if (!item.getItemMeta().hasDisplayName() && !sfitem.getItemMeta().hasDisplayName()) { - if (lore) { - if (item.getItemMeta().hasLore() && sfitem.getItemMeta().hasLore()) { - return equalsLore(item.getItemMeta().getLore(), sfitem.getItemMeta().getLore()); + else if (itemMeta.hasDisplayName() && sfitemMeta.hasDisplayName()) { + if (itemMeta.getDisplayName().equals(sfitemMeta.getDisplayName())) { + if (checkLore) { + if (itemMeta.hasLore() && sfitemMeta.hasLore()) { + return equalsLore(itemMeta.getLore(), sfitemMeta.getLore()); + } + else return !itemMeta.hasLore() && !sfitemMeta.hasLore(); } - else return !item.getItemMeta().hasLore() && !sfitem.getItemMeta().hasLore(); + else return true; + } + else return false; + } + else if (!itemMeta.hasDisplayName() && !sfitemMeta.hasDisplayName()) { + if (checkLore) { + if (itemMeta.hasLore() && sfitemMeta.hasLore()) { + return equalsLore(itemMeta.getLore(), sfitemMeta.getLore()); + } + else return !itemMeta.hasLore() && !sfitemMeta.hasLore(); } else return true; } @@ -128,13 +181,15 @@ public final class SlimefunManager { StringBuilder string2 = new StringBuilder(); String colors = ChatColor.YELLOW.toString() + ChatColor.YELLOW.toString() + ChatColor.GRAY.toString(); - for (String string: lore) { + + for (String string : lore) { if (!string.equals(ChatColor.GRAY + "Soulbound") && !string.startsWith(colors)) string1.append("-NEW LINE-").append(string); } - for (String string: lore2) { + for (String string : lore2) { if (!string.equals(ChatColor.GRAY + "Soulbound") && !string.startsWith(colors)) string2.append("-NEW LINE-").append(string); } + return string1.toString().equals(string2.toString()); } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Setup/SlimefunSetup.java b/src/main/java/me/mrCookieSlime/Slimefun/Setup/SlimefunSetup.java index d0eac54c2..5dc2dbda1 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Setup/SlimefunSetup.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Setup/SlimefunSetup.java @@ -129,6 +129,7 @@ import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.Electric import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.ElectricIngotFactory; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.ElectricIngotPulverizer; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.ElectricOreGrinder; +import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.ElectricPress; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.ElectricSmeltery; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.ElectrifiedCrucible; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.ElevatorPlate; @@ -590,7 +591,7 @@ public final class SlimefunSetup { .register(true); new GrapplingHook(Categories.TOOLS, (SlimefunItemStack) SlimefunItems.GRAPPLING_HOOK, RecipeType.ENHANCED_CRAFTING_TABLE, - new ItemStack[] {null, SlimefunItems.HOOK, SlimefunItems.HOOK, null, SlimefunItems.CHAIN, SlimefunItems.HOOK, SlimefunItems.CHAIN, null, null}, + new ItemStack[] {null, null, SlimefunItems.HOOK, null, SlimefunItems.CHAIN, null, SlimefunItems.CHAIN, null, null}, new String[] {"despawn-seconds"}, new Object[] {60}) .register(true); @@ -610,7 +611,7 @@ public final class SlimefunSetup { @Override public boolean onRightClick(ItemUseEvent e, Player p, ItemStack item) { - if (SlimefunManager.isItemSimiliar(item, SlimefunItems.STAFF_WATER, true)) { + if (SlimefunManager.isItemSimilar(item, SlimefunItems.STAFF_WATER, true)) { p.setFireTicks(0); SlimefunPlugin.getLocal().sendMessage(p, "messages.fire-extinguish", true); return true; @@ -618,40 +619,42 @@ public final class SlimefunSetup { else return false; } }); + + String[] multiToolItems = new String[] {"PORTABLE_CRAFTER", "MAGIC_EYE_OF_ENDER", "STAFF_ELEMENTAL_WIND", "GRAPPLING_HOOK"}; new MultiTool((SlimefunItemStack) SlimefunItems.DURALUMIN_MULTI_TOOL, RecipeType.ENHANCED_CRAFTING_TABLE, new ItemStack[] {SlimefunItems.DURALUMIN_INGOT, null, SlimefunItems.DURALUMIN_INGOT, SlimefunItems.DURALUMIN_INGOT, SlimefunItems.SMALL_CAPACITOR, SlimefunItems.DURALUMIN_INGOT, null, SlimefunItems.DURALUMIN_INGOT, null}, - new String[] {"mode.0.enabled", "mode.0.name", "mode.0.item", "mode.1.enabled", "mode.1.name", "mode.1.item", "mode.2.enabled", "mode.2.name", "mode.2.item", "mode.3.enabled", "mode.3.name", "mode.3.item"}, new Object[] {true, "Portable Crafter", "PORTABLE_CRAFTER", true, "Magic Eye of Ender", "MAGIC_EYE_OF_ENDER", true, "Wind Staff", "STAFF_ELEMENTAL_WIND", true, "Grappling Hook", "GRAPPLING_HOOK"}) + multiToolItems) .register(true); new MultiTool((SlimefunItemStack) SlimefunItems.SOLDER_MULTI_TOOL, RecipeType.ENHANCED_CRAFTING_TABLE, new ItemStack[] {SlimefunItems.SOLDER_INGOT, null, SlimefunItems.SOLDER_INGOT, SlimefunItems.SOLDER_INGOT, SlimefunItems.SMALL_CAPACITOR, SlimefunItems.SOLDER_INGOT, null, SlimefunItems.SOLDER_INGOT, null}, - new String[] {"mode.0.enabled", "mode.0.name", "mode.0.item", "mode.1.enabled", "mode.1.name", "mode.1.item", "mode.2.enabled", "mode.2.name", "mode.2.item", "mode.3.enabled", "mode.3.name", "mode.3.item"}, new Object[] {true, "Portable Crafter", "PORTABLE_CRAFTER", true, "Magic Eye of Ender", "MAGIC_EYE_OF_ENDER", true, "Wind Staff", "STAFF_ELEMENTAL_WIND", true, "Grappling Hook", "GRAPPLING_HOOK"}) + multiToolItems) .register(true); new MultiTool((SlimefunItemStack) SlimefunItems.BILLON_MULTI_TOOL, RecipeType.ENHANCED_CRAFTING_TABLE, new ItemStack[] {SlimefunItems.BILLON_INGOT, null, SlimefunItems.BILLON_INGOT, SlimefunItems.BILLON_INGOT, SlimefunItems.SMALL_CAPACITOR, SlimefunItems.BILLON_INGOT, null, SlimefunItems.BILLON_INGOT, null}, - new String[] {"mode.0.enabled", "mode.0.name", "mode.0.item", "mode.1.enabled", "mode.1.name", "mode.1.item", "mode.2.enabled", "mode.2.name", "mode.2.item", "mode.3.enabled", "mode.3.name", "mode.3.item"}, new Object[] {true, "Portable Crafter", "PORTABLE_CRAFTER", true, "Magic Eye of Ender", "MAGIC_EYE_OF_ENDER", true, "Wind Staff", "STAFF_ELEMENTAL_WIND", true, "Grappling Hook", "GRAPPLING_HOOK"}) + multiToolItems) .register(true); new MultiTool((SlimefunItemStack) SlimefunItems.STEEL_MULTI_TOOL, RecipeType.ENHANCED_CRAFTING_TABLE, new ItemStack[] {SlimefunItems.STEEL_INGOT, null, SlimefunItems.STEEL_INGOT, SlimefunItems.STEEL_INGOT, SlimefunItems.SMALL_CAPACITOR, SlimefunItems.STEEL_INGOT, null, SlimefunItems.STEEL_INGOT, null}, - new String[] {"mode.0.enabled", "mode.0.name", "mode.0.item", "mode.1.enabled", "mode.1.name", "mode.1.item", "mode.2.enabled", "mode.2.name", "mode.2.item", "mode.3.enabled", "mode.3.name", "mode.3.item"}, new Object[] {true, "Portable Crafter", "PORTABLE_CRAFTER", true, "Magic Eye of Ender", "MAGIC_EYE_OF_ENDER", true, "Wind Staff", "STAFF_ELEMENTAL_WIND", true, "Grappling Hook", "GRAPPLING_HOOK"}) + multiToolItems) .register(true); new MultiTool((SlimefunItemStack) SlimefunItems.DAMASCUS_STEEL_MULTI_TOOL, RecipeType.ENHANCED_CRAFTING_TABLE, new ItemStack[] {SlimefunItems.DAMASCUS_STEEL_INGOT, null, SlimefunItems.DAMASCUS_STEEL_INGOT, SlimefunItems.DAMASCUS_STEEL_INGOT, SlimefunItems.SMALL_CAPACITOR, SlimefunItems.DAMASCUS_STEEL_INGOT, null, SlimefunItems.DAMASCUS_STEEL_INGOT, null}, - new String[] {"mode.0.enabled", "mode.0.name", "mode.0.item", "mode.1.enabled", "mode.1.name", "mode.1.item", "mode.2.enabled", "mode.2.name", "mode.2.item", "mode.3.enabled", "mode.3.name", "mode.3.item"}, new Object[] {true, "Portable Crafter", "PORTABLE_CRAFTER", true, "Magic Eye of Ender", "MAGIC_EYE_OF_ENDER", true, "Wind Staff", "STAFF_ELEMENTAL_WIND", true, "Grappling Hook", "GRAPPLING_HOOK"}) + multiToolItems) .register(true); new MultiTool((SlimefunItemStack) SlimefunItems.REINFORCED_ALLOY_MULTI_TOOL, RecipeType.ENHANCED_CRAFTING_TABLE, new ItemStack[] {SlimefunItems.REINFORCED_ALLOY_INGOT, null, SlimefunItems.REINFORCED_ALLOY_INGOT, SlimefunItems.REINFORCED_ALLOY_INGOT, SlimefunItems.MEDIUM_CAPACITOR, SlimefunItems.REINFORCED_ALLOY_INGOT, null, SlimefunItems.REINFORCED_ALLOY_INGOT, null}, - new String[] {"mode.0.enabled", "mode.0.name", "mode.0.item", "mode.1.enabled", "mode.1.name", "mode.1.item", "mode.2.enabled", "mode.2.name", "mode.2.item", "mode.3.enabled", "mode.3.name", "mode.3.item"}, new Object[] {true, "Portable Crafter", "PORTABLE_CRAFTER", true, "Magic Eye of Ender", "MAGIC_EYE_OF_ENDER", true, "Wind Staff", "STAFF_ELEMENTAL_WIND", true, "Grappling Hook", "GRAPPLING_HOOK"}) + multiToolItems) .register(true); new MultiTool((SlimefunItemStack) SlimefunItems.CARBONADO_MULTI_TOOL, RecipeType.ENHANCED_CRAFTING_TABLE, new ItemStack[] {SlimefunItems.CARBONADO, null, SlimefunItems.CARBONADO, SlimefunItems.CARBONADO, SlimefunItems.LARGE_CAPACITOR, SlimefunItems.CARBONADO, null, SlimefunItems.CARBONADO, null}, - new String[] {"mode.0.enabled", "mode.0.name", "mode.0.item", "mode.1.enabled", "mode.1.name", "mode.1.item", "mode.2.enabled", "mode.2.name", "mode.2.item", "mode.3.enabled", "mode.3.name", "mode.3.item", "mode.4.enabled", "mode.4.name", "mode.4.item"}, new Object[] {true, "Portable Crafter", "PORTABLE_CRAFTER", true, "Magic Eye of Ender", "MAGIC_EYE_OF_ENDER", true, "Wind Staff", "STAFF_ELEMENTAL_WIND", true, "Grappling Hook", "GRAPPLING_HOOK", true, "Gold Pan", "GOLD_PAN"}) + "PORTABLE_CRAFTER", "MAGIC_EYE_OF_ENDER", "STAFF_ELEMENTAL_WIND", "GRAPPLING_HOOK", "GOLD_PAN", "NETHER_GOLD_PAN") .register(true); new OreWasher().register(); @@ -893,7 +896,7 @@ public final class SlimefunSetup { @Override public boolean onRightClick(ItemUseEvent e, Player p, ItemStack item) { - if (SlimefunManager.isItemSimiliar(item, SlimefunItems.RAG, true)) { + if (SlimefunManager.isItemSimilar(item, SlimefunItems.RAG, true)) { if (p.getGameMode() != GameMode.CREATIVE) ItemUtils.consumeItem(item, false); p.getWorld().playEffect(p.getLocation(), Effect.STEP_SOUND, Material.WHITE_WOOL); p.addPotionEffect(new PotionEffect(PotionEffectType.HEAL, 1, 0)); @@ -911,7 +914,7 @@ public final class SlimefunSetup { @Override public boolean onRightClick(ItemUseEvent e, Player p, ItemStack item) { - if (SlimefunManager.isItemSimiliar(item, SlimefunItems.BANDAGE, true)) { + if (SlimefunManager.isItemSimilar(item, SlimefunItems.BANDAGE, true)) { if (p.getGameMode() != GameMode.CREATIVE) ItemUtils.consumeItem(item, false); p.getWorld().playEffect(p.getLocation(), Effect.STEP_SOUND, Material.WHITE_WOOL); p.addPotionEffect(new PotionEffect(PotionEffectType.HEAL, 1, 1)); @@ -929,7 +932,7 @@ public final class SlimefunSetup { @Override public boolean onRightClick(ItemUseEvent e, Player p, ItemStack item) { - if (SlimefunManager.isItemSimiliar(item, SlimefunItems.SPLINT, true)) { + if (SlimefunManager.isItemSimilar(item, SlimefunItems.SPLINT, true)) { if (p.getGameMode() != GameMode.CREATIVE) ItemUtils.consumeItem(item, false); p.getWorld().playSound(p.getLocation(), Sound.ENTITY_SKELETON_HURT, 1, 1); p.addPotionEffect(new PotionEffect(PotionEffectType.HEAL, 1, 0)); @@ -949,7 +952,7 @@ public final class SlimefunSetup { @Override public boolean onRightClick(ItemUseEvent e, Player p, ItemStack item) { - if (SlimefunManager.isItemSimiliar(item, SlimefunItems.VITAMINS, true)) { + if (SlimefunManager.isItemSimilar(item, SlimefunItems.VITAMINS, true)) { if (p.getGameMode() != GameMode.CREATIVE) ItemUtils.consumeItem(item, false); p.getWorld().playSound(p.getLocation(), Sound.ENTITY_GENERIC_EAT, 1, 1); if (p.hasPotionEffect(PotionEffectType.POISON)) p.removePotionEffect(PotionEffectType.POISON); @@ -974,7 +977,7 @@ public final class SlimefunSetup { @Override public boolean onConsume(PlayerItemConsumeEvent e, Player p, ItemStack item) { - if (SlimefunManager.isItemSimiliar(item, SlimefunItems.MEDICINE, true)) { + if (SlimefunManager.isItemSimilar(item, SlimefunItems.MEDICINE, true)) { if (p.hasPotionEffect(PotionEffectType.POISON)) p.removePotionEffect(PotionEffectType.POISON); if (p.hasPotionEffect(PotionEffectType.WITHER)) p.removePotionEffect(PotionEffectType.WITHER); if (p.hasPotionEffect(PotionEffectType.SLOW)) p.removePotionEffect(PotionEffectType.SLOW); @@ -1237,7 +1240,7 @@ public final class SlimefunSetup { .register(true); new SoulboundBackpack(36, Categories.PORTABLE, (SlimefunItemStack) SlimefunItems.BOUND_BACKPACK, - new ItemStack[] {SlimefunItems.ENDER_LUMP_2, null, SlimefunItems.ENDER_LUMP_2, SlimefunItems.ESSENCE_OF_AFTERLIFE, SlimefunItems.RADIANT_BACKPACK, SlimefunItems.ESSENCE_OF_AFTERLIFE, SlimefunItems.ENDER_LUMP_2, null, SlimefunItems.ENDER_LUMP_2}) + new ItemStack[] {SlimefunItems.ENDER_LUMP_2, null, SlimefunItems.ENDER_LUMP_2, SlimefunItems.ESSENCE_OF_AFTERLIFE, SlimefunItems.WOVEN_BACKPACK, SlimefunItems.ESSENCE_OF_AFTERLIFE, SlimefunItems.ENDER_LUMP_2, null, SlimefunItems.ENDER_LUMP_2}) .register(true); new JetBoots((SlimefunItemStack) SlimefunItems.DURALUMIN_JETBOOTS, @@ -1291,6 +1294,10 @@ public final class SlimefunSetup { new SoulboundItem(Categories.WEAPONS, (SlimefunItemStack) SlimefunItems.SOULBOUND_SWORD, new ItemStack[] {null, SlimefunItems.ESSENCE_OF_AFTERLIFE, null, null, new ItemStack(Material.DIAMOND_SWORD), null, null, SlimefunItems.ESSENCE_OF_AFTERLIFE, null}) .register(true); + + new SoulboundItem(Categories.WEAPONS, (SlimefunItemStack) SlimefunItems.SOULBOUND_TRIDENT, + new ItemStack[] {null, SlimefunItems.ESSENCE_OF_AFTERLIFE, null, null, new ItemStack(Material.TRIDENT), null, null, SlimefunItems.ESSENCE_OF_AFTERLIFE, null}) + .register(true); new SoulboundItem(Categories.WEAPONS, (SlimefunItemStack) SlimefunItems.SOULBOUND_BOW, new ItemStack[] {null, SlimefunItems.ESSENCE_OF_AFTERLIFE, null, null, new ItemStack(Material.BOW), null, null, SlimefunItems.ESSENCE_OF_AFTERLIFE, null}) @@ -1361,7 +1368,7 @@ public final class SlimefunSetup { new SlimefunItem(Categories.MAGIC, (SlimefunItemStack) SlimefunItems.REPAIRED_SPAWNER, RecipeType.ANCIENT_ALTAR, new ItemStack[] {SlimefunItems.RUNE_ENDER, new CustomItem(Material.EXPERIENCE_BOTTLE, "&aFlask of Knowledge"), SlimefunItems.ESSENCE_OF_AFTERLIFE, new CustomItem(Material.EXPERIENCE_BOTTLE, "&aFlask of Knowledge"), SlimefunItems.BROKEN_SPAWNER, new CustomItem(Material.EXPERIENCE_BOTTLE, "&aFlask of Knowledge"), SlimefunItems.ESSENCE_OF_AFTERLIFE, new CustomItem(Material.EXPERIENCE_BOTTLE, "&aFlask of Knowledge"), SlimefunItems.RUNE_ENDER}) .register(true, (BlockPlaceHandler) (e, item) -> { - if (SlimefunManager.isItemSimiliar(item, SlimefunItems.REPAIRED_SPAWNER, false)) { + if (SlimefunManager.isItemSimilar(item, SlimefunItems.REPAIRED_SPAWNER, false)) { EntityType type = null; for (String line: item.getItemMeta().getLore()) { @@ -1466,7 +1473,7 @@ public final class SlimefunSetup { @Override public boolean onHit(EntityDamageByEntityEvent e, LivingEntity n) { - if (SlimefunManager.isItemSimiliar(SlimefunPlugin.getUtilities().arrows.get(e.getDamager().getUniqueId()), SlimefunItems.EXPLOSIVE_BOW, true)) { + if (SlimefunManager.isItemSimilar(SlimefunPlugin.getUtilities().arrows.get(e.getDamager().getUniqueId()), SlimefunItems.EXPLOSIVE_BOW, true)) { Vector vector = n.getVelocity(); vector.setY(0.6); n.setVelocity(vector); @@ -1484,7 +1491,7 @@ public final class SlimefunSetup { @Override public boolean onHit(EntityDamageByEntityEvent e, LivingEntity n) { - if (SlimefunManager.isItemSimiliar(SlimefunPlugin.getUtilities().arrows.get(e.getDamager().getUniqueId()), SlimefunItems.ICY_BOW, true)) { + if (SlimefunManager.isItemSimilar(SlimefunPlugin.getUtilities().arrows.get(e.getDamager().getUniqueId()), SlimefunItems.ICY_BOW, true)) { n.getWorld().playEffect(n.getLocation(), Effect.STEP_SOUND, Material.ICE); n.getWorld().playEffect(n.getEyeLocation(), Effect.STEP_SOUND, Material.ICE); n.addPotionEffect(new PotionEffect(PotionEffectType.SLOW, 20 * 2, 10)); @@ -1552,7 +1559,7 @@ public final class SlimefunSetup { .register(true); new SlimefunItem(Categories.CHRISTMAS, SlimefunItems.CHRISTMAS_CHOCOLATE_APPLE, "CHRISTMAS_CHOCOLATE_APPLE", RecipeType.ENHANCED_CRAFTING_TABLE, - new ItemStack[] {null, new ItemStack(Material.COCOA_BEANS), null, null, new ItemStack(Material.APPLE), null, null, new ItemStack(Material.STICK), null}, new CustomItem(SlimefunItems.CHRISTMAS_CARAMEL_APPLE, 2)) + new ItemStack[] {null, new ItemStack(Material.COCOA_BEANS), null, null, new ItemStack(Material.APPLE), null, null, new ItemStack(Material.STICK), null}, new CustomItem(SlimefunItems.CHRISTMAS_CHOCOLATE_APPLE, 2)) .register(true); new SlimefunItem(Categories.CHRISTMAS, SlimefunItems.CHRISTMAS_PRESENT, "CHRISTMAS_PRESENT", RecipeType.MAGIC_WORKBENCH, @@ -1573,7 +1580,7 @@ public final class SlimefunSetup { @Override public boolean onRightClick(ItemUseEvent e, Player p, ItemStack item) { - if (SlimefunManager.isItemSimiliar(item, SlimefunItems.EASTER_EGG, true)) { + if (SlimefunManager.isItemSimilar(item, SlimefunItems.EASTER_EGG, true)) { e.setCancelled(true); if (p.getGameMode() != GameMode.CREATIVE) ItemUtils.consumeItem(item, false); FireworkShow.launchRandom(e.getPlayer(), 2); @@ -2055,6 +2062,36 @@ public final class SlimefunSetup { new ItemStack[] {null, null, null, SlimefunItems.HEATING_COIL, new ItemStack(Material.SMOKER), SlimefunItems.HEATING_COIL, null, new ItemStack(Material.CAMPFIRE), null}) .registerChargeableBlock(true, 128); + new ElectricPress(Categories.ELECTRICITY, (SlimefunItemStack) SlimefunItems.ELECTRIC_PRESS, RecipeType.ENHANCED_CRAFTING_TABLE, + new ItemStack[] {new ItemStack(Material.PISTON), SlimefunItems.ELECTRIC_MOTOR, new ItemStack(Material.PISTON), null, SlimefunItems.MEDIUM_CAPACITOR, null, SlimefunItems.DAMASCUS_STEEL_INGOT, SlimefunItems.DAMASCUS_STEEL_INGOT, SlimefunItems.DAMASCUS_STEEL_INGOT}) { + + @Override + public int getEnergyConsumption() { + return 8; + } + + @Override + public int getSpeed() { + return 1; + } + + }.registerChargeableBlock(true, 256); + + new ElectricPress(Categories.ELECTRICITY, (SlimefunItemStack) SlimefunItems.ELECTRIC_PRESS_2, RecipeType.ENHANCED_CRAFTING_TABLE, + new ItemStack[] {new ItemStack(Material.STICKY_PISTON), SlimefunItems.ELECTRIC_PRESS, new ItemStack(Material.STICKY_PISTON), SlimefunItems.DAMASCUS_STEEL_INGOT, SlimefunItems.BIG_CAPACITOR, SlimefunItems.DAMASCUS_STEEL_INGOT, SlimefunItems.DAMASCUS_STEEL_INGOT, SlimefunItems.DAMASCUS_STEEL_INGOT, SlimefunItems.DAMASCUS_STEEL_INGOT}) { + + @Override + public int getEnergyConsumption() { + return 20; + } + + @Override + public int getSpeed() { + return 3; + } + + }.registerChargeableBlock(true, 1024); + new AutoEnchanter(Categories.ELECTRICITY, (SlimefunItemStack) SlimefunItems.AUTO_ENCHANTER, RecipeType.ENHANCED_CRAFTING_TABLE, new ItemStack[] {null, new ItemStack(Material.ENCHANTING_TABLE), null, SlimefunItems.CARBONADO, SlimefunItems.ELECTRIC_MOTOR, SlimefunItems.CARBONADO, SlimefunItems.WITHER_PROOF_OBSIDIAN, SlimefunItems.WITHER_PROOF_OBSIDIAN, SlimefunItems.WITHER_PROOF_OBSIDIAN}) .registerChargeableBlock(true, 128); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Setup/WikiSetup.java b/src/main/java/me/mrCookieSlime/Slimefun/Setup/WikiSetup.java index b69574139..b87c74cf5 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Setup/WikiSetup.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Setup/WikiSetup.java @@ -27,7 +27,7 @@ public final class WikiSetup { JsonElement element = parser.parse(reader.lines().collect(Collectors.joining(""))); JsonObject json = element.getAsJsonObject(); - for (Map.Entry entry: json.entrySet()) { + for (Map.Entry entry : json.entrySet()) { SlimefunItem item = SlimefunItem.getByID(entry.getKey()); if (item != null) { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/SlimefunGuide.java b/src/main/java/me/mrCookieSlime/Slimefun/SlimefunGuide.java index 95bd81c31..803f5daad 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/SlimefunGuide.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/SlimefunGuide.java @@ -12,16 +12,16 @@ import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.ItemMeta; import io.github.thebusybiscuit.cscorelib2.chat.ChatColors; +import io.github.thebusybiscuit.slimefun4.core.guide.BookSlimefunGuide; +import io.github.thebusybiscuit.slimefun4.core.guide.ChestSlimefunGuide; +import io.github.thebusybiscuit.slimefun4.core.guide.ISlimefunGuide; +import io.github.thebusybiscuit.slimefun4.core.guide.SlimefunGuideLayout; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.Item.CustomItem; import me.mrCookieSlime.Slimefun.Objects.Category; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem; import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; import me.mrCookieSlime.Slimefun.api.PlayerProfile; import me.mrCookieSlime.Slimefun.api.Slimefun; -import me.mrCookieSlime.Slimefun.guides.BookSlimefunGuide; -import me.mrCookieSlime.Slimefun.guides.ChestSlimefunGuide; -import me.mrCookieSlime.Slimefun.guides.ISlimefunGuide; -import me.mrCookieSlime.Slimefun.guides.SlimefunGuideLayout; public final class SlimefunGuide { @@ -88,13 +88,13 @@ public final class SlimefunGuide { } public static void openGuide(Player p, ItemStack guide) { - if (SlimefunManager.isItemSimiliar(guide, getItem(SlimefunGuideLayout.CHEST), true)) { + if (SlimefunManager.isItemSimilar(guide, getItem(SlimefunGuideLayout.CHEST), true)) { openGuide(p, SlimefunGuideLayout.CHEST); } - else if (SlimefunManager.isItemSimiliar(guide, getItem(SlimefunGuideLayout.BOOK), true)) { + else if (SlimefunManager.isItemSimilar(guide, getItem(SlimefunGuideLayout.BOOK), true)) { openGuide(p, SlimefunGuideLayout.BOOK); } - else if (SlimefunManager.isItemSimiliar(guide, getItem(SlimefunGuideLayout.CHEAT_SHEET), true)) { + else if (SlimefunManager.isItemSimilar(guide, getItem(SlimefunGuideLayout.CHEAT_SHEET), true)) { openGuide(p, SlimefunGuideLayout.CHEAT_SHEET); } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/SlimefunPlugin.java b/src/main/java/me/mrCookieSlime/Slimefun/SlimefunPlugin.java index 770617a73..8b5f18f23 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/SlimefunPlugin.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/SlimefunPlugin.java @@ -19,6 +19,13 @@ import io.github.thebusybiscuit.cscorelib2.reflection.ReflectionUtils; import io.github.thebusybiscuit.cscorelib2.updater.BukkitUpdater; import io.github.thebusybiscuit.cscorelib2.updater.GitHubBuildsUpdater; import io.github.thebusybiscuit.cscorelib2.updater.Updater; +import io.github.thebusybiscuit.slimefun4.core.services.BlockDataService; +import io.github.thebusybiscuit.slimefun4.core.services.CustomItemDataService; +import io.github.thebusybiscuit.slimefun4.core.services.CustomTextureService; +import io.github.thebusybiscuit.slimefun4.core.services.MetricsService; +import io.github.thebusybiscuit.slimefun4.core.services.github.Contributor; +import io.github.thebusybiscuit.slimefun4.core.services.github.GitHubConnector; +import io.github.thebusybiscuit.slimefun4.core.services.github.GitHubService; import me.mrCookieSlime.CSCoreLibPlugin.CSCoreLib; import me.mrCookieSlime.CSCoreLibPlugin.PluginUtils; import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config; @@ -52,9 +59,6 @@ import me.mrCookieSlime.Slimefun.autosave.PlayerAutoSaver; import me.mrCookieSlime.Slimefun.commands.SlimefunCommand; import me.mrCookieSlime.Slimefun.commands.SlimefunTabCompleter; import me.mrCookieSlime.Slimefun.hooks.SlimefunHooks; -import me.mrCookieSlime.Slimefun.hooks.github.Contributor; -import me.mrCookieSlime.Slimefun.hooks.github.GitHubConnector; -import me.mrCookieSlime.Slimefun.hooks.github.GitHubSetup; import me.mrCookieSlime.Slimefun.listeners.AndroidKillingListener; import me.mrCookieSlime.Slimefun.listeners.ArmorListener; import me.mrCookieSlime.Slimefun.listeners.AutonomousToolsListener; @@ -74,9 +78,6 @@ import me.mrCookieSlime.Slimefun.listeners.TalismanListener; import me.mrCookieSlime.Slimefun.listeners.TeleporterListener; import me.mrCookieSlime.Slimefun.listeners.ToolListener; import me.mrCookieSlime.Slimefun.listeners.WorldListener; -import me.mrCookieSlime.Slimefun.services.CustomItemDataService; -import me.mrCookieSlime.Slimefun.services.CustomTextureService; -import me.mrCookieSlime.Slimefun.services.MetricsService; import me.mrCookieSlime.Slimefun.utils.Settings; import me.mrCookieSlime.Slimefun.utils.Utilities; @@ -88,6 +89,8 @@ public final class SlimefunPlugin extends JavaPlugin { private final CustomItemDataService itemDataService = new CustomItemDataService(this, "slimefun_item"); private final CustomTextureService textureService = new CustomTextureService(this); + private final BlockDataService blockDataService = new BlockDataService(this, "slimefun_block"); + private final GitHubService gitHubService = new GitHubService("TheBusyBiscuit/Slimefun4"); private TickerTask ticker; private SlimefunLocalization local; @@ -103,7 +106,7 @@ public final class SlimefunPlugin extends JavaPlugin { private SlimefunHooks hooks; // Supported Versions of Minecraft - private final String[] supported = {"v1_14_"}; + private final String[] supported = {"v1_14_", "v1_15_"}; @Override public void onEnable() { @@ -216,12 +219,12 @@ public final class SlimefunPlugin extends JavaPlugin { } MiscSetup.loadDescriptions(); - - settings.researchesEnabled = getResearchCfg().getBoolean("enable-researching"); - settings.smelteryFireBreakChance = (int) Slimefun.getItemValue("SMELTERY", "chance.fireBreak"); getLogger().log(Level.INFO, "Loading Researches..."); ResearchSetup.setupResearches(); + + settings.researchesEnabled = getResearchCfg().getBoolean("enable-researching"); + settings.smelteryFireBreakChance = (int) Slimefun.getItemValue("SMELTERY", "chance.fireBreak"); MiscSetup.setupMisc(); WikiSetup.addWikiPages(this); @@ -235,8 +238,7 @@ public final class SlimefunPlugin extends JavaPlugin { OreGenSystem.registerResource(new UraniumResource()); // Setting up GitHub Connectors... - - GitHubSetup.setup(); + gitHubService.connect(config.getBoolean("options.print-out-github-data-retrieving")); // All Slimefun Listeners new ArmorListener(this); @@ -307,15 +309,13 @@ public final class SlimefunPlugin extends JavaPlugin { }, 100L, config.getInt("URID.custom-ticker-delay")); getServer().getScheduler().runTaskTimerAsynchronously(this, () -> { - utilities.connectors.forEach(GitHubConnector::pullFile); - - for (Contributor contributor: utilities.contributors.values()) { + gitHubService.getConnectors().forEach(GitHubConnector::pullFile); + + for (Contributor contributor : gitHubService.getContributors().values()) { if (!contributor.hasTexture()) { - String name = contributor.getName(); - try { - Optional uuid = MinecraftAccount.getUUID(name); - + Optional uuid = MinecraftAccount.getUUID(contributor.getMinecraftName()); + if (uuid.isPresent()) { Optional skin = MinecraftAccount.getSkin(uuid.get()); contributor.setTexture(skin); @@ -324,6 +324,10 @@ public final class SlimefunPlugin extends JavaPlugin { contributor.setTexture(Optional.empty()); } } + catch(IllegalArgumentException x) { + // There cannot be a texture found because it is not a valid MC username + contributor.setTexture(Optional.empty()); + } catch(TooManyRequestsException x) { break; } @@ -480,5 +484,13 @@ public final class SlimefunPlugin extends JavaPlugin { public static CustomTextureService getItemTextureService() { return instance.textureService; } + + public static BlockDataService getBlockDataService() { + return instance.blockDataService; + } + + public static GitHubService getGitHubService() { + return instance.gitHubService; + } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/ancient_altar/AncientAltarListener.java b/src/main/java/me/mrCookieSlime/Slimefun/ancient_altar/AncientAltarListener.java index 26608c493..6574d838b 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/ancient_altar/AncientAltarListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/ancient_altar/AncientAltarListener.java @@ -28,7 +28,6 @@ import org.bukkit.util.Vector; import io.github.thebusybiscuit.cscorelib2.inventory.ItemUtils; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.Item.CustomItem; -import me.mrCookieSlime.CSCoreLibPlugin.general.String.StringUtils; import me.mrCookieSlime.Slimefun.SlimefunPlugin; import me.mrCookieSlime.Slimefun.Lists.SlimefunItems; import me.mrCookieSlime.Slimefun.api.BlockStorage; @@ -163,7 +162,7 @@ public class AncientAltarListener implements Listener { public static ItemStack fixItemStack(ItemStack itemStack, String customName) { ItemStack stack = itemStack.clone(); - if (customName.equals(StringUtils.formatItemName(new ItemStack(itemStack.getType()), false))) { + if (customName.equals(ItemUtils.getItemName(new ItemStack(itemStack.getType())))) { ItemMeta im = stack.getItemMeta(); im.setDisplayName(null); stack.setItemMeta(im); @@ -192,7 +191,7 @@ public class AncientAltarListener implements Listener { ItemUtils.consumeItem(hand, false); } - String nametag = StringUtils.formatItemName(stack, false); + String nametag = ItemUtils.getItemName(stack); Item entity = b.getWorld().dropItem(b.getLocation().add(0.5, 1.2, 0.5), new CustomItem(stack, "&5&dALTAR &3Probe - &e" + System.nanoTime())); entity.setVelocity(new Vector(0, 0.1, 0)); entity.setMetadata("no_pickup", new FixedMetadataValue(SlimefunPlugin.instance, "altar_item")); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/ancient_altar/Pedestals.java b/src/main/java/me/mrCookieSlime/Slimefun/ancient_altar/Pedestals.java index 7b23a31b2..130b13b3a 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/ancient_altar/Pedestals.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/ancient_altar/Pedestals.java @@ -52,7 +52,7 @@ public final class Pedestals { public static ItemStack getRecipeOutput(ItemStack catalyst, List input) { if (input.size() != 8) return null; - if (SlimefunManager.isItemSimiliar(catalyst, SlimefunItems.BROKEN_SPAWNER, false)) { + if (SlimefunManager.isItemSimilar(catalyst, SlimefunItems.BROKEN_SPAWNER, false)) { if (checkRecipe(SlimefunItems.BROKEN_SPAWNER, input) == null) return null; final ItemStack spawner = SlimefunItems.REPAIRED_SPAWNER.clone(); ItemMeta im = spawner.getItemMeta(); @@ -66,11 +66,11 @@ public final class Pedestals { private static ItemStack checkRecipe(ItemStack catalyst, List items) { for (AltarRecipe recipe: SlimefunPlugin.getUtilities().altarRecipes) { - if (SlimefunManager.isItemSimiliar(catalyst, recipe.getCatalyst(), true)) { + if (SlimefunManager.isItemSimilar(catalyst, recipe.getCatalyst(), true)) { for (int i = 0; i < 8; i++) { - if (SlimefunManager.isItemSimiliar(items.get(i), recipe.getInput().get(0), true)) { + if (SlimefunManager.isItemSimilar(items.get(i), recipe.getInput().get(0), true)) { for (int j = 1; j < 8; j++) { - if (!SlimefunManager.isItemSimiliar(items.get((i + j) % items.size()), recipe.getInput().get(j), true)) { + if (!SlimefunManager.isItemSimilar(items.get((i + j) % items.size()), recipe.getInput().get(j), true)) { break; } else if (j == 7) { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/androids/AndroidObject.java b/src/main/java/me/mrCookieSlime/Slimefun/androids/AndroidEntity.java similarity index 60% rename from src/main/java/me/mrCookieSlime/Slimefun/androids/AndroidObject.java rename to src/main/java/me/mrCookieSlime/Slimefun/androids/AndroidEntity.java index 9f4d60d25..e3ad8fbe6 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/androids/AndroidObject.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/androids/AndroidEntity.java @@ -2,12 +2,12 @@ package me.mrCookieSlime.Slimefun.androids; import org.bukkit.block.Block; -public class AndroidObject { +public class AndroidEntity { - private ProgrammableAndroid android; - private Block b; + private final ProgrammableAndroid android; + private final Block b; - public AndroidObject(ProgrammableAndroid android, Block b) { + public AndroidEntity(ProgrammableAndroid android, Block b) { this.android = android; this.b = b; } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/androids/ProgrammableAndroid.java b/src/main/java/me/mrCookieSlime/Slimefun/androids/ProgrammableAndroid.java index 837a33a0b..719d6b028 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/androids/ProgrammableAndroid.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/androids/ProgrammableAndroid.java @@ -11,6 +11,7 @@ import java.util.Optional; import java.util.Random; import java.util.Set; import java.util.UUID; +import java.util.concurrent.ThreadLocalRandom; import java.util.function.Predicate; import java.util.logging.Level; @@ -39,10 +40,13 @@ import org.bukkit.metadata.FixedMetadataValue; import io.github.thebusybiscuit.cscorelib2.blocks.Vein; import io.github.thebusybiscuit.cscorelib2.chat.ChatInput; +import io.github.thebusybiscuit.cscorelib2.collections.RandomizedSet; +import io.github.thebusybiscuit.cscorelib2.config.Config; import io.github.thebusybiscuit.cscorelib2.materials.MaterialCollections; import io.github.thebusybiscuit.cscorelib2.materials.MaterialConverter; import io.github.thebusybiscuit.cscorelib2.protection.ProtectableAction; -import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config; +import io.github.thebusybiscuit.cscorelib2.skull.SkullItem; +import io.github.thebusybiscuit.slimefun4.api.events.AndroidMineEvent; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.ChestMenu; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.ChestMenu.AdvancedMenuClickHandler; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.ClickAction; @@ -73,26 +77,24 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent private static final int[] border = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 18, 24, 25, 26, 27, 33, 35, 36, 42, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53}; private static final int[] border_out = {10, 11, 12, 13, 14, 19, 23, 28, 32, 37, 38, 39, 40, 41}; - private static final ItemStack[] fish = new ItemStack[] {new ItemStack(Material.COD), new ItemStack(Material.SALMON), new ItemStack(Material.PUFFERFISH), new ItemStack(Material.TROPICAL_FISH), new ItemStack(Material.STRING), new ItemStack(Material.BONE), new ItemStack(Material.STICK)}; - - private static final List directions = Arrays.asList(BlockFace.NORTH, BlockFace.EAST, BlockFace.SOUTH, BlockFace.WEST); - private static final List blockblacklist = new ArrayList<>(); - - + private static final RandomizedSet fishingLoot = new RandomizedSet<>(); + static { - blockblacklist.add(Material.BEDROCK); - blockblacklist.add(Material.BARRIER); - blockblacklist.add(Material.END_PORTAL_FRAME); - blockblacklist.add(Material.END_PORTAL); - blockblacklist.add(Material.NETHER_PORTAL); - blockblacklist.add(Material.COMMAND_BLOCK); - blockblacklist.add(Material.CHAIN_COMMAND_BLOCK); - blockblacklist.add(Material.REPEATING_COMMAND_BLOCK); - blockblacklist.add(Material.STRUCTURE_BLOCK); + for (Material fish : MaterialCollections.getAllFishItems()) { + fishingLoot.add(new ItemStack(fish), 20); + } + + fishingLoot.add(new ItemStack(Material.BONE), 10); + fishingLoot.add(new ItemStack(Material.STRING), 10); + fishingLoot.add(new ItemStack(Material.STICK), 5); + fishingLoot.add(new ItemStack(Material.INK_SAC), 4); + fishingLoot.add(new ItemStack(Material.ROTTEN_FLESH), 3); + fishingLoot.add(new ItemStack(Material.LEATHER), 2); } + + private static final List directions = Arrays.asList(BlockFace.NORTH, BlockFace.EAST, BlockFace.SOUTH, BlockFace.WEST); private final Set recipes = new HashSet<>(); - private final Random random = new Random(); @Override public int[] getInputSlots() { @@ -116,17 +118,17 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent registerFuel(new MachineFuel(45, new ItemStack(Material.BLAZE_ROD))); // Coals - for (Material mat: Tag.ITEMS_COALS.getValues()) { + for (Material mat : Tag.ITEMS_COALS.getValues()) { registerFuel(new MachineFuel(8, new ItemStack(mat))); } // Logs - for (Material mat: Tag.LOGS.getValues()) { + for (Material mat : Tag.LOGS.getValues()) { registerFuel(new MachineFuel(2, new ItemStack(mat))); } // Wooden Planks - for (Material mat: Tag.PLANKS.getValues()) { + for (Material mat : Tag.PLANKS.getValues()) { registerFuel(new MachineFuel(1, new ItemStack(mat))); } } @@ -145,11 +147,7 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent @Override public void init() { - try { - constructMenu(this); - } catch (Exception x) { - Slimefun.getLogger().log(Level.SEVERE, "An Error occured while constructing an Android Inventory for Slimefun " + Slimefun.getVersion(), x); - } + constructMenu(this); } @Override @@ -163,32 +161,28 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent @Override public void newInstance(BlockMenu menu, final Block b) { - try { - menu.replaceExistingItem(15, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZTAxYzdiNTcyNjE3ODk3NGIzYjNhMDFiNDJhNTkwZTU0MzY2MDI2ZmQ0MzgwOGYyYTc4NzY0ODg0M2E3ZjVhIn19fQ=="), "&aStart/Continue")); - menu.addMenuClickHandler(15, (p, slot, item, action) -> { - SlimefunPlugin.getLocal().sendMessage(p, "robot.started", true); - BlockStorage.addBlockInfo(b, "paused", "false"); - p.closeInventory(); - return false; - }); + menu.replaceExistingItem(15, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZTAxYzdiNTcyNjE3ODk3NGIzYjNhMDFiNDJhNTkwZTU0MzY2MDI2ZmQ0MzgwOGYyYTc4NzY0ODg0M2E3ZjVhIn19fQ=="), "&aStart/Continue")); + menu.addMenuClickHandler(15, (p, slot, item, action) -> { + SlimefunPlugin.getLocal().sendMessage(p, "robot.started", true); + BlockStorage.addBlockInfo(b, "paused", "false"); + p.closeInventory(); + return false; + }); - menu.replaceExistingItem(17, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTYxMzlmZDFjNTY1NGU1NmU5ZTRlMmM4YmU3ZWIyYmQ1YjQ5OWQ2MzM2MTY2NjNmZWVlOTliNzQzNTJhZDY0In19fQ=="), "&4Pause")); - menu.addMenuClickHandler(17, (p, slot, item, action) -> { - BlockStorage.addBlockInfo(b, "paused", "true"); - SlimefunPlugin.getLocal().sendMessage(p, "robot.stopped", true); - return false; - }); + menu.replaceExistingItem(17, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTYxMzlmZDFjNTY1NGU1NmU5ZTRlMmM4YmU3ZWIyYmQ1YjQ5OWQ2MzM2MTY2NjNmZWVlOTliNzQzNTJhZDY0In19fQ=="), "&4Pause")); + menu.addMenuClickHandler(17, (p, slot, item, action) -> { + BlockStorage.addBlockInfo(b, "paused", "true"); + SlimefunPlugin.getLocal().sendMessage(p, "robot.stopped", true); + return false; + }); - menu.replaceExistingItem(16, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZDc4ZjJiN2U1ZTc1NjM5ZWE3ZmI3OTZjMzVkMzY0YzRkZjI4YjQyNDNlNjZiNzYyNzdhYWRjZDYyNjEzMzcifX19"), "&bMemory Core", "", "&8\u21E8 &7Click to open the Script Editor")); - menu.addMenuClickHandler(16, (p, slot, item, action) -> { - BlockStorage.addBlockInfo(b, "paused", "true"); - SlimefunPlugin.getLocal().sendMessage(p, "robot.stopped", true); - openScriptEditor(p, b); - return false; - }); - } catch (Exception x) { - Slimefun.getLogger().log(Level.SEVERE, "An Error occured while creating a new Instance of an Android Inventory for Slimefun " + Slimefun.getVersion(), x); - } + menu.replaceExistingItem(16, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZDc4ZjJiN2U1ZTc1NjM5ZWE3ZmI3OTZjMzVkMzY0YzRkZjI4YjQyNDNlNjZiNzYyNzdhYWRjZDYyNjEzMzcifX19"), "&bMemory Core", "", "&8\u21E8 &7Click to open the Script Editor")); + menu.addMenuClickHandler(16, (p, slot, item, action) -> { + BlockStorage.addBlockInfo(b, "paused", "true"); + SlimefunPlugin.getLocal().sendMessage(p, "robot.stopped", true); + openScriptEditor(p, b); + return false; + }); } @Override @@ -208,6 +202,7 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent BlockStorage.addBlockInfo(b, "rotation", p.getFacing().getOppositeFace().toString()); BlockStorage.addBlockInfo(b, "paused", "true"); b.setType(Material.PLAYER_HEAD); + Rotatable blockData = (Rotatable) b.getBlockData(); blockData.setRotation(p.getFacing()); b.setBlockData(blockData); @@ -219,12 +214,14 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent if (allow) { BlockMenu inv = BlockStorage.getInventory(b); + if (inv != null) { if (inv.getItemInSlot(43) != null) { b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(43)); inv.replaceExistingItem(43, null); } - for (int slot: getOutputSlots()) { + + for (int slot : getOutputSlots()) { if (inv.getItemInSlot(slot) != null) { b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot)); inv.replaceExistingItem(slot, null); @@ -253,7 +250,7 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent if (item != null) { for (MachineFuel recipe: recipes) { - if (SlimefunManager.isItemSimiliar(item, recipe.getInput(), true)) { + if (SlimefunManager.isItemSimilar(item, recipe.getInput(), true)) { menu.replaceExistingItem(43, InvUtils.decreaseItem(item, 1)); if (getTier() == 2) { @@ -321,8 +318,8 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent Block water = b.getRelative(BlockFace.DOWN); if (water.getType() == Material.WATER) { water.getWorld().playSound(water.getLocation(), Sound.ENTITY_PLAYER_SPLASH, 1F, 1F); - if (random.nextInt(100) < 10 * getTier()) { - ItemStack drop = fish[random.nextInt(fish.length)]; + if (ThreadLocalRandom.current().nextInt(100) < 10 * getTier()) { + ItemStack drop = fishingLoot.getRandom(); if (menu.fits(drop, getOutputSlots())) { menu.pushItem(drop, getOutputSlots()); } @@ -342,7 +339,8 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent case INTERFACE_ITEMS: if (BlockStorage.check(b.getRelative(face), "ANDROID_INTERFACE_ITEMS") && b.getRelative(face).getState() instanceof Dispenser) { Dispenser d = (Dispenser) b.getRelative(face).getState(); - for (int slot: getOutputSlots()) { + + for (int slot : getOutputSlots()) { ItemStack stack = menu.getItemInSlot(slot); if (stack != null) { @@ -370,7 +368,7 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent d.getInventory().setItem(slot, null); break; } - else if (SlimefunManager.isItemSimiliar(item, menu.getItemInSlot(43), true)) { + else if (SlimefunManager.isItemSimilar(item, menu.getItemInSlot(43), true)) { int rest = item.getType().getMaxStackSize() - menu.getItemInSlot(43).getAmount(); if (rest > 0) { @@ -385,16 +383,16 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent } break; case FARM_FORWARD: - farm(b, menu, b.getRelative(face)); + farm(menu, b.getRelative(face)); break; case FARM_DOWN: - farm(b, menu, b.getRelative(BlockFace.DOWN)); + farm(menu, b.getRelative(BlockFace.DOWN)); break; case FARM_EXOTIC_FORWARD: - exoticFarm(b, menu, b.getRelative(face)); + exoticFarm(menu, b.getRelative(face)); break; case FARM_EXOTIC_DOWN: - exoticFarm(b, menu, b.getRelative(BlockFace.DOWN)); + exoticFarm(menu, b.getRelative(BlockFace.DOWN)); break; case CHOP_TREE: if (MaterialCollections.getAllLogs().contains(b.getRelative(face).getType())) { @@ -447,7 +445,7 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent private void killEntities(Block b, double damage, Predicate predicate) { double radius = 4.0 + getTier(); - for (Entity n: b.getWorld().getNearbyEntities(b.getLocation(), radius, radius, radius, n -> n instanceof LivingEntity && !(n instanceof ArmorStand) && !(n instanceof Player) && n.isValid() && predicate.test(n))) { + for (Entity n : b.getWorld().getNearbyEntities(b.getLocation(), radius, radius, radius, n -> n instanceof LivingEntity && !(n instanceof ArmorStand) && !(n instanceof Player) && n.isValid() && predicate.test(n))) { boolean attack = false; switch (BlockFace.valueOf(BlockStorage.getLocationInfo(b.getLocation(), "rotation"))) { @@ -468,8 +466,11 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent } if (attack) { - if (n.hasMetadata("android_killer")) n.removeMetadata("android_killer", SlimefunPlugin.instance); - n.setMetadata("android_killer", new FixedMetadataValue(SlimefunPlugin.instance, new AndroidObject(this, b))); + if (n.hasMetadata("android_killer")) { + n.removeMetadata("android_killer", SlimefunPlugin.instance); + } + + n.setMetadata("android_killer", new FixedMetadataValue(SlimefunPlugin.instance, new AndroidEntity(this, b))); ((LivingEntity) n).damage(damage); break; @@ -497,11 +498,17 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent private void mine(Block b, BlockMenu menu, Block block) { Collection drops = block.getDrops(); - if (!blockblacklist.contains(block.getType()) && !drops.isEmpty() && SlimefunPlugin.getProtectionManager().hasPermission(Bukkit.getOfflinePlayer(UUID.fromString(BlockStorage.getLocationInfo(b.getLocation(), "owner"))), block.getLocation(), ProtectableAction.BREAK_BLOCK)) { + if (!MaterialCollections.getAllUnbreakableBlocks().contains(block.getType()) && !drops.isEmpty() && SlimefunPlugin.getProtectionManager().hasPermission(Bukkit.getOfflinePlayer(UUID.fromString(BlockStorage.getLocationInfo(b.getLocation(), "owner"))), block.getLocation(), ProtectableAction.BREAK_BLOCK)) { String item = BlockStorage.checkID(block); - + + AndroidMineEvent event = new AndroidMineEvent(block, new AndroidEntity(this, b)); + Bukkit.getPluginManager().callEvent(event); + if (event.isCancelled()) { + return; + } + if (item == null) { - for (ItemStack drop: drops) { + for (ItemStack drop : drops) { if (menu.fits(drop, getOutputSlots())) { menu.pushItem(drop, getOutputSlots()); block.getWorld().playEffect(block.getLocation(), Effect.STEP_SOUND, block.getType()); @@ -526,10 +533,17 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent private void movedig(Block b, BlockMenu menu, BlockFace face, Block block) { Collection drops = block.getDrops(); - if (!blockblacklist.contains(block.getType()) && !drops.isEmpty() && SlimefunPlugin.getProtectionManager().hasPermission(Bukkit.getOfflinePlayer(UUID.fromString(BlockStorage.getLocationInfo(b.getLocation(), "owner"))), block.getLocation(), ProtectableAction.BREAK_BLOCK)) { + if (!MaterialCollections.getAllUnbreakableBlocks().contains(block.getType()) && !drops.isEmpty() && SlimefunPlugin.getProtectionManager().hasPermission(Bukkit.getOfflinePlayer(UUID.fromString(BlockStorage.getLocationInfo(b.getLocation(), "owner"))), block.getLocation(), ProtectableAction.BREAK_BLOCK)) { SlimefunItem item = BlockStorage.check(block); + + AndroidMineEvent event = new AndroidMineEvent(block, new AndroidEntity(this, b)); + Bukkit.getPluginManager().callEvent(event); + if (event.isCancelled()) { + return; + } + if (item == null) { - for (ItemStack drop: drops) { + for (ItemStack drop : drops) { if (menu.fits(drop, getOutputSlots())) { menu.pushItem(drop, getOutputSlots()); block.getWorld().playEffect(block.getLocation(), Effect.STEP_SOUND, block.getType()); @@ -567,34 +581,9 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent return ageable.getAge() >= ageable.getMaximumAge(); } - private void farm(Block b, BlockMenu menu, Block block) { + private void farm(BlockMenu menu, Block block) { if (isFullGrown(block)) { - ItemStack drop = null; - switch (block.getType()) { - case WHEAT: - drop = new ItemStack(Material.WHEAT, random.nextInt(2) + 1); - break; - case POTATOES: - drop = new ItemStack(Material.POTATO, random.nextInt(3) + 1); - break; - case CARROTS: - drop = new ItemStack(Material.CARROT, random.nextInt(3) + 1); - break; - case BEETROOTS: - drop = new ItemStack(Material.BEETROOT, random.nextInt(3) + 1); - break; - case COCOA: - drop = new ItemStack(Material.COCOA_BEANS, random.nextInt(3) + 1); - break; - case NETHER_WART: - drop = new ItemStack(Material.NETHER_WART, random.nextInt(3) + 1); - break; - case SWEET_BERRY_BUSH: - drop = new ItemStack(Material.SWEET_BERRIES, random.nextInt(3) + 1); - break; - default: - break; - } + ItemStack drop = getDropFromCrop(block.getType()); if (drop != null && menu.fits(drop, getOutputSlots())) { menu.pushItem(drop, getOutputSlots()); @@ -605,9 +594,33 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent } } } + + private ItemStack getDropFromCrop(Material crop) { + Random random = ThreadLocalRandom.current(); + + switch (crop) { + case WHEAT: + return new ItemStack(Material.WHEAT, random.nextInt(2) + 1); + case POTATOES: + return new ItemStack(Material.POTATO, random.nextInt(3) + 1); + case CARROTS: + return new ItemStack(Material.CARROT, random.nextInt(3) + 1); + case BEETROOTS: + return new ItemStack(Material.BEETROOT, random.nextInt(3) + 1); + case COCOA: + return new ItemStack(Material.COCOA_BEANS, random.nextInt(3) + 1); + case NETHER_WART: + return new ItemStack(Material.NETHER_WART, random.nextInt(3) + 1); + case SWEET_BERRY_BUSH: + return new ItemStack(Material.SWEET_BERRIES, random.nextInt(3) + 1); + default: + return null; + } + } - private void exoticFarm(Block b, BlockMenu menu, Block block) { - farm(b, menu, block); + private void exoticFarm(BlockMenu menu, Block block) { + farm(menu, block); + if (SlimefunPlugin.getHooks().isExoticGardenInstalled()) { ItemStack drop = ExoticGarden.harvestPlant(block); if (drop != null && menu.fits(drop, getOutputSlots())) { @@ -617,7 +630,7 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent } } - private void constructMenu(BlockMenuPreset preset) throws Exception { + private void constructMenu(BlockMenuPreset preset) { for (int i : border) { preset.addItem(i, new CustomItem(new ItemStack(Material.GRAY_STAINED_GLASS_PANE), " "), (p, slot, item, action) -> false); } @@ -641,13 +654,13 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent } if (getTier() == 1) { - preset.addItem(34, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvOTM0M2NlNThkYTU0Yzc5OTI0YTJjOTMzMWNmYzQxN2ZlOGNjYmJlYTliZTQ1YTdhYzg1ODYwYTZjNzMwIn19fQ=="), "&8\u21E9 &cFuel Input &8\u21E9", "", "&rThis Android runs on solid Fuel", "&re.g. Coal, Wood, etc..."), (p, slot, item, action) -> false); + preset.addItem(34, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvOTM0M2NlNThkYTU0Yzc5OTI0YTJjOTMzMWNmYzQxN2ZlOGNjYmJlYTliZTQ1YTdhYzg1ODYwYTZjNzMwIn19fQ=="), "&8\u21E9 &cFuel Input &8\u21E9", "", "&rThis Android runs on solid Fuel", "&re.g. Coal, Wood, etc..."), (p, slot, item, action) -> false); } else if (getTier() == 2){ - preset.addItem(34, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvOTM0M2NlNThkYTU0Yzc5OTI0YTJjOTMzMWNmYzQxN2ZlOGNjYmJlYTliZTQ1YTdhYzg1ODYwYTZjNzMwIn19fQ=="), "&8\u21E9 &cFuel Input &8\u21E9", "", "&rThis Android runs on liquid Fuel", "&re.g. Lava, Oil, Fuel, etc..."), (p, slot, item, action) -> false); + preset.addItem(34, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvOTM0M2NlNThkYTU0Yzc5OTI0YTJjOTMzMWNmYzQxN2ZlOGNjYmJlYTliZTQ1YTdhYzg1ODYwYTZjNzMwIn19fQ=="), "&8\u21E9 &cFuel Input &8\u21E9", "", "&rThis Android runs on liquid Fuel", "&re.g. Lava, Oil, Fuel, etc..."), (p, slot, item, action) -> false); } else { - preset.addItem(34, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvOTM0M2NlNThkYTU0Yzc5OTI0YTJjOTMzMWNmYzQxN2ZlOGNjYmJlYTliZTQ1YTdhYzg1ODYwYTZjNzMwIn19fQ=="), "&8\u21E9 &cFuel Input &8\u21E9", "", "&rThis Android runs on radioactive Fuel", "&re.g. Uranium, Neptunium or Boosted Uranium"), (p, slot, item, action) -> false); + preset.addItem(34, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvOTM0M2NlNThkYTU0Yzc5OTI0YTJjOTMzMWNmYzQxN2ZlOGNjYmJlYTliZTQ1YTdhYzg1ODYwYTZjNzMwIn19fQ=="), "&8\u21E9 &cFuel Input &8\u21E9", "", "&rThis Android runs on radioactive Fuel", "&re.g. Uranium, Neptunium or Boosted Uranium"), (p, slot, item, action) -> false); } } @@ -655,25 +668,25 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent ChestMenu menu = new ChestMenu("&eScript Editor"); try { - menu.addItem(1, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZDliZjZkYjRhZWRhOWQ4ODIyYjlmNzM2NTM4ZThjMThiOWE0ODQ0Zjg0ZWI0NTUwNGFkZmJmZWU4N2ViIn19fQ=="), "&2> Edit Script", "", "&aEdits your current Script")); + menu.addItem(1, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvZDliZjZkYjRhZWRhOWQ4ODIyYjlmNzM2NTM4ZThjMThiOWE0ODQ0Zjg0ZWI0NTUwNGFkZmJmZWU4N2ViIn19fQ=="), "&2> Edit Script", "", "&aEdits your current Script")); menu.addMenuClickHandler(1, (pl, slot, item, action) -> { openScript(pl, b, BlockStorage.getLocationInfo(b.getLocation(), "script")); return false; }); - menu.addItem(3, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTcxZDg5NzljMTg3OGEwNTk4N2E3ZmFmMjFiNTZkMWI3NDRmOWQwNjhjNzRjZmZjZGUxZWExZWRhZDU4NTIifX19"), "&4> Create new Script", "", "&cDeletes your current Script", "&cand creates a blank one")); + menu.addItem(3, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTcxZDg5NzljMTg3OGEwNTk4N2E3ZmFmMjFiNTZkMWI3NDRmOWQwNjhjNzRjZmZjZGUxZWExZWRhZDU4NTIifX19"), "&4> Create new Script", "", "&cDeletes your current Script", "&cand creates a blank one")); menu.addMenuClickHandler(3, (pl, slot, item, action) -> { openScript(pl, b, "START-TURN_LEFT-REPEAT"); return false; }); - menu.addItem(5, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYzAxNTg2ZTM5ZjZmZmE2M2I0ZmIzMDFiNjVjYTdkYThhOTJmNzM1M2FhYWI4OWQzODg2NTc5MTI1ZGZiYWY5In19fQ=="), "&6> Download a Script", "", "&eDownload a Script from the Server", "&eYou can edit or simply use it")); + menu.addItem(5, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYzAxNTg2ZTM5ZjZmZmE2M2I0ZmIzMDFiNjVjYTdkYThhOTJmNzM1M2FhYWI4OWQzODg2NTc5MTI1ZGZiYWY5In19fQ=="), "&6> Download a Script", "", "&eDownload a Script from the Server", "&eYou can edit or simply use it")); menu.addMenuClickHandler(5, (pl, slot, item, action) -> { openScriptDownloader(pl, b, 1); return false; }); - menu.addItem(8, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYTE4NWM5N2RiYjgzNTNkZTY1MjY5OGQyNGI2NDMyN2I3OTNhM2YzMmE5OGJlNjdiNzE5ZmJlZGFiMzVlIn19fQ=="), "&6> Back", "", "&7Return to the Android's interface")); + menu.addItem(8, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYTE4NWM5N2RiYjgzNTNkZTY1MjY5OGQyNGI2NDMyN2I3OTNhM2YzMmE5OGJlNjdiNzE5ZmJlZGFiMzVlIn19fQ=="), "&6> Back", "", "&7Return to the Android's interface")); menu.addMenuClickHandler(8, (pl, slot, item, action) -> { BlockStorage.getInventory(b).open(p); return false; @@ -704,7 +717,7 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent if (additional == 1) { try { - menu.addItem(i, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTcxZDg5NzljMTg3OGEwNTk4N2E3ZmFmMjFiNTZkMWI3NDRmOWQwNjhjNzRjZmZjZGUxZWExZWRhZDU4NTIifX19"), "&7> Add new Command")); + menu.addItem(i, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTcxZDg5NzljMTg3OGEwNTk4N2E3ZmFmMjFiNTZkMWI3NDRmOWQwNjhjNzRjZmZjZGUxZWExZWRhZDU4NTIifX19"), "&7> Add new Command")); menu.addMenuClickHandler(i, (pl, slot, item, action) -> { openScriptComponentEditor(pl, b, script, index); return false; @@ -794,7 +807,7 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent }); try { - menu.addItem(48, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTA1YTJjYWI4YjY4ZWE1N2UzYWY5OTJhMzZlNDdjOGZmOWFhODdjYzg3NzYyODE5NjZmOGMzY2YzMWEzOCJ9fX0="), "&eUpload a Script", "", "&6Click &7to upload your Android's Script", "&7to the Database")); + menu.addItem(48, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTA1YTJjYWI4YjY4ZWE1N2UzYWY5OTJhMzZlNDdjOGZmOWFhODdjYzg3NzYyODE5NjZmOGMzY2YzMWEzOCJ9fX0="), "&eUpload a Script", "", "&6Click &7to upload your Android's Script", "&7to the Database")); menu.addMenuClickHandler(48, (pl, slot, item, action) -> { final String code = BlockStorage.getLocationInfo(b.getLocation(), "script"); int num = 1; @@ -841,7 +854,7 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent return false; }); - menu.addItem(53, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYTE4NWM5N2RiYjgzNTNkZTY1MjY5OGQyNGI2NDMyN2I3OTNhM2YzMmE5OGJlNjdiNzE5ZmJlZGFiMzVlIn19fQ=="), "&6> Back", "", "&7Return to the Android's interface")); + menu.addItem(53, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvYTE4NWM5N2RiYjgzNTNkZTY1MjY5OGQyNGI2NDMyN2I3OTNhM2YzMmE5OGJlNjdiNzE5ZmJlZGFiMzVlIn19fQ=="), "&6> Back", "", "&7Return to the Android's interface")); menu.addMenuClickHandler(53, (pl, slot, item, action) -> { openScriptEditor(pl, b); return false; @@ -955,7 +968,7 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent } try { - menu.addItem(9, new CustomItem(CustomSkull.getItem("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTYxMzlmZDFjNTY1NGU1NmU5ZTRlMmM4YmU3ZWIyYmQ1YjQ5OWQ2MzM2MTY2NjNmZWVlOTliNzQzNTJhZDY0In19fQ=="), "&rDo nothing"), (pl, slot, item, action) -> { + menu.addItem(9, new CustomItem(SkullItem.fromBase64("eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvMTYxMzlmZDFjNTY1NGU1NmU5ZTRlMmM4YmU3ZWIyYmQ1YjQ5OWQ2MzM2MTY2NjNmZWVlOTliNzQzNTJhZDY0In19fQ=="), "&rDo nothing"), (pl, slot, item, action) -> { int i = 0; StringBuilder builder = new StringBuilder("START-"); @@ -1013,7 +1026,7 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent addItemHandler(new BlockTicker() { @Override - public void tick(Block b, SlimefunItem sf, Config data) { + public void tick(Block b, SlimefunItem sf, me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config data) { if (b != null) ProgrammableAndroid.this.tick(b); } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/androids/ScriptPart.java b/src/main/java/me/mrCookieSlime/Slimefun/androids/ScriptPart.java index f022af028..59552f23f 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/androids/ScriptPart.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/androids/ScriptPart.java @@ -1,12 +1,9 @@ package me.mrCookieSlime.Slimefun.androids; -import java.util.logging.Level; - import org.bukkit.inventory.ItemStack; +import io.github.thebusybiscuit.cscorelib2.skull.SkullItem; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.Item.CustomItem; -import me.mrCookieSlime.CSCoreLibPlugin.general.World.CustomSkull; -import me.mrCookieSlime.Slimefun.api.Slimefun; public enum ScriptPart { @@ -62,12 +59,8 @@ public enum ScriptPart { private AndroidType type; private ScriptPart(AndroidType type, String name, String texture) { - try { - this.type = type; - this.item = new CustomItem(CustomSkull.getItem(texture), name); - } catch(Exception x) { - Slimefun.getLogger().log(Level.SEVERE, "An Error occured while initializing Android-Script Texture for Slimefun " + Slimefun.getVersion(), x); - } + this.type = type; + this.item = new CustomItem(SkullItem.fromBase64(texture), name); } public ItemStack toItemStack() { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/androids/comparators/ScriptDownloadSorter.java b/src/main/java/me/mrCookieSlime/Slimefun/androids/comparators/ScriptDownloadSorter.java index 0163f3b32..da5b5ebca 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/androids/comparators/ScriptDownloadSorter.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/androids/comparators/ScriptDownloadSorter.java @@ -2,7 +2,7 @@ package me.mrCookieSlime.Slimefun.androids.comparators; import java.util.Comparator; -import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config; +import io.github.thebusybiscuit.cscorelib2.config.Config; public class ScriptDownloadSorter implements Comparator { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/androids/comparators/ScriptReputationSorter.java b/src/main/java/me/mrCookieSlime/Slimefun/androids/comparators/ScriptReputationSorter.java index df96e75c4..bb052ec89 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/androids/comparators/ScriptReputationSorter.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/androids/comparators/ScriptReputationSorter.java @@ -2,7 +2,7 @@ package me.mrCookieSlime.Slimefun.androids.comparators; import java.util.Comparator; -import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config; +import io.github.thebusybiscuit.cscorelib2.config.Config; import me.mrCookieSlime.Slimefun.androids.ProgrammableAndroid; public class ScriptReputationSorter implements Comparator { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/api/BlockStorage.java b/src/main/java/me/mrCookieSlime/Slimefun/api/BlockStorage.java index 30a590777..e923dac80 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/api/BlockStorage.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/api/BlockStorage.java @@ -8,6 +8,7 @@ import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.Map; +import java.util.Optional; import java.util.Set; import java.util.logging.Level; import java.util.logging.Logger; @@ -17,6 +18,7 @@ import org.bukkit.Chunk; import org.bukkit.Location; import org.bukkit.World; import org.bukkit.block.Block; +import org.bukkit.block.TileState; import org.bukkit.configuration.file.FileConfiguration; import org.bukkit.configuration.file.YamlConfiguration; import org.bukkit.entity.HumanEntity; @@ -242,8 +244,9 @@ public class BlockStorage { Config cfg = entry.getValue(); if (cfg.getKeys().isEmpty()) { - if (!cfg.getFile().delete()) { - Slimefun.getLogger().log(Level.WARNING, "Could not delete File: " + cfg.getFile().getName()); + File file = cfg.getFile(); + if (file.exists() && !file.delete()) { + Slimefun.getLogger().log(Level.WARNING, "Could not delete File: " + file.getName()); } } else { @@ -561,12 +564,19 @@ public class BlockStorage { return SlimefunItem.getByID(getLocationInfo(l, "id")); } - public static String checkID(Block block) { - return checkID(block.getLocation()); + public static String checkID(Block b) { + if (b.getState() instanceof TileState) { + Optional blockData = SlimefunPlugin.getBlockDataService().getBlockData((TileState) b.getState()); + + if (blockData.isPresent()) return blockData.get(); + } + + return checkID(b.getLocation()); } public static boolean check(Block block, String slimefunItem) { - return check(block.getLocation(), slimefunItem); + String id = checkID(block); + return id != null && id.equals(slimefunItem); } public static String checkID(Location l) { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/api/PlayerProfile.java b/src/main/java/me/mrCookieSlime/Slimefun/api/PlayerProfile.java index c6cbe11b7..02a24cccc 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/api/PlayerProfile.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/api/PlayerProfile.java @@ -20,7 +20,7 @@ import org.bukkit.command.CommandSender; import org.bukkit.entity.Player; import org.bukkit.inventory.ItemStack; -import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config; +import io.github.thebusybiscuit.cscorelib2.config.Config; import me.mrCookieSlime.Slimefun.SlimefunPlugin; import me.mrCookieSlime.Slimefun.Objects.Research; import me.mrCookieSlime.Slimefun.api.inventory.BackpackInventory; @@ -225,10 +225,7 @@ public final class PlayerProfile { * * @param uuid The UUID of the profile you are trying to retrieve. * @return The PlayerProfile of this player - * - * @deprecated Use {@link #fromUUID(UUID, Consumer)} */ - @Deprecated public static PlayerProfile fromUUID(UUID uuid) { PlayerProfile profile = SlimefunPlugin.getUtilities().profiles.get(uuid); @@ -264,9 +261,7 @@ public final class PlayerProfile { * * @param p The player's profile you wish to retrieve * @return The PlayerProfile of this player - * @deprecated Use {@link #get(OfflinePlayer, Consumer)} */ - @Deprecated public static PlayerProfile get(OfflinePlayer p) { PlayerProfile profile = SlimefunPlugin.getUtilities().profiles.get(p.getUniqueId()); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/api/Slimefun.java b/src/main/java/me/mrCookieSlime/Slimefun/api/Slimefun.java index 91ee8602c..79971e503 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/api/Slimefun.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/api/Slimefun.java @@ -104,9 +104,10 @@ public final class Slimefun { * @param items the items to bind, not null */ public static void registerResearch(Research research, ItemStack... items) { - for (ItemStack item: items) { + for (ItemStack item : items) { research.addItems(SlimefunItem.getByItem(item)); } + research.register(); } @@ -126,7 +127,10 @@ public final class Slimefun { if (sfItem == null) { if (state != ItemState.ENABLED) { - if (message && state != ItemState.VANILLA) SlimefunPlugin.getLocal().sendMessage(p, "messages.disabled-item", true); + if (message && state != ItemState.VANILLA) { + SlimefunPlugin.getLocal().sendMessage(p, "messages.disabled-item", true); + } + return false; } else return true; @@ -135,7 +139,10 @@ public final class Slimefun { if (sfItem.getResearch() == null) return true; else if (PlayerProfile.get(p).hasUnlocked(sfItem.getResearch())) return true; else { - if (message && !(sfItem instanceof VanillaItem)) SlimefunPlugin.getLocal().sendMessage(p, "messages.not-researched", true); + if (message && !(sfItem instanceof VanillaItem)) { + SlimefunPlugin.getLocal().sendMessage(p, "messages.not-researched", true); + } + return false; } } @@ -241,7 +248,7 @@ public final class Slimefun { */ public static List listIDs() { List ids = new ArrayList<>(); - for (SlimefunItem item: SlimefunItem.list()) { + for (SlimefunItem item : SlimefunItem.list()) { ids.add(item.getID()); } return ids; @@ -255,7 +262,7 @@ public final class Slimefun { */ public static List listCategories() { List items = new ArrayList<>(); - for (Category c: Category.list()) { + for (Category c : Category.list()) { items.add(c.getItem()); } return items; diff --git a/src/main/java/me/mrCookieSlime/Slimefun/api/SlimefunItemStack.java b/src/main/java/me/mrCookieSlime/Slimefun/api/SlimefunItemStack.java index 4dc7d856f..f071a21c9 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/api/SlimefunItemStack.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/api/SlimefunItemStack.java @@ -1,7 +1,6 @@ package me.mrCookieSlime.Slimefun.api; import java.util.function.Consumer; -import java.util.logging.Level; import org.bukkit.Color; import org.bukkit.Material; @@ -9,12 +8,14 @@ import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.ItemMeta; import io.github.thebusybiscuit.cscorelib2.item.CustomItem; -import me.mrCookieSlime.CSCoreLibPlugin.general.World.CustomSkull; +import io.github.thebusybiscuit.cscorelib2.item.ImmutableItemMeta; +import io.github.thebusybiscuit.cscorelib2.skull.SkullItem; import me.mrCookieSlime.Slimefun.SlimefunPlugin; public class SlimefunItemStack extends CustomItem { private String id; + private ImmutableItemMeta immutableMeta; public SlimefunItemStack(String id, Material type, String name, String... lore) { super(type, name, lore); @@ -47,7 +48,7 @@ public class SlimefunItemStack extends CustomItem { } public SlimefunItemStack(String id, String texture, String name, String... lore) { - super(getSkull(texture), name, lore); + super(SkullItem.fromBase64(texture), name, lore); setID(id); } @@ -62,19 +63,27 @@ public class SlimefunItemStack extends CustomItem { setItemMeta(meta); } - - private static ItemStack getSkull(String texture) { - try { - return CustomSkull.getItem(texture); - } catch (Exception x) { - Slimefun.getLogger().log(Level.SEVERE, "An Error occurred while initializing the Items for Slimefun " + Slimefun.getVersion(), x); - - return new ItemStack(Material.PLAYER_HEAD); - } - } public String getItemID() { return id; } + + public ImmutableItemMeta getImmutableMeta() { + return immutableMeta; + } + + @Override + public boolean setItemMeta(ItemMeta meta) { + immutableMeta = new ImmutableItemMeta(meta); + + return super.setItemMeta(meta); + } + + @Override + public ItemStack clone() { + SlimefunItemStack item = (SlimefunItemStack) super.clone(); + item.id = getItemID(); + return item; + } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/api/TickerTask.java b/src/main/java/me/mrCookieSlime/Slimefun/api/TickerTask.java index 10e8ceba1..ecad6c60c 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/api/TickerTask.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/api/TickerTask.java @@ -22,6 +22,7 @@ import org.bukkit.command.CommandSender; import org.bukkit.entity.Player; import io.github.thebusybiscuit.cscorelib2.chat.ChatColors; +import io.github.thebusybiscuit.slimefun4.api.ErrorReport; import me.mrCookieSlime.CSCoreLibPlugin.general.Chat.TellRawMessage; import me.mrCookieSlime.CSCoreLibPlugin.general.Chat.TellRawMessage.HoverAction; import me.mrCookieSlime.Slimefun.SlimefunPlugin; diff --git a/src/main/java/me/mrCookieSlime/Slimefun/api/inventory/BackpackInventory.java b/src/main/java/me/mrCookieSlime/Slimefun/api/inventory/BackpackInventory.java index e3c2487ec..a361b581c 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/api/inventory/BackpackInventory.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/api/inventory/BackpackInventory.java @@ -4,7 +4,7 @@ import org.bukkit.Bukkit; import org.bukkit.entity.Player; import org.bukkit.inventory.Inventory; -import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config; +import io.github.thebusybiscuit.cscorelib2.config.Config; import me.mrCookieSlime.Slimefun.api.PlayerProfile; public class BackpackInventory { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/api/item_transport/CargoManager.java b/src/main/java/me/mrCookieSlime/Slimefun/api/item_transport/CargoManager.java index beac13811..0a8d6763b 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/api/item_transport/CargoManager.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/api/item_transport/CargoManager.java @@ -24,7 +24,7 @@ public final class CargoManager { UniversalBlockMenu menu = storage.getUniversalInventory(target); for (int slot: menu.getPreset().getSlotsAccessedByItemTransport(menu, ItemTransportFlow.WITHDRAW, null)) { final ItemStack is = menu.getItemInSlot(slot); - if (SlimefunManager.isItemSimiliar(is, template, true) && matchesFilter(node, is, -1)) { + if (SlimefunManager.isItemSimilar(is, template, true) && matchesFilter(node, is, -1)) { if (is.getAmount() > template.getAmount()) { menu.replaceExistingItem(slot, new CustomItem(is, is.getAmount() - template.getAmount())); return template; @@ -40,7 +40,7 @@ public final class CargoManager { BlockMenu menu = BlockStorage.getInventory(target.getLocation()); for (int slot: menu.getPreset().getSlotsAccessedByItemTransport(menu, ItemTransportFlow.WITHDRAW, null)) { final ItemStack is = menu.getItemInSlot(slot); - if (SlimefunManager.isItemSimiliar(is, template, true) && matchesFilter(node, is, -1)) { + if (SlimefunManager.isItemSimilar(is, template, true) && matchesFilter(node, is, -1)) { if (is.getAmount() > template.getAmount()) { menu.replaceExistingItem(slot, new CustomItem(is, is.getAmount() - template.getAmount())); return template; @@ -56,7 +56,7 @@ public final class CargoManager { Inventory inv = ((InventoryHolder) target.getState()).getInventory(); for (int slot = 0; slot < inv.getContents().length; slot++) { final ItemStack is = inv.getContents()[slot]; - if (SlimefunManager.isItemSimiliar(is, template, true) && matchesFilter(node, is, -1)) { + if (SlimefunManager.isItemSimilar(is, template, true) && matchesFilter(node, is, -1)) { if (is.getAmount() > template.getAmount()) { inv.setItem(slot, ChestManipulator.trigger(target, slot, is, new CustomItem(is, is.getAmount() - template.getAmount()))); return template; @@ -115,7 +115,7 @@ public final class CargoManager { menu.replaceExistingItem(slot, stack.clone()); return null; } - else if (SlimefunManager.isItemSimiliar(new CustomItem(is, 1), new CustomItem(stack, 1), true) && is.getAmount() < is.getType().getMaxStackSize()) { + else if (SlimefunManager.isItemSimilar(new CustomItem(is, 1), new CustomItem(stack, 1), true) && is.getAmount() < is.getType().getMaxStackSize()) { int amount = is.getAmount() + stack.getAmount(); if (amount > is.getType().getMaxStackSize()) { @@ -140,7 +140,7 @@ public final class CargoManager { menu.replaceExistingItem(slot, stack.clone()); return null; } - else if (SlimefunManager.isItemSimiliar(new CustomItem(is, 1), new CustomItem(stack, 1), true) && is.getAmount() < is.getType().getMaxStackSize()) { + else if (SlimefunManager.isItemSimilar(new CustomItem(is, 1), new CustomItem(stack, 1), true) && is.getAmount() < is.getType().getMaxStackSize()) { int amount = is.getAmount() + stack.getAmount(); if (amount > is.getType().getMaxStackSize()) { @@ -166,7 +166,7 @@ public final class CargoManager { inv.setItem(slot, ChestManipulator.trigger(target, slot, null, stack.clone())); return null; } - else if (SlimefunManager.isItemSimiliar(new CustomItem(is, 1), new CustomItem(stack, 1), true) && is.getAmount() < is.getType().getMaxStackSize()) { + else if (SlimefunManager.isItemSimilar(new CustomItem(is, 1), new CustomItem(stack, 1), true) && is.getAmount() < is.getType().getMaxStackSize()) { ItemStack prev = is.clone(); int amount = is.getAmount() + stack.getAmount(); @@ -220,18 +220,18 @@ public final class CargoManager { BlockStorage.addBlockInfo(block, "index", String.valueOf(index)); - return SlimefunManager.isItemSimiliar(item, items.get(index), lore); + return SlimefunManager.isItemSimilar(item, items.get(index), lore); } else { for (ItemStack stack: items) { - if (SlimefunManager.isItemSimiliar(item, stack, lore)) return true; + if (SlimefunManager.isItemSimilar(item, stack, lore)) return true; } return false; } } else { for (int slot: slots) { - if (menu.getItemInSlot(slot) != null && SlimefunManager.isItemSimiliar(item, new CustomItem(menu.getItemInSlot(slot), 1), lore)) { + if (menu.getItemInSlot(slot) != null && SlimefunManager.isItemSimilar(item, new CustomItem(menu.getItemInSlot(slot), 1), lore)) { return false; } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/api/item_transport/CargoNet.java b/src/main/java/me/mrCookieSlime/Slimefun/api/item_transport/CargoNet.java index 05d10b7c6..4083b5d6e 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/api/item_transport/CargoNet.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/api/item_transport/CargoNet.java @@ -286,7 +286,7 @@ public class CargoNet extends Network { int slot = request.getSlot(); ItemStack prevStack = menu.getItemInSlot(slot); - if (!(prevStack == null || (prevStack.getAmount() + request.getItem().getAmount() <= prevStack.getMaxStackSize() && SlimefunManager.isItemSimiliar(prevStack, new CustomItem(request.getItem(), 1), true)))) { + if (!(prevStack == null || (prevStack.getAmount() + request.getItem().getAmount() <= prevStack.getMaxStackSize() && SlimefunManager.isItemSimilar(prevStack, new CustomItem(request.getItem(), 1), true)))) { iterator.remove(); break; } @@ -419,7 +419,7 @@ public class CargoNet extends Network { if (is != null && CargoManager.matchesFilter(l.getBlock(), is, -1)) { boolean add = true; for (StoredItem item: items) { - if (SlimefunManager.isItemSimiliar(is, item.getItem(), true)) { + if (SlimefunManager.isItemSimilar(is, item.getItem(), true)) { add = false; item.add(is.getAmount() + stored); } @@ -521,7 +521,7 @@ public class CargoNet extends Network { if (is != null && CargoManager.matchesFilter(l.getBlock(), is, -1)) { boolean add = true; for (StoredItem item: items) { - if (SlimefunManager.isItemSimiliar(is, item.getItem(), true)) { + if (SlimefunManager.isItemSimilar(is, item.getItem(), true)) { add = false; item.add(is.getAmount()); } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/autosave/BlockAutoSaver.java b/src/main/java/me/mrCookieSlime/Slimefun/autosave/BlockAutoSaver.java index e46224fe4..24feb444e 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/autosave/BlockAutoSaver.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/autosave/BlockAutoSaver.java @@ -17,7 +17,7 @@ public class BlockAutoSaver implements Runnable { public void run() { Set worlds = new HashSet<>(); - for (World world: Bukkit.getWorlds()) { + for (World world : Bukkit.getWorlds()) { if (BlockStorage.isWorldRegistered(world.getName())) { BlockStorage storage = BlockStorage.getStorage(world); storage.computeChanges(); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/commands/subcommands/GuideCommand.java b/src/main/java/me/mrCookieSlime/Slimefun/commands/subcommands/GuideCommand.java index c551364dd..c3248e9b5 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/commands/subcommands/GuideCommand.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/commands/subcommands/GuideCommand.java @@ -3,11 +3,11 @@ package me.mrCookieSlime.Slimefun.commands.subcommands; import org.bukkit.command.CommandSender; import org.bukkit.entity.Player; +import io.github.thebusybiscuit.slimefun4.core.guide.SlimefunGuideLayout; import me.mrCookieSlime.Slimefun.SlimefunGuide; import me.mrCookieSlime.Slimefun.SlimefunPlugin; import me.mrCookieSlime.Slimefun.commands.SlimefunCommand; import me.mrCookieSlime.Slimefun.commands.SubCommand; -import me.mrCookieSlime.Slimefun.guides.SlimefunGuideLayout; public class GuideCommand extends SubCommand { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/commands/subcommands/OpenGuideCommand.java b/src/main/java/me/mrCookieSlime/Slimefun/commands/subcommands/OpenGuideCommand.java index ba06eeedd..fccc23ff7 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/commands/subcommands/OpenGuideCommand.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/commands/subcommands/OpenGuideCommand.java @@ -3,11 +3,11 @@ package me.mrCookieSlime.Slimefun.commands.subcommands; import org.bukkit.command.CommandSender; import org.bukkit.entity.Player; +import io.github.thebusybiscuit.slimefun4.core.guide.SlimefunGuideLayout; import me.mrCookieSlime.Slimefun.SlimefunGuide; import me.mrCookieSlime.Slimefun.SlimefunPlugin; import me.mrCookieSlime.Slimefun.commands.SlimefunCommand; import me.mrCookieSlime.Slimefun.commands.SubCommand; -import me.mrCookieSlime.Slimefun.guides.SlimefunGuideLayout; public class OpenGuideCommand extends SubCommand { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/hooks/PlaceholderAPIHook.java b/src/main/java/me/mrCookieSlime/Slimefun/hooks/PlaceholderAPIHook.java index 507e86d0d..7688f200a 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/hooks/PlaceholderAPIHook.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/hooks/PlaceholderAPIHook.java @@ -38,7 +38,6 @@ public class PlaceholderAPIHook extends PlaceholderExpansion { return true; } - @SuppressWarnings("deprecation") @Override public String onRequest(OfflinePlayer p, String params) { if (params.equals("researches_total_xp_levels_spent")) { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/hooks/SlimefunHooks.java b/src/main/java/me/mrCookieSlime/Slimefun/hooks/SlimefunHooks.java index f0c9f4504..46ea22837 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/hooks/SlimefunHooks.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/hooks/SlimefunHooks.java @@ -54,7 +54,7 @@ public final class SlimefunHooks { private boolean isPluginInstalled(String hook) { if (plugin.getServer().getPluginManager().isPluginEnabled(hook)) { - Slimefun.getLogger().log(Level.INFO, "Hooked into Plugin: " + hook); + Slimefun.getLogger().log(Level.INFO, "Hooked into Plugin: {0}", hook); return true; } else { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/hooks/github/GitHubSetup.java b/src/main/java/me/mrCookieSlime/Slimefun/hooks/github/GitHubSetup.java deleted file mode 100644 index 39a479778..000000000 --- a/src/main/java/me/mrCookieSlime/Slimefun/hooks/github/GitHubSetup.java +++ /dev/null @@ -1,105 +0,0 @@ -package me.mrCookieSlime.Slimefun.hooks.github; - -import com.google.gson.JsonArray; -import com.google.gson.JsonElement; -import com.google.gson.JsonObject; - -import me.mrCookieSlime.Slimefun.SlimefunPlugin; - -public final class GitHubSetup { - - private static final String REPOSITORY = "TheBusyBiscuit/Slimefun4"; - - private GitHubSetup() {} - - public static void setup() { - new ContributionsConnector("code", REPOSITORY, "&6Developer"); - new ContributionsConnector("wiki", "TheBusyBiscuit/Slimefun4-wiki", "&3Wiki Editor"); - new ContributionsConnector("resourcepack", "TheBusyBiscuit/Slimefun4-Resourcepack", "&cResourcepack Artist"); - - new GitHubConnector() { - - @Override - public void onSuccess(JsonElement element) { - JsonObject object = element.getAsJsonObject(); - SlimefunPlugin.getUtilities().forks = object.get("forks").getAsInt(); - SlimefunPlugin.getUtilities().stars = object.get("stargazers_count").getAsInt(); - SlimefunPlugin.getUtilities().lastUpdate = IntegerFormat.parseGitHubDate(object.get("pushed_at").getAsString()); - } - - @Override - public String getRepository() { - return REPOSITORY; - } - - @Override - public String getFileName() { - return "repo"; - } - - @Override - public String getURLSuffix() { - return ""; - } - }; - - new GitHubConnector() { - - @Override - public void onSuccess(JsonElement element) { - JsonArray array = element.getAsJsonArray(); - - int issues = 0; - int prs = 0; - - for (JsonElement elem: array) { - JsonObject obj = elem.getAsJsonObject(); - if (obj.has("pull_request")) prs++; - else issues++; - } - - SlimefunPlugin.getUtilities().issues = issues; - SlimefunPlugin.getUtilities().prs = prs; - } - - @Override - public String getRepository() { - return REPOSITORY; - } - - @Override - public String getFileName() { - return "issues"; - } - - @Override - public String getURLSuffix() { - return "/issues"; - } - }; - - new GitHubConnector() { - - @Override - public void onSuccess(JsonElement element) { - JsonObject object = element.getAsJsonObject(); - SlimefunPlugin.getUtilities().codeBytes = object.get("Java").getAsInt(); - } - - @Override - public String getRepository() { - return REPOSITORY; - } - - @Override - public String getFileName() { - return "languages"; - } - - @Override - public String getURLSuffix() { - return "/languages"; - } - }; - } -} diff --git a/src/main/java/me/mrCookieSlime/Slimefun/listeners/AndroidKillingListener.java b/src/main/java/me/mrCookieSlime/Slimefun/listeners/AndroidKillingListener.java index 4ce769584..a9e219368 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/listeners/AndroidKillingListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/listeners/AndroidKillingListener.java @@ -17,7 +17,7 @@ import org.bukkit.event.entity.EntityDeathEvent; import org.bukkit.inventory.ItemStack; import me.mrCookieSlime.Slimefun.SlimefunPlugin; -import me.mrCookieSlime.Slimefun.androids.AndroidObject; +import me.mrCookieSlime.Slimefun.androids.AndroidEntity; public class AndroidKillingListener implements Listener { @@ -30,7 +30,7 @@ public class AndroidKillingListener implements Listener { @EventHandler(priority = EventPriority.HIGHEST) public void onDeath(final EntityDeathEvent e) { if (e.getEntity().hasMetadata("android_killer")) { - final AndroidObject obj = (AndroidObject) e.getEntity().getMetadata("android_killer").get(0).value(); + final AndroidEntity obj = (AndroidEntity) e.getEntity().getMetadata("android_killer").get(0).value(); Bukkit.getScheduler().scheduleSyncDelayedTask(SlimefunPlugin.instance, () -> { List items = new ArrayList<>(); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/listeners/ArmorListener.java b/src/main/java/me/mrCookieSlime/Slimefun/listeners/ArmorListener.java index 5d7df7fc8..dec04eee7 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/listeners/ArmorListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/listeners/ArmorListener.java @@ -94,7 +94,7 @@ public class ArmorListener implements Listener { if (e.getAction() == Action.PHYSICAL && e.getClickedBlock() != null && e.getClickedBlock().getType() == Material.FARMLAND - && SlimefunManager.isItemSimiliar(e.getPlayer().getInventory().getBoots(), + && SlimefunManager.isItemSimilar(e.getPlayer().getInventory().getBoots(), SlimefunItems.FARMER_SHOES, true) ) e.setCancelled(true); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/listeners/BackpackListener.java b/src/main/java/me/mrCookieSlime/Slimefun/listeners/BackpackListener.java index 045c722a3..9c1f2bea9 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/listeners/BackpackListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/listeners/BackpackListener.java @@ -67,7 +67,7 @@ public class BackpackListener implements Listener { } else if (e.getCurrentItem() != null && e.getCurrentItem().getType() != Material.AIR) { SlimefunItem sfItem = SlimefunItem.getByItem(e.getCurrentItem()); - if ((SlimefunManager.isItemSimiliar(item, SlimefunItems.COOLER, false) && !(sfItem instanceof Juice)) || + if ((SlimefunManager.isItemSimilar(item, SlimefunItems.COOLER, false) && !(sfItem instanceof Juice)) || e.getCurrentItem().getType().toString().contains("SHULKER_BOX") || sfItem instanceof SlimefunBackpack) diff --git a/src/main/java/me/mrCookieSlime/Slimefun/listeners/BlockListener.java b/src/main/java/me/mrCookieSlime/Slimefun/listeners/BlockListener.java index 08551e10d..f7c9abc61 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/listeners/BlockListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/listeners/BlockListener.java @@ -18,8 +18,8 @@ import org.bukkit.event.player.PlayerInteractEvent; import org.bukkit.inventory.EquipmentSlot; import org.bukkit.inventory.ItemStack; +import io.github.thebusybiscuit.slimefun4.api.events.MultiBlockInteractEvent; import me.mrCookieSlime.Slimefun.SlimefunPlugin; -import me.mrCookieSlime.Slimefun.Events.MultiBlockInteractEvent; import me.mrCookieSlime.Slimefun.Objects.MultiBlock; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem; import me.mrCookieSlime.Slimefun.Objects.handlers.ItemHandler; diff --git a/src/main/java/me/mrCookieSlime/Slimefun/listeners/CoolerListener.java b/src/main/java/me/mrCookieSlime/Slimefun/listeners/CoolerListener.java index f552ebb75..dab228807 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/listeners/CoolerListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/listeners/CoolerListener.java @@ -28,7 +28,7 @@ public class CoolerListener implements Listener { if (e.getFoodLevel() < ((Player) e.getEntity()).getFoodLevel()) { Player p = (Player) e.getEntity(); for (ItemStack item: p.getInventory().getContents()) { - if (SlimefunManager.isItemSimiliar(item, SlimefunItems.COOLER, false)) { + if (SlimefunManager.isItemSimilar(item, SlimefunItems.COOLER, false)) { BackpackInventory backpack = PlayerProfile.getBackpack(item); if (backpack != null) { Inventory inv = backpack.getInventory(); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/listeners/GuideOnJoinListener.java b/src/main/java/me/mrCookieSlime/Slimefun/listeners/GuideOnJoinListener.java index 0ec661e5e..287cfe1f3 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/listeners/GuideOnJoinListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/listeners/GuideOnJoinListener.java @@ -5,9 +5,9 @@ import org.bukkit.event.EventHandler; import org.bukkit.event.Listener; import org.bukkit.event.player.PlayerJoinEvent; +import io.github.thebusybiscuit.slimefun4.core.guide.SlimefunGuideLayout; import me.mrCookieSlime.Slimefun.SlimefunGuide; import me.mrCookieSlime.Slimefun.SlimefunPlugin; -import me.mrCookieSlime.Slimefun.guides.SlimefunGuideLayout; public class GuideOnJoinListener implements Listener { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/listeners/ItemListener.java b/src/main/java/me/mrCookieSlime/Slimefun/listeners/ItemListener.java index 85fd8eba8..2f55f9f11 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/listeners/ItemListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/listeners/ItemListener.java @@ -37,6 +37,8 @@ import org.bukkit.inventory.meta.PotionMeta; import org.bukkit.potion.PotionEffect; import org.bukkit.potion.PotionEffectType; +import io.github.thebusybiscuit.slimefun4.core.guide.GuideSettings; +import io.github.thebusybiscuit.slimefun4.core.guide.SlimefunGuideLayout; import me.mrCookieSlime.CSCoreLibPlugin.events.ItemUseEvent; import me.mrCookieSlime.CSCoreLibPlugin.general.World.CustomSkull; import me.mrCookieSlime.Slimefun.SlimefunGuide; @@ -58,8 +60,6 @@ import me.mrCookieSlime.Slimefun.api.energy.ItemEnergy; import me.mrCookieSlime.Slimefun.api.inventory.BlockMenu; import me.mrCookieSlime.Slimefun.api.inventory.BlockMenuPreset; import me.mrCookieSlime.Slimefun.api.inventory.UniversalBlockMenu; -import me.mrCookieSlime.Slimefun.guides.GuideSettings; -import me.mrCookieSlime.Slimefun.guides.SlimefunGuideLayout; import me.mrCookieSlime.Slimefun.utils.Utilities; public class ItemListener implements Listener { @@ -89,14 +89,14 @@ public class ItemListener implements Listener { e.setCancelled(true); - if (SlimefunManager.isItemSimiliar(slot0, SlimefunGuide.getItem(SlimefunGuideLayout.BOOK), true)) + if (SlimefunManager.isItemSimilar(slot0, SlimefunGuide.getItem(SlimefunGuideLayout.BOOK), true)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(slot0, SlimefunGuide.getItem(SlimefunGuideLayout.CHEST), true)) + else if (SlimefunManager.isItemSimilar(slot0, SlimefunGuide.getItem(SlimefunGuideLayout.CHEST), true)) e.setCancelled(true); - if (SlimefunManager.isItemSimiliar(slot1, SlimefunGuide.getItem(SlimefunGuideLayout.BOOK), true)) + if (SlimefunManager.isItemSimilar(slot1, SlimefunGuide.getItem(SlimefunGuideLayout.BOOK), true)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(slot1, SlimefunGuide.getItem(SlimefunGuideLayout.CHEST), true)) + else if (SlimefunManager.isItemSimilar(slot1, SlimefunGuide.getItem(SlimefunGuideLayout.CHEST), true)) e.setCancelled(true); } } @@ -122,7 +122,7 @@ public class ItemListener implements Listener { Player p = e.getPlayer(); - if (SlimefunManager.isItemSimiliar(e.getItem(), SlimefunItems.DEBUG_FISH, true)) { + if (SlimefunManager.isItemSimilar(e.getItem(), SlimefunItems.DEBUG_FISH, true)) { e.setCancelled(true); if (p.isOp()) { switch (e.getAction()) { @@ -211,19 +211,19 @@ public class ItemListener implements Listener { final Player p = e.getPlayer(); ItemStack item = e.getItem(); - if (SlimefunManager.isItemSimiliar(item, SlimefunGuide.getItem(SlimefunGuideLayout.BOOK), true)) { + if (SlimefunManager.isItemSimilar(item, SlimefunGuide.getItem(SlimefunGuideLayout.BOOK), true)) { if (p.isSneaking()) GuideSettings.openSettings(p, item); else SlimefunGuide.openGuide(p, SlimefunGuideLayout.BOOK); } - else if (SlimefunManager.isItemSimiliar(item, SlimefunGuide.getItem(SlimefunGuideLayout.CHEST), true)) { + else if (SlimefunManager.isItemSimilar(item, SlimefunGuide.getItem(SlimefunGuideLayout.CHEST), true)) { if (p.isSneaking()) GuideSettings.openSettings(p, item); else SlimefunGuide.openGuide(p, SlimefunGuideLayout.CHEST); } - else if (SlimefunManager.isItemSimiliar(item, SlimefunGuide.getItem(SlimefunGuideLayout.CHEAT_SHEET), true)) { + else if (SlimefunManager.isItemSimilar(item, SlimefunGuide.getItem(SlimefunGuideLayout.CHEAT_SHEET), true)) { if (p.isSneaking()) GuideSettings.openSettings(p, item); else p.chat("/sf cheat"); } - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.DEBUG_FISH, true)) { + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.DEBUG_FISH, true)) { // Ignore the debug fish in here } else { @@ -249,6 +249,7 @@ public class ItemListener implements Listener { if (!p.isSneaking()) { float charge = ItemEnergy.getStoredEnergy(item); float cost = 0.3F; + if (charge >= cost) { p.getEquipment().setItemInMainHand(ItemEnergy.chargeItem(item, -cost)); Bukkit.getPluginManager().callEvent(new ItemUseEvent(e.getParentEvent(), SlimefunItem.getByID((String) Slimefun.getItemValue(slimefunItem.getID(), "mode." + modes.get(index) + ".item")).getItem().clone(), e.getClickedBlock())); @@ -257,13 +258,14 @@ public class ItemListener implements Listener { else { index++; if (index == modes.size()) index = 0; - - final int finalIndex = index; - SlimefunPlugin.getLocal().sendMessage(p, "messages.mode-change", true, msg -> msg.replace("%device%", "Multi Tool").replace("%mode%", (String) Slimefun.getItemValue(slimefunItem.getID(), "mode." + modes.get(finalIndex) + ".name"))); + + SlimefunItem selectedItem = SlimefunItem.getByID((String) Slimefun.getItemValue(slimefunItem.getID(), "mode." + modes.get(index) + ".item")); + String itemName = selectedItem != null ? selectedItem.getItemName(): "Unknown"; + SlimefunPlugin.getLocal().sendMessage(p, "messages.mode-change", true, msg -> msg.replace("%device%", "Multi Tool").replace("%mode%", ChatColor.stripColor(itemName))); utilities.mode.put(p.getUniqueId(), index); } } - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.HEAVY_CREAM, true)) e.setCancelled(true); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.HEAVY_CREAM, true)) e.setCancelled(true); } else { e.setCancelled(true); @@ -306,11 +308,11 @@ public class ItemListener implements Listener { } private boolean canPlaceCargoNodes(Player p, ItemStack item, Block b) { - if (canPlaceBlock(p, b) && SlimefunManager.isItemSimiliar(item, SlimefunItems.CARGO_INPUT, true)) return true; - else if (canPlaceBlock(p, b) && SlimefunManager.isItemSimiliar(item, SlimefunItems.CARGO_OUTPUT, true)) return true; - else if (canPlaceBlock(p, b) && SlimefunManager.isItemSimiliar(item, SlimefunItems.CARGO_OUTPUT_ADVANCED, true)) return true; - else if (canPlaceBlock(p, b) && SlimefunManager.isItemSimiliar(item, SlimefunItems.CT_IMPORT_BUS, true)) return true; - else if (canPlaceBlock(p, b) && SlimefunManager.isItemSimiliar(item, SlimefunItems.CT_EXPORT_BUS, true)) return true; + if (canPlaceBlock(p, b) && SlimefunManager.isItemSimilar(item, SlimefunItems.CARGO_INPUT, true)) return true; + else if (canPlaceBlock(p, b) && SlimefunManager.isItemSimilar(item, SlimefunItems.CARGO_OUTPUT, true)) return true; + else if (canPlaceBlock(p, b) && SlimefunManager.isItemSimilar(item, SlimefunItems.CARGO_OUTPUT_ADVANCED, true)) return true; + else if (canPlaceBlock(p, b) && SlimefunManager.isItemSimilar(item, SlimefunItems.CT_IMPORT_BUS, true)) return true; + else if (canPlaceBlock(p, b) && SlimefunManager.isItemSimilar(item, SlimefunItems.CT_EXPORT_BUS, true)) return true; else return false; } @@ -337,7 +339,7 @@ public class ItemListener implements Listener { // Determine from which hand the juice is being drunk, and its amount int mode = 0; - if (SlimefunManager.isItemSimiliar(item, p.getInventory().getItemInMainHand(), true)) { + if (SlimefunManager.isItemSimilar(item, p.getInventory().getItemInMainHand(), true)) { if (p.getInventory().getItemInMainHand().getAmount() == 1) { mode = 0; } @@ -345,7 +347,7 @@ public class ItemListener implements Listener { mode = 2; } } - else if (SlimefunManager.isItemSimiliar(item, p.getInventory().getItemInOffHand(), true)) { + else if (SlimefunManager.isItemSimilar(item, p.getInventory().getItemInOffHand(), true)) { if (p.getInventory().getItemInOffHand().getAmount() == 1) { mode = 1; } @@ -420,16 +422,16 @@ public class ItemListener implements Listener { ItemStack slot0 = e.getInventory().getContents()[0]; ItemStack slot1 = e.getInventory().getContents()[1]; - if (SlimefunManager.isItemSimiliar(slot0, SlimefunItems.ELYTRA, true)) return; + if (SlimefunManager.isItemSimilar(slot0, SlimefunItems.ELYTRA, true)) return; if (SlimefunItem.getByItem(slot0) != null && !SlimefunItem.isDisabled(slot0) || SlimefunItem.getByItem(slot1) != null && !SlimefunItem.isDisabled(slot1) || - SlimefunManager.isItemSimiliar(slot0, SlimefunGuide.getItem(SlimefunGuideLayout.BOOK), true) || - SlimefunManager.isItemSimiliar(slot0, SlimefunGuide.getItem(SlimefunGuideLayout.CHEST), true)|| + SlimefunManager.isItemSimilar(slot0, SlimefunGuide.getItem(SlimefunGuideLayout.BOOK), true) || + SlimefunManager.isItemSimilar(slot0, SlimefunGuide.getItem(SlimefunGuideLayout.CHEST), true)|| - SlimefunManager.isItemSimiliar(slot1, SlimefunGuide.getItem(SlimefunGuideLayout.BOOK), true) || - SlimefunManager.isItemSimiliar(slot1, SlimefunGuide.getItem(SlimefunGuideLayout.CHEST), true)) { + SlimefunManager.isItemSimilar(slot1, SlimefunGuide.getItem(SlimefunGuideLayout.BOOK), true) || + SlimefunManager.isItemSimilar(slot1, SlimefunGuide.getItem(SlimefunGuideLayout.CHEST), true)) { e.setCancelled(true); SlimefunPlugin.getLocal().sendMessage((Player) e.getWhoClicked(), "anvil.not-working", true); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/listeners/PlayerQuitListener.java b/src/main/java/me/mrCookieSlime/Slimefun/listeners/PlayerQuitListener.java index ca89c98b8..943caa724 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/listeners/PlayerQuitListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/listeners/PlayerQuitListener.java @@ -12,8 +12,7 @@ public class PlayerQuitListener implements Listener { public PlayerQuitListener(SlimefunPlugin plugin) { plugin.getServer().getPluginManager().registerEvents(this, plugin); } - - @SuppressWarnings("deprecation") + @EventHandler public void onDisconnect(PlayerQuitEvent e) { if (PlayerProfile.isLoaded(e.getPlayer().getUniqueId())) { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/listeners/TalismanListener.java b/src/main/java/me/mrCookieSlime/Slimefun/listeners/TalismanListener.java index f532e2fa0..9b2671a9a 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/listeners/TalismanListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/listeners/TalismanListener.java @@ -49,7 +49,7 @@ public class TalismanListener implements Listener { @EventHandler(priority=EventPriority.MONITOR) public void onDamageGet(EntityDamageEvent e) { if (!e.isCancelled()) { - if (e instanceof EntityDamageByEntityEvent && ((EntityDamageByEntityEvent) e).getDamager() instanceof Player && random.nextInt(100) < 45 && SlimefunManager.isItemSimiliar(((Player) ((EntityDamageByEntityEvent) e).getDamager()).getInventory().getItemInMainHand(), SlimefunItems.BLADE_OF_VAMPIRES, true)) { + if (e instanceof EntityDamageByEntityEvent && ((EntityDamageByEntityEvent) e).getDamager() instanceof Player && random.nextInt(100) < 45 && SlimefunManager.isItemSimilar(((Player) ((EntityDamageByEntityEvent) e).getDamager()).getInventory().getItemInMainHand(), SlimefunItems.BLADE_OF_VAMPIRES, true)) { ((Player) ((EntityDamageByEntityEvent) e).getDamager()).playSound(((EntityDamageByEntityEvent) e).getDamager().getLocation(), Sound.ENTITY_ARROW_HIT_PLAYER, 0.7F, 0.7F); ((Player) ((EntityDamageByEntityEvent) e).getDamager()).addPotionEffect(new PotionEffect(PotionEffectType.HEAL, 1, 1)); } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/listeners/ToolListener.java b/src/main/java/me/mrCookieSlime/Slimefun/listeners/ToolListener.java index 4430c985b..3393a13a7 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/listeners/ToolListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/listeners/ToolListener.java @@ -4,6 +4,7 @@ import java.util.ArrayList; import java.util.HashSet; import java.util.Iterator; import java.util.List; +import java.util.Optional; import java.util.Random; import java.util.Set; @@ -12,6 +13,8 @@ import org.bukkit.Material; import org.bukkit.Tag; import org.bukkit.block.Block; import org.bukkit.block.BlockFace; +import org.bukkit.block.BlockState; +import org.bukkit.block.TileState; import org.bukkit.enchantments.Enchantment; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; @@ -73,6 +76,13 @@ public class ToolListener implements Listener { e.setCancelled(true); } else { + BlockState state = e.getBlock().getState(); + boolean supportsPersistentData = state instanceof TileState; + + if (supportsPersistentData) { + SlimefunPlugin.getBlockDataService().setBlockData((TileState) state, sfItem.getID()); + } + BlockStorage.addBlockInfo(e.getBlock(), "id", sfItem.getID(), true); SlimefunBlockHandler blockHandler = utilities.blockHandlers.get(sfItem.getID()); @@ -100,38 +110,38 @@ public class ToolListener implements Listener { if (utilities.cancelPlace.remove(e.getPlayer().getUniqueId())) e.setCancelled(true); - if (SlimefunManager.isItemSimiliar(item, SlimefunItems.BASIC_CIRCUIT_BOARD, true)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.ADVANCED_CIRCUIT_BOARD, true)) e.setCancelled(true); + if (SlimefunManager.isItemSimilar(item, SlimefunItems.BASIC_CIRCUIT_BOARD, true)) e.setCancelled(true); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.ADVANCED_CIRCUIT_BOARD, true)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.PORTABLE_CRAFTER, true)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.PORTABLE_DUSTBIN, true)) e.setCancelled(true); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.PORTABLE_CRAFTER, true)) e.setCancelled(true); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.PORTABLE_DUSTBIN, true)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.BACKPACK_SMALL, false)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.BACKPACK_MEDIUM, false)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.BACKPACK_LARGE, false)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.WOVEN_BACKPACK, false)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.GILDED_BACKPACK, false)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.RADIANT_BACKPACK, false)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.BOUND_BACKPACK, false)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.COOLER, false)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.ENDER_BACKPACK, false)) e.setCancelled(true); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.BACKPACK_SMALL, false)) e.setCancelled(true); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.BACKPACK_MEDIUM, false)) e.setCancelled(true); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.BACKPACK_LARGE, false)) e.setCancelled(true); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.WOVEN_BACKPACK, false)) e.setCancelled(true); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.GILDED_BACKPACK, false)) e.setCancelled(true); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.RADIANT_BACKPACK, false)) e.setCancelled(true); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.BOUND_BACKPACK, false)) e.setCancelled(true); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.COOLER, false)) e.setCancelled(true); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.ENDER_BACKPACK, false)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.CARBON, false)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.COMPRESSED_CARBON, false)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.CARBON_CHUNK, false)) e.setCancelled(true); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.CARBON, false)) e.setCancelled(true); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.COMPRESSED_CARBON, false)) e.setCancelled(true); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.CARBON_CHUNK, false)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.ANDROID_MEMORY_CORE, false)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.LAVA_CRYSTAL, false)) e.setCancelled(true); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.ANDROID_MEMORY_CORE, false)) e.setCancelled(true); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.LAVA_CRYSTAL, false)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.TINY_URANIUM, false)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.SMALL_URANIUM, false)) e.setCancelled(true); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.TINY_URANIUM, false)) e.setCancelled(true); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.SMALL_URANIUM, false)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.BROKEN_SPAWNER, false)) e.setCancelled(true); - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.GPS_MARKER_TOOL, true)) { + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.BROKEN_SPAWNER, false)) e.setCancelled(true); + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.GPS_MARKER_TOOL, true)) { e.setCancelled(true); Slimefun.getGPSNetwork().addWaypoint(e.getPlayer(), e.getBlock().getLocation()); } - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.CHRISTMAS_PRESENT, false)) { + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.CHRISTMAS_PRESENT, false)) { e.setCancelled(true); if (e.getPlayer().getGameMode() != GameMode.CREATIVE) { @@ -156,25 +166,25 @@ public class ToolListener implements Listener { e.getBlockPlaced().getWorld().dropItemNaturally(e.getBlockPlaced().getLocation(), gifts.get(random.nextInt(gifts.size()))); } - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.CARGO_INPUT, false)) { + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.CARGO_INPUT, false)) { if (e.getBlock().getY() != e.getBlockAgainst().getY()) { SlimefunPlugin.getLocal().sendMessage(e.getPlayer(), "machines.CARGO_NODES.must-be-placed", true); e.setCancelled(true); } } - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.CARGO_OUTPUT, false)) { + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.CARGO_OUTPUT, false)) { if (e.getBlock().getY() != e.getBlockAgainst().getY()) { SlimefunPlugin.getLocal().sendMessage(e.getPlayer(), "machines.CARGO_NODES.must-be-placed", true); e.setCancelled(true); } } - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.CARGO_OUTPUT_ADVANCED, false)) { + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.CARGO_OUTPUT_ADVANCED, false)) { if (e.getBlock().getY() != e.getBlockAgainst().getY()) { SlimefunPlugin.getLocal().sendMessage(e.getPlayer(), "machines.CARGO_NODES.must-be-placed", true); e.setCancelled(true); } } - else if (SlimefunManager.isItemSimiliar(item, SlimefunItems.CT_IMPORT_BUS, false) && e.getBlock().getY() != e.getBlockAgainst().getY()) { + else if (SlimefunManager.isItemSimilar(item, SlimefunItems.CT_IMPORT_BUS, false) && e.getBlock().getY() != e.getBlockAgainst().getY()) { SlimefunPlugin.getLocal().sendMessage(e.getPlayer(), "machines.CARGO_NODES.must-be-placed", true); e.setCancelled(true); } @@ -192,6 +202,17 @@ public class ToolListener implements Listener { if (sensitiveMaterials.contains(block2.getType())) { SlimefunItem sfItem = BlockStorage.check(e.getBlock().getRelative(BlockFace.UP)); + if (sfItem == null) { + BlockState state = block2.getState(); + if (state instanceof TileState) { + Optional blockData = SlimefunPlugin.getBlockDataService().getBlockData((TileState) state); + + if (blockData.isPresent()) { + sfItem = SlimefunItem.getByID(blockData.get()); + } + } + } + if (sfItem != null && !(sfItem instanceof HandledBlock)) { SlimefunBlockHandler blockHandler = utilities.blockHandlers.get(sfItem.getID()); if (blockHandler != null) { @@ -211,6 +232,18 @@ public class ToolListener implements Listener { SlimefunItem sfItem = BlockStorage.check(e.getBlock()); + if (sfItem == null) { + BlockState state = e.getBlock().getState(); + + if (state instanceof TileState) { + Optional blockData = SlimefunPlugin.getBlockDataService().getBlockData((TileState) state); + + if (blockData.isPresent()) { + sfItem = SlimefunItem.getByID(blockData.get()); + } + } + } + if (sfItem != null && !(sfItem instanceof HandledBlock)) { SlimefunBlockHandler blockHandler = utilities.blockHandlers.get(sfItem.getID()); if (blockHandler != null) { @@ -223,7 +256,8 @@ public class ToolListener implements Listener { } } if (allow) { - drops.add(BlockStorage.retrieve(e.getBlock())); + drops.addAll(sfItem.getDrops()); + BlockStorage.clearBlockInfo(e.getBlock()); } else { e.setCancelled(true); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/services/MetricsService.java b/src/main/java/me/mrCookieSlime/Slimefun/services/MetricsService.java deleted file mode 100644 index 5702a3791..000000000 --- a/src/main/java/me/mrCookieSlime/Slimefun/services/MetricsService.java +++ /dev/null @@ -1,27 +0,0 @@ -package me.mrCookieSlime.Slimefun.services; - -import org.bstats.bukkit.Metrics; - -import me.mrCookieSlime.Slimefun.SlimefunPlugin; - -public class MetricsService extends Metrics { - - public MetricsService(SlimefunPlugin plugin) { - super(plugin); - - addCustomChart(new SimplePie("auto_updates", () -> SlimefunPlugin.getCfg().getBoolean("options.auto-update") ? "enabled": "disabled")); - - addCustomChart(new SimplePie("branch", () -> { - if (plugin.getDescription().getVersion().startsWith("DEV - ")) { - return "master"; - } - else if (plugin.getDescription().getVersion().startsWith("RC - ")) { - return "stable"; - } - else { - return "Unknown"; - } - })); - } - -} diff --git a/src/main/java/me/mrCookieSlime/Slimefun/utils/Christmas.java b/src/main/java/me/mrCookieSlime/Slimefun/utils/Christmas.java index 12e80fffd..9d95c283f 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/utils/Christmas.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/utils/Christmas.java @@ -3,13 +3,20 @@ package me.mrCookieSlime.Slimefun.utils; import org.bukkit.ChatColor; import io.github.thebusybiscuit.cscorelib2.chat.ChatColors; +import io.github.thebusybiscuit.slimefun4.core.utils.ChatUtils; +/** + * + * @deprecated This class will be deleted after X-Mas 2019. It will be replaced by {@link ChatUtils#christmas(String)} + * + */ +@Deprecated public final class Christmas { private Christmas() {} public static String color(String text) { - return ChatColors.alternating(text, ChatColor.GREEN, ChatColor.RED); + return ChatColor.RED + ChatColors.alternating(text, ChatColor.GREEN, ChatColor.RED); } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/utils/Utilities.java b/src/main/java/me/mrCookieSlime/Slimefun/utils/Utilities.java index bdb3b3c25..2abb2a563 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/utils/Utilities.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/utils/Utilities.java @@ -1,7 +1,6 @@ package me.mrCookieSlime.Slimefun.utils; import java.util.ArrayList; -import java.util.Date; import java.util.EnumMap; import java.util.HashMap; import java.util.HashSet; @@ -10,15 +9,15 @@ import java.util.List; import java.util.Map; import java.util.Set; import java.util.UUID; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ConcurrentMap; import org.bukkit.Location; import org.bukkit.entity.Entity; import org.bukkit.entity.EntityType; import org.bukkit.inventory.ItemStack; -import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config; +import io.github.thebusybiscuit.cscorelib2.config.Config; +import io.github.thebusybiscuit.slimefun4.core.guide.ISlimefunGuide; +import io.github.thebusybiscuit.slimefun4.core.guide.SlimefunGuideLayout; import me.mrCookieSlime.Slimefun.GEO.OreGenResource; import me.mrCookieSlime.Slimefun.Lists.Categories; import me.mrCookieSlime.Slimefun.Objects.Category; @@ -37,10 +36,6 @@ import me.mrCookieSlime.Slimefun.api.inventory.BlockMenuPreset; import me.mrCookieSlime.Slimefun.api.inventory.UniversalBlockMenu; import me.mrCookieSlime.Slimefun.api.item_transport.CargoTransportEvent; import me.mrCookieSlime.Slimefun.api.item_transport.ItemRequest; -import me.mrCookieSlime.Slimefun.guides.ISlimefunGuide; -import me.mrCookieSlime.Slimefun.guides.SlimefunGuideLayout; -import me.mrCookieSlime.Slimefun.hooks.github.Contributor; -import me.mrCookieSlime.Slimefun.hooks.github.GitHubConnector; /** * Really dirty way to store stuff, but you can dump @@ -61,7 +56,7 @@ public final class Utilities { public final List allMultiblocks = new LinkedList<>(); public final List allResearches = new LinkedList<>(); - public final Map guideLayouts = new HashMap<>(); + public final Map guideLayouts = new EnumMap<>(SlimefunGuideLayout.class); /** * List of the registered Categories. @@ -126,12 +121,9 @@ public final class Utilities { public final Set teleporterUsers = new HashSet<>(); public final Map resources = new HashMap<>(); - public final Map resource_configs = new HashMap<>(); + public final Map resourceConfigs = new HashMap<>(); - public final Set connectors = new HashSet<>(); - public final ConcurrentMap contributors = new ConcurrentHashMap<>(); - - public final List cargoTransportEvents = new ArrayList<>(); + public final Set cargoTransportEvents = new HashSet<>(); public ItemStack[] oreWasherOutputs; @@ -140,36 +132,5 @@ public final class Utilities { * @since 4.0 */ public final Set researching = new HashSet<>(); - - /** - * Represents the current month of the year - */ - public int month = 0; - - /** - * Represents the number of unresolved Issues on the Slimefun4 GitHub repository. - * @since 4.1.13 - */ - public int issues = 0; - - /** - * Represents the number of pending Pull Requests on the Slimefun4 GitHub repository. - */ - public int prs = 0; - - /** - * Represents the number of Forks of the Slimefun4 GitHub repository. - * @since 4.1.13 - */ - public int forks = 0; - - /** - * Represents the number of stars on the Slimefun4 GitHub repository. - * @since 4.1.13 - */ - public int stars = 0; - - public int codeBytes = 0; - public Date lastUpdate = new Date(); } diff --git a/src/main/resources/wiki.json b/src/main/resources/wiki.json index 4f834c1c6..fa3836fcd 100644 --- a/src/main/resources/wiki.json +++ b/src/main/resources/wiki.json @@ -20,5 +20,14 @@ "CHICKEN_JERKY": "Meat-Jerky", "MUTTON_JERKY": "Meat-Jerky", "RABBIT_JERKY": "Meat-Jerky", - "FISH_JERKY": "Meat-Jerky" + "FISH_JERKY": "Meat-Jerky", + "ANCIENT_ALTAR": "Ancient-Altar", + "ANCIENT_PEDESTAL": "Ancient-Pedestal", + "BLADE_OF_VAMPIRES": "Blade-of-Vampires", + "BROKEN_SPAWNER": "Broken-Spawner", + "REPAIRED_SPAWNER": "Reinforced-Spawner", + "NETHER_GOLD_PAN": "Nether-Gold-Pan", + "PICKAXE_OF_CONTAINMENT": "Pickaxe-of-Containment", + "SEISMIC_AXE": "Seismic-Axe", + "SMELTERS_PICKAXE": "Smelter's-Pickaxe" }