From 8b177df6c80556f415fbacb59df9240dc0983579 Mon Sep 17 00:00:00 2001 From: creator3 Date: Mon, 16 Dec 2019 11:15:32 -0500 Subject: [PATCH 1/7] Fix drops in 1.15 --- .../Objects/SlimefunItem/items/ExplosivePickaxe.java | 7 +++++-- .../Objects/SlimefunItem/items/ExplosiveShovel.java | 5 ++++- .../Objects/SlimefunItem/items/HerculesPickaxe.java | 5 ++++- .../Slimefun/Objects/SlimefunItem/items/LumberAxe.java | 5 ++++- .../Objects/SlimefunItem/items/PickaxeOfVeinMining.java | 4 +++- .../Objects/SlimefunItem/items/SmeltersPickaxe.java | 5 +++-- .../me/mrCookieSlime/Slimefun/Setup/SlimefunSetup.java | 5 +++-- .../Slimefun/androids/ProgrammableAndroid.java | 7 +++++-- 8 files changed, 31 insertions(+), 12 deletions(-) diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/ExplosivePickaxe.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/ExplosivePickaxe.java index 91a40afac..fd2a7ae28 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/ExplosivePickaxe.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/ExplosivePickaxe.java @@ -26,7 +26,10 @@ import me.mrCookieSlime.Slimefun.api.Slimefun; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class ExplosivePickaxe extends SimpleSlimefunItem implements NotPlaceable, DamageableItem { - + + // Determines the drops an ExplosivePickaxe will get + private static final ItemStack EFFECTIVE_PICKAXE = new ItemStack(Material.DIAMOND_PICKAXE); + private String[] blacklist; private boolean damageOnUse; @@ -77,7 +80,7 @@ public class ExplosivePickaxe extends SimpleSlimefunItem impl b.breakNaturally(); } else { - for (ItemStack drop: b.getDrops()) { + for (ItemStack drop: b.getDrops(EFFECTIVE_PICKAXE)) { b.getWorld().dropItemNaturally(b.getLocation(), (b.getType().toString().endsWith("_ORE") && b.getType() != Material.IRON_ORE && b.getType() != Material.GOLD_ORE) ? new CustomItem(drop, fortune): drop); } b.setType(Material.AIR); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/ExplosiveShovel.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/ExplosiveShovel.java index df9135640..bc2bc4ff4 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/ExplosiveShovel.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/ExplosiveShovel.java @@ -20,6 +20,9 @@ import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class ExplosiveShovel extends SimpleSlimefunItem implements NotPlaceable, DamageableItem { + // Determines the drops an ExplosiveShovel will get + private static final ItemStack EFFECTIVE_SHOVEL = new ItemStack(Material.DIAMOND_SHOVEL); + private boolean damageOnUse; public ExplosiveShovel(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe, String[] keys, Object[] values) { @@ -52,7 +55,7 @@ public class ExplosiveShovel extends SimpleSlimefunItem imple b.getWorld().playEffect(b.getLocation(), Effect.STEP_SOUND, b.getType()); - for (ItemStack drop: b.getDrops()) { + for (ItemStack drop: b.getDrops(EFFECTIVE_SHOVEL)) { if (drop != null) { b.getWorld().dropItemNaturally(b.getLocation(), drop); } 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 31b47e13c..b50e15eb6 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 @@ -13,6 +13,9 @@ import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class HerculesPickaxe extends SimpleSlimefunItem { + // Determines the drops a HerculesPickaxe will get + private static final ItemStack EFFECTIVE_PICKAXE = new ItemStack(Material.DIAMOND_PICKAXE); + public HerculesPickaxe(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) { super(category, item, recipeType, recipe); } @@ -33,7 +36,7 @@ public class HerculesPickaxe extends SimpleSlimefunItem { drops.add(new CustomItem(SlimefunItems.GOLD_DUST, 2)); } else { - for (ItemStack drop: e.getBlock().getDrops()) { + for (ItemStack drop: e.getBlock().getDrops(EFFECTIVE_PICKAXE)) { drops.add(new CustomItem(drop, drop.getAmount() * 2)); } } 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 f458df373..7874d0400 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 @@ -20,6 +20,9 @@ import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class LumberAxe extends SimpleSlimefunItem implements NotPlaceable { + // Determines the drops a LumberAxe will get + private static final ItemStack EFFECTIVE_AXE = new ItemStack(Material.DIAMOND_AXE); + public LumberAxe(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) { super(category, item, recipeType, recipe); } @@ -44,7 +47,7 @@ public class LumberAxe extends SimpleSlimefunItem implements if (SlimefunPlugin.getProtectionManager().hasPermission(e.getPlayer(), b, ProtectableAction.BREAK_BLOCK)) { b.getWorld().playEffect(b.getLocation(), Effect.STEP_SOUND, b.getType()); - for (ItemStack drop: b.getDrops()) { + for (ItemStack drop: b.getDrops(EFFECTIVE_AXE)) { b.getWorld().dropItemNaturally(b.getLocation(), drop); } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/PickaxeOfVeinMining.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/PickaxeOfVeinMining.java index 08b1235d9..22e59a4ad 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/PickaxeOfVeinMining.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/PickaxeOfVeinMining.java @@ -19,6 +19,8 @@ import me.mrCookieSlime.Slimefun.Objects.handlers.BlockBreakHandler; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class PickaxeOfVeinMining extends SimpleSlimefunItem { + // Determines the drops a PickaxeOfVeinMining will get + private static final ItemStack EFFECTIVE_PICKAXE = new ItemStack(Material.DIAMOND_PICKAXE); public PickaxeOfVeinMining(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) { super(category, item, recipeType, recipe); @@ -40,7 +42,7 @@ public class PickaxeOfVeinMining extends SimpleSlimefunItem { if (SlimefunPlugin.getProtectionManager().hasPermission(e.getPlayer(), b.getLocation(), ProtectableAction.BREAK_BLOCK)) { b.getWorld().playEffect(b.getLocation(), Effect.STEP_SOUND, b.getType()); - for (ItemStack drop: b.getDrops()) { + for (ItemStack drop: b.getDrops(EFFECTIVE_PICKAXE)) { b.getWorld().dropItemNaturally(b.getLocation(), drop.getType().isBlock() ? drop: new CustomItem(drop, fortune)); } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/SmeltersPickaxe.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/SmeltersPickaxe.java index 890d99395..1b888d66f 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/SmeltersPickaxe.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/SmeltersPickaxe.java @@ -18,7 +18,8 @@ import me.mrCookieSlime.Slimefun.api.BlockStorage; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class SmeltersPickaxe extends SimpleSlimefunItem { - + // Determines the drops a SmeltersPickaxe will get + private static final ItemStack EFFECTIVE_PICKAXE = new ItemStack(Material.DIAMOND_PICKAXE); public SmeltersPickaxe(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) { super(category, item, recipeType, recipe); } @@ -35,7 +36,7 @@ public class SmeltersPickaxe extends SimpleSlimefunItem { if (BlockStorage.hasBlockInfo(e.getBlock())) return true; if (e.getBlock().getType() == Material.PLAYER_HEAD) return true; - Collection blockDrops = e.getBlock().getDrops(); + Collection blockDrops = e.getBlock().getDrops(EFFECTIVE_PICKAXE); for (ItemStack drop: blockDrops) { if (drop != null) { ItemStack output = drop; diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Setup/SlimefunSetup.java b/src/main/java/me/mrCookieSlime/Slimefun/Setup/SlimefunSetup.java index 5dc2dbda1..6396d922c 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Setup/SlimefunSetup.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Setup/SlimefunSetup.java @@ -1092,7 +1092,8 @@ public final class SlimefunSetup { new ItemStack[] {SlimefunItems.SOLAR_PANEL, new ItemStack(Material.CHEST), SlimefunItems.SOLAR_PANEL, SlimefunItems.GOLD_24K_BLOCK, new ItemStack(Material.DISPENSER), SlimefunItems.GOLD_24K_BLOCK, SlimefunItems.GOLD_24K_BLOCK, new ItemStack(Material.HOPPER), SlimefunItems.GOLD_24K_BLOCK}, new ItemStack[0], BlockFace.SELF) .register(true, new MultiBlockInteractionHandler() { - + // Determines the drops an Advanced Digital Miner will get + private final ItemStack EFFECTIVE_PICKAXE = new ItemStack(Material.DIAMOND_PICKAXE); @Override public boolean onInteract(final Player p, MultiBlock mb, final Block b) { if (mb.isMultiBlock(SlimefunItem.getByID("ADVANCED_DIGITAL_MINER"))) { @@ -1128,7 +1129,7 @@ public final class SlimefunSetup { else if (ore == Material.NETHER_QUARTZ_ORE) drop = new ItemStack(Material.QUARTZ, 4); else if (ore == Material.LAPIS_ORE) drop = new ItemStack(Material.LAPIS_LAZULI, 12); else { - for (ItemStack drops: ores.get(0).getBlock().getDrops()) { + for (ItemStack drops: ores.get(0).getBlock().getDrops(EFFECTIVE_PICKAXE)) { if (!drops.getType().isBlock()) drop = new CustomItem(drops, 2); } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/androids/ProgrammableAndroid.java b/src/main/java/me/mrCookieSlime/Slimefun/androids/ProgrammableAndroid.java index 719d6b028..f004ba676 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/androids/ProgrammableAndroid.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/androids/ProgrammableAndroid.java @@ -74,6 +74,9 @@ import me.mrCookieSlime.Slimefun.api.item_transport.ItemTransportFlow; public abstract class ProgrammableAndroid extends SlimefunItem implements InventoryBlock { + // Determines the drops a miner android will get + private static final ItemStack EFFECTIVE_PICKAXE = new ItemStack(Material.DIAMOND_PICKAXE); + 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}; @@ -497,7 +500,7 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent } private void mine(Block b, BlockMenu menu, Block block) { - Collection drops = block.getDrops(); + Collection drops = block.getDrops(EFFECTIVE_PICKAXE); 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); @@ -532,7 +535,7 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent private void movedig(Block b, BlockMenu menu, BlockFace face, Block block) { - Collection drops = block.getDrops(); + Collection drops = block.getDrops(EFFECTIVE_PICKAXE); 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); From d698840e1f7c5b9e9d9e744d469099586ff0500e Mon Sep 17 00:00:00 2001 From: creator3 Date: Mon, 16 Dec 2019 11:47:47 -0500 Subject: [PATCH 2/7] Use the actual tool item in calls to getDrops() --- .../Objects/SlimefunItem/items/ExplosivePickaxe.java | 5 +---- .../Objects/SlimefunItem/items/ExplosiveShovel.java | 5 +---- .../Objects/SlimefunItem/items/HerculesPickaxe.java | 5 +---- .../Slimefun/Objects/SlimefunItem/items/LumberAxe.java | 5 +---- .../Objects/SlimefunItem/items/PickaxeOfVeinMining.java | 4 +--- .../Objects/SlimefunItem/items/SmeltersPickaxe.java | 7 +++---- 6 files changed, 8 insertions(+), 23 deletions(-) diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/ExplosivePickaxe.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/ExplosivePickaxe.java index fd2a7ae28..214b5f9a4 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/ExplosivePickaxe.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/ExplosivePickaxe.java @@ -27,9 +27,6 @@ import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class ExplosivePickaxe extends SimpleSlimefunItem implements NotPlaceable, DamageableItem { - // Determines the drops an ExplosivePickaxe will get - private static final ItemStack EFFECTIVE_PICKAXE = new ItemStack(Material.DIAMOND_PICKAXE); - private String[] blacklist; private boolean damageOnUse; @@ -80,7 +77,7 @@ public class ExplosivePickaxe extends SimpleSlimefunItem impl b.breakNaturally(); } else { - for (ItemStack drop: b.getDrops(EFFECTIVE_PICKAXE)) { + for (ItemStack drop : b.getDrops(getItem())) { b.getWorld().dropItemNaturally(b.getLocation(), (b.getType().toString().endsWith("_ORE") && b.getType() != Material.IRON_ORE && b.getType() != Material.GOLD_ORE) ? new CustomItem(drop, fortune): drop); } b.setType(Material.AIR); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/ExplosiveShovel.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/ExplosiveShovel.java index bc2bc4ff4..acfc28b3c 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/ExplosiveShovel.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/ExplosiveShovel.java @@ -19,9 +19,6 @@ import me.mrCookieSlime.Slimefun.api.Slimefun; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class ExplosiveShovel extends SimpleSlimefunItem implements NotPlaceable, DamageableItem { - - // Determines the drops an ExplosiveShovel will get - private static final ItemStack EFFECTIVE_SHOVEL = new ItemStack(Material.DIAMOND_SHOVEL); private boolean damageOnUse; @@ -55,7 +52,7 @@ public class ExplosiveShovel extends SimpleSlimefunItem imple b.getWorld().playEffect(b.getLocation(), Effect.STEP_SOUND, b.getType()); - for (ItemStack drop: b.getDrops(EFFECTIVE_SHOVEL)) { + for (ItemStack drop : b.getDrops(getItem())) { if (drop != null) { b.getWorld().dropItemNaturally(b.getLocation(), drop); } 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 b50e15eb6..25cc5526f 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 @@ -13,9 +13,6 @@ import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class HerculesPickaxe extends SimpleSlimefunItem { - // Determines the drops a HerculesPickaxe will get - private static final ItemStack EFFECTIVE_PICKAXE = new ItemStack(Material.DIAMOND_PICKAXE); - public HerculesPickaxe(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) { super(category, item, recipeType, recipe); } @@ -36,7 +33,7 @@ public class HerculesPickaxe extends SimpleSlimefunItem { drops.add(new CustomItem(SlimefunItems.GOLD_DUST, 2)); } else { - for (ItemStack drop: e.getBlock().getDrops(EFFECTIVE_PICKAXE)) { + for (ItemStack drop : e.getBlock().getDrops(getItem())) { drops.add(new CustomItem(drop, drop.getAmount() * 2)); } } 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 7874d0400..3caedc1b9 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 @@ -20,9 +20,6 @@ import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class LumberAxe extends SimpleSlimefunItem implements NotPlaceable { - // Determines the drops a LumberAxe will get - private static final ItemStack EFFECTIVE_AXE = new ItemStack(Material.DIAMOND_AXE); - public LumberAxe(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) { super(category, item, recipeType, recipe); } @@ -47,7 +44,7 @@ public class LumberAxe extends SimpleSlimefunItem implements if (SlimefunPlugin.getProtectionManager().hasPermission(e.getPlayer(), b, ProtectableAction.BREAK_BLOCK)) { b.getWorld().playEffect(b.getLocation(), Effect.STEP_SOUND, b.getType()); - for (ItemStack drop: b.getDrops(EFFECTIVE_AXE)) { + for (ItemStack drop : b.getDrops(getItem())) { b.getWorld().dropItemNaturally(b.getLocation(), drop); } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/PickaxeOfVeinMining.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/PickaxeOfVeinMining.java index 22e59a4ad..acce5e190 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/PickaxeOfVeinMining.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/PickaxeOfVeinMining.java @@ -19,8 +19,6 @@ import me.mrCookieSlime.Slimefun.Objects.handlers.BlockBreakHandler; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class PickaxeOfVeinMining extends SimpleSlimefunItem { - // Determines the drops a PickaxeOfVeinMining will get - private static final ItemStack EFFECTIVE_PICKAXE = new ItemStack(Material.DIAMOND_PICKAXE); public PickaxeOfVeinMining(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) { super(category, item, recipeType, recipe); @@ -42,7 +40,7 @@ public class PickaxeOfVeinMining extends SimpleSlimefunItem { if (SlimefunPlugin.getProtectionManager().hasPermission(e.getPlayer(), b.getLocation(), ProtectableAction.BREAK_BLOCK)) { b.getWorld().playEffect(b.getLocation(), Effect.STEP_SOUND, b.getType()); - for (ItemStack drop: b.getDrops(EFFECTIVE_PICKAXE)) { + for (ItemStack drop : b.getDrops(getItem())) { b.getWorld().dropItemNaturally(b.getLocation(), drop.getType().isBlock() ? drop: new CustomItem(drop, fortune)); } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/SmeltersPickaxe.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/SmeltersPickaxe.java index 1b888d66f..ae9717fca 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/SmeltersPickaxe.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/items/SmeltersPickaxe.java @@ -18,8 +18,7 @@ import me.mrCookieSlime.Slimefun.api.BlockStorage; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class SmeltersPickaxe extends SimpleSlimefunItem { - // Determines the drops a SmeltersPickaxe will get - private static final ItemStack EFFECTIVE_PICKAXE = new ItemStack(Material.DIAMOND_PICKAXE); + public SmeltersPickaxe(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) { super(category, item, recipeType, recipe); } @@ -36,8 +35,8 @@ public class SmeltersPickaxe extends SimpleSlimefunItem { if (BlockStorage.hasBlockInfo(e.getBlock())) return true; if (e.getBlock().getType() == Material.PLAYER_HEAD) return true; - Collection blockDrops = e.getBlock().getDrops(EFFECTIVE_PICKAXE); - for (ItemStack drop: blockDrops) { + Collection blockDrops = e.getBlock().getDrops(getItem()); + for (ItemStack drop : blockDrops) { if (drop != null) { ItemStack output = drop; From 989ed45a02993b3eb1bff19fad73b5abd4452eb2 Mon Sep 17 00:00:00 2001 From: TheBusyBiscuit Date: Tue, 17 Dec 2019 00:18:04 +0100 Subject: [PATCH 3/7] Added Salt to the GEO Miner (and reduced technical debt) --- .../core/guide/BookSlimefunGuide.java | 2 +- .../core/guide/ChestSlimefunGuide.java | 9 +-- .../slimefun4/core/guide/GuideSettings.java | 2 +- .../github/ContributionsConnector.java | 3 +- .../core/services/github/GitHubService.java | 1 + .../core/services/github/GitHubTask.java | 61 ++++++++++++++++ .../geo}/resources/NetherIceResource.java | 2 +- .../geo}/resources/OilResource.java | 14 +++- .../geo/resources/SaltResource.java | 73 +++++++++++++++++++ .../geo}/resources/UraniumResource.java | 7 +- .../Slimefun/SlimefunPlugin.java | 44 ++--------- 11 files changed, 165 insertions(+), 53 deletions(-) create mode 100644 src/main/java/io/github/thebusybiscuit/slimefun4/core/services/github/GitHubTask.java rename src/main/java/{me/mrCookieSlime/Slimefun/GEO => io/github/thebusybiscuit/slimefun4/implementation/geo}/resources/NetherIceResource.java (89%) rename src/main/java/{me/mrCookieSlime/Slimefun/GEO => io/github/thebusybiscuit/slimefun4/implementation/geo}/resources/OilResource.java (82%) create mode 100644 src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/SaltResource.java rename src/main/java/{me/mrCookieSlime/Slimefun/GEO => io/github/thebusybiscuit/slimefun4/implementation/geo}/resources/UraniumResource.java (82%) diff --git a/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/BookSlimefunGuide.java b/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/BookSlimefunGuide.java index 0623e3c3c..a967d3e2d 100644 --- a/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/BookSlimefunGuide.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/BookSlimefunGuide.java @@ -11,11 +11,11 @@ import org.bukkit.inventory.ItemStack; import io.github.thebusybiscuit.cscorelib2.chat.ChatColors; import io.github.thebusybiscuit.cscorelib2.inventory.ItemUtils; +import io.github.thebusybiscuit.cscorelib2.item.CustomItem; 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.Slimefun.SlimefunGuide; import me.mrCookieSlime.Slimefun.SlimefunPlugin; import me.mrCookieSlime.Slimefun.Objects.Category; diff --git a/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/ChestSlimefunGuide.java b/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/ChestSlimefunGuide.java index 8d5f51e3a..83ccce0e0 100644 --- a/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/ChestSlimefunGuide.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/ChestSlimefunGuide.java @@ -24,6 +24,7 @@ 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 io.github.thebusybiscuit.slimefun4.core.utils.ChatUtils; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.ChestMenu; import me.mrCookieSlime.Slimefun.SlimefunGuide; import me.mrCookieSlime.Slimefun.SlimefunPlugin; @@ -429,9 +430,7 @@ public class ChestSlimefunGuide implements ISlimefunGuide { menu.addItem(8, new CustomItem(Material.KNOWLEDGE_BOOK, "&rView this Item on our Wiki &7(Slimefun Wiki)", "", "&7\u21E8 Click to open")); menu.addMenuClickHandler(8, (pl, slot, itemstack, action) -> { pl.closeInventory(); - pl.sendMessage(""); - pl.sendMessage(ChatColor.translateAlternateColorCodes('&', "&7&o" + item.getWiki())); - pl.sendMessage(""); + ChatUtils.sendURL(pl, item.getWiki()); return false; }); } catch (Exception x) { @@ -444,9 +443,7 @@ public class ChestSlimefunGuide implements ISlimefunGuide { 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(""); - pl.sendMessage(ChatColor.translateAlternateColorCodes('&', "&7&o" + Slimefun.getItemConfig().getString(item.getID() + ".youtube"))); - pl.sendMessage(""); + ChatUtils.sendURL(pl, Slimefun.getItemConfig().getString(item.getID() + ".youtube")); return false; }); } catch (Exception x) { diff --git a/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/GuideSettings.java b/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/GuideSettings.java index c7f19ffb4..be94d96ce 100644 --- a/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/GuideSettings.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/core/guide/GuideSettings.java @@ -15,13 +15,13 @@ import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.SkullMeta; import io.github.thebusybiscuit.cscorelib2.chat.ChatColors; +import io.github.thebusybiscuit.cscorelib2.item.CustomItem; 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.Slimefun.SlimefunGuide; import me.mrCookieSlime.Slimefun.SlimefunPlugin; import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; diff --git a/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/github/ContributionsConnector.java b/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/github/ContributionsConnector.java index 1b2af8543..66a1ca814 100644 --- a/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/github/ContributionsConnector.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/github/ContributionsConnector.java @@ -16,9 +16,8 @@ public class ContributionsConnector extends GitHubConnector { private static final List blacklist = Arrays.asList( "invalid-email-address", "renovate-bot", - "ImgBotApp", "TheBusyBot", - "imgbot" + "imgbot[bot]" ); // Matches a GitHub name with a Minecraft name. 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 index 52fc2c2a4..f43d6ec61 100644 --- 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 @@ -78,6 +78,7 @@ public class GitHubService { for (JsonElement elem : array) { JsonObject obj = elem.getAsJsonObject(); + if (obj.has("pull_request")) prCount++; else issueCount++; } diff --git a/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/github/GitHubTask.java b/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/github/GitHubTask.java new file mode 100644 index 000000000..4aa57e209 --- /dev/null +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/core/services/github/GitHubTask.java @@ -0,0 +1,61 @@ +package io.github.thebusybiscuit.slimefun4.core.services.github; + +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; +import java.util.UUID; + +import io.github.thebusybiscuit.cscorelib2.players.MinecraftAccount; +import io.github.thebusybiscuit.cscorelib2.players.MinecraftAccount.TooManyRequestsException; + +public class GitHubTask implements Runnable { + + private final GitHubService gitHubService; + + public GitHubTask(GitHubService github) { + gitHubService = github; + } + + @Override + public void run() { + gitHubService.getConnectors().forEach(GitHubConnector::pullFile); + + // Store all queried usernames to prevent 429 responses for pinging the + // same URL twice in one run. + Map skins = new HashMap<>(); + + for (Contributor contributor : gitHubService.getContributors().values()) { + if (!contributor.hasTexture()) { + try { + if (skins.containsKey(contributor.getMinecraftName())) { + contributor.setTexture(Optional.of(skins.get(contributor.getMinecraftName()))); + } + else { + contributor.setTexture(grabTexture(skins, contributor.getMinecraftName())); + } + } + 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; + } + } + } + } + + private Optional grabTexture(Map skins, String username) throws TooManyRequestsException { + Optional uuid = MinecraftAccount.getUUID(username); + + if (uuid.isPresent()) { + Optional skin = MinecraftAccount.getSkin(uuid.get()); + skins.put(username, skin.orElse("")); + return skin; + } + else { + return Optional.empty(); + } + } + +} diff --git a/src/main/java/me/mrCookieSlime/Slimefun/GEO/resources/NetherIceResource.java b/src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/NetherIceResource.java similarity index 89% rename from src/main/java/me/mrCookieSlime/Slimefun/GEO/resources/NetherIceResource.java rename to src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/NetherIceResource.java index 514db45e1..018bfe6c7 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/GEO/resources/NetherIceResource.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/NetherIceResource.java @@ -1,4 +1,4 @@ -package me.mrCookieSlime.Slimefun.GEO.resources; +package io.github.thebusybiscuit.slimefun4.implementation.geo.resources; import org.bukkit.block.Biome; import org.bukkit.inventory.ItemStack; diff --git a/src/main/java/me/mrCookieSlime/Slimefun/GEO/resources/OilResource.java b/src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/OilResource.java similarity index 82% rename from src/main/java/me/mrCookieSlime/Slimefun/GEO/resources/OilResource.java rename to src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/OilResource.java index 6945f7a2d..ed98083a4 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/GEO/resources/OilResource.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/OilResource.java @@ -1,6 +1,7 @@ -package me.mrCookieSlime.Slimefun.GEO.resources; +package io.github.thebusybiscuit.slimefun4.implementation.geo.resources; import java.util.Random; +import java.util.concurrent.ThreadLocalRandom; import org.bukkit.block.Biome; import org.bukkit.inventory.ItemStack; @@ -10,10 +11,10 @@ import me.mrCookieSlime.Slimefun.Lists.SlimefunItems; public class OilResource implements OreGenResource { - private final Random random = new Random(); - @Override public int getDefaultSupply(Biome biome) { + Random random = ThreadLocalRandom.current(); + switch (biome) { case SNOWY_BEACH: case STONE_SHORE: @@ -55,6 +56,13 @@ public class OilResource implements OreGenResource { case DEEP_OCEAN: case OCEAN: + case COLD_OCEAN: + case DEEP_COLD_OCEAN: + case DEEP_FROZEN_OCEAN: + case DEEP_LUKEWARM_OCEAN: + case DEEP_WARM_OCEAN: + case LUKEWARM_OCEAN: + case WARM_OCEAN: return random.nextInt(62) + 24; case SWAMP: diff --git a/src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/SaltResource.java b/src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/SaltResource.java new file mode 100644 index 000000000..63e72d64c --- /dev/null +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/SaltResource.java @@ -0,0 +1,73 @@ +package io.github.thebusybiscuit.slimefun4.implementation.geo.resources; + +import java.util.Random; +import java.util.concurrent.ThreadLocalRandom; + +import org.bukkit.block.Biome; +import org.bukkit.inventory.ItemStack; + +import me.mrCookieSlime.Slimefun.GEO.OreGenResource; +import me.mrCookieSlime.Slimefun.Lists.SlimefunItems; + +public class SaltResource implements OreGenResource { + + @Override + public int getDefaultSupply(Biome biome) { + Random random = ThreadLocalRandom.current(); + + switch (biome) { + case SNOWY_BEACH: + case STONE_SHORE: + case BEACH: + case DESERT_LAKES: + case RIVER: + case ICE_SPIKES: + case FROZEN_RIVER: + return random.nextInt(40) + 3; + + case DEEP_OCEAN: + case OCEAN: + case COLD_OCEAN: + case DEEP_COLD_OCEAN: + case DEEP_FROZEN_OCEAN: + case DEEP_LUKEWARM_OCEAN: + case DEEP_WARM_OCEAN: + case FROZEN_OCEAN: + case LUKEWARM_OCEAN: + case WARM_OCEAN: + return random.nextInt(60) + 24; + + case SWAMP: + case SWAMP_HILLS: + return random.nextInt(20) + 4; + + case THE_END: + case NETHER: + return 0; + + default: + return random.nextInt(6) + 4; + } + } + + @Override + public String getName() { + return "Salt"; + } + + @Override + public ItemStack getIcon() { + return SlimefunItems.SALT.clone(); + } + + @Override + public String getMeasurementUnit() { + return "Crystal(s)"; + } + + @Override + public boolean isLiquid() { + return false; + } + +} diff --git a/src/main/java/me/mrCookieSlime/Slimefun/GEO/resources/UraniumResource.java b/src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/UraniumResource.java similarity index 82% rename from src/main/java/me/mrCookieSlime/Slimefun/GEO/resources/UraniumResource.java rename to src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/UraniumResource.java index d60be82ee..8f3ff850d 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/GEO/resources/UraniumResource.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/UraniumResource.java @@ -1,6 +1,7 @@ -package me.mrCookieSlime.Slimefun.GEO.resources; +package io.github.thebusybiscuit.slimefun4.implementation.geo.resources; import java.util.Random; +import java.util.concurrent.ThreadLocalRandom; import org.bukkit.block.Biome; import org.bukkit.inventory.ItemStack; @@ -10,10 +11,10 @@ import me.mrCookieSlime.Slimefun.Lists.SlimefunItems; public class UraniumResource implements OreGenResource { - private final Random random = new Random(); - @Override public int getDefaultSupply(Biome biome) { + Random random = ThreadLocalRandom.current(); + switch (biome) { case THE_END: case END_BARRENS: diff --git a/src/main/java/me/mrCookieSlime/Slimefun/SlimefunPlugin.java b/src/main/java/me/mrCookieSlime/Slimefun/SlimefunPlugin.java index 8b5f18f23..2ea2285a6 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/SlimefunPlugin.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/SlimefunPlugin.java @@ -1,8 +1,6 @@ package me.mrCookieSlime.Slimefun; import java.io.File; -import java.util.Optional; -import java.util.UUID; import java.util.logging.Level; import org.bukkit.Bukkit; @@ -11,8 +9,6 @@ import org.bukkit.entity.Player; import org.bukkit.inventory.ItemStack; import org.bukkit.plugin.java.JavaPlugin; -import io.github.thebusybiscuit.cscorelib2.players.MinecraftAccount; -import io.github.thebusybiscuit.cscorelib2.players.MinecraftAccount.TooManyRequestsException; import io.github.thebusybiscuit.cscorelib2.protection.ProtectionManager; import io.github.thebusybiscuit.cscorelib2.recipes.RecipeSnapshot; import io.github.thebusybiscuit.cscorelib2.reflection.ReflectionUtils; @@ -23,16 +19,16 @@ 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 io.github.thebusybiscuit.slimefun4.core.services.github.GitHubTask; +import io.github.thebusybiscuit.slimefun4.implementation.geo.resources.NetherIceResource; +import io.github.thebusybiscuit.slimefun4.implementation.geo.resources.OilResource; +import io.github.thebusybiscuit.slimefun4.implementation.geo.resources.SaltResource; +import io.github.thebusybiscuit.slimefun4.implementation.geo.resources.UraniumResource; import me.mrCookieSlime.CSCoreLibPlugin.CSCoreLib; import me.mrCookieSlime.CSCoreLibPlugin.PluginUtils; import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config; import me.mrCookieSlime.Slimefun.GEO.OreGenSystem; -import me.mrCookieSlime.Slimefun.GEO.resources.NetherIceResource; -import me.mrCookieSlime.Slimefun.GEO.resources.OilResource; -import me.mrCookieSlime.Slimefun.GEO.resources.UraniumResource; import me.mrCookieSlime.Slimefun.GPS.GPSNetwork; import me.mrCookieSlime.Slimefun.Lists.SlimefunItems; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem; @@ -232,10 +228,11 @@ public final class SlimefunPlugin extends JavaPlugin { getLogger().log(Level.INFO, "Loading World Generators..."); - // Generating Oil as an OreGenResource (its a cool API) + // Generating Oil as an OreGenResource (it iss a cool API) OreGenSystem.registerResource(new OilResource()); OreGenSystem.registerResource(new NetherIceResource()); OreGenSystem.registerResource(new UraniumResource()); + OreGenSystem.registerResource(new SaltResource()); // Setting up GitHub Connectors... gitHubService.connect(config.getBoolean("options.print-out-github-data-retrieving")); @@ -308,32 +305,7 @@ public final class SlimefunPlugin extends JavaPlugin { } }, 100L, config.getInt("URID.custom-ticker-delay")); - getServer().getScheduler().runTaskTimerAsynchronously(this, () -> { - gitHubService.getConnectors().forEach(GitHubConnector::pullFile); - - for (Contributor contributor : gitHubService.getContributors().values()) { - if (!contributor.hasTexture()) { - try { - Optional uuid = MinecraftAccount.getUUID(contributor.getMinecraftName()); - - if (uuid.isPresent()) { - Optional skin = MinecraftAccount.getSkin(uuid.get()); - contributor.setTexture(skin); - } - else { - 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; - } - } - } - }, 80L, 60 * 60 * 20L); + getServer().getScheduler().runTaskTimerAsynchronously(this, new GitHubTask(gitHubService), 80L, 60 * 60 * 20L); // Hooray! getLogger().log(Level.INFO, "Finished!"); From 59fb83e871d28aa52a2cf95ffea4cccede7d0de4 Mon Sep 17 00:00:00 2001 From: TheBusyBiscuit Date: Tue, 17 Dec 2019 00:44:41 +0100 Subject: [PATCH 4/7] [CI skip] Removed CS-CoreLib Auto-Installer and reduced technical debt --- .../geo/resources/NetherIceResource.java | 2 +- .../geo/resources/OilResource.java | 2 +- .../geo/resources/UraniumResource.java | 2 +- .../Slimefun/GEO/GEOScanner.java | 4 +- .../Slimefun/Objects/Category.java | 16 -- .../Slimefun/Objects/LockedCategory.java | 8 +- .../Slimefun/Objects/Research.java | 34 +--- .../Slimefun/Objects/SeasonalCategory.java | 8 +- .../Slimefun/Setup/CSCoreLibLoader.java | 161 ------------------ .../Slimefun/SlimefunPlugin.java | 18 +- .../Slimefun/ancient_altar/AltarRecipe.java | 6 +- .../ancient_altar/AncientAltarListener.java | 4 +- .../Slimefun/ancient_altar/Pedestals.java | 5 +- .../ancient_altar/RitualAnimation.java | 4 +- .../Slimefun/autosave/BlockAutoSaver.java | 2 +- .../Slimefun/commands/SlimefunCommand.java | 5 +- .../commands/SlimefunTabCompleter.java | 4 + .../Slimefun/hooks/WorldEditHook.java | 3 + .../listeners/AndroidKillingListener.java | 7 +- .../listeners/AutonomousToolsListener.java | 2 +- .../Slimefun/listeners/BackpackListener.java | 1 + .../Slimefun/listeners/BlockListener.java | 6 +- .../Slimefun/listeners/BowListener.java | 28 +-- .../Slimefun/listeners/CoolerListener.java | 4 +- .../Slimefun/listeners/ItemListener.java | 4 +- .../Slimefun/listeners/TalismanListener.java | 14 +- .../listeners/TeleporterListener.java | 2 +- .../Slimefun/listeners/ToolListener.java | 6 +- 28 files changed, 97 insertions(+), 265 deletions(-) delete mode 100644 src/main/java/me/mrCookieSlime/Slimefun/Setup/CSCoreLibLoader.java diff --git a/src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/NetherIceResource.java b/src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/NetherIceResource.java index 018bfe6c7..5a8d44761 100644 --- a/src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/NetherIceResource.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/NetherIceResource.java @@ -25,7 +25,7 @@ public class NetherIceResource implements OreGenResource { @Override public String getMeasurementUnit() { - return "Blocks"; + return "Block(s)"; } @Override diff --git a/src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/OilResource.java b/src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/OilResource.java index ed98083a4..35b0ac04e 100644 --- a/src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/OilResource.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/OilResource.java @@ -86,7 +86,7 @@ public class OilResource implements OreGenResource { @Override public String getMeasurementUnit() { - return "Buckets"; + return "Bucket(s)"; } @Override diff --git a/src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/UraniumResource.java b/src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/UraniumResource.java index 8f3ff850d..f80dcbe6c 100644 --- a/src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/UraniumResource.java +++ b/src/main/java/io/github/thebusybiscuit/slimefun4/implementation/geo/resources/UraniumResource.java @@ -39,7 +39,7 @@ public class UraniumResource implements OreGenResource { @Override public String getMeasurementUnit() { - return "Pieces"; + return "Piece(s)"; } @Override diff --git a/src/main/java/me/mrCookieSlime/Slimefun/GEO/GEOScanner.java b/src/main/java/me/mrCookieSlime/Slimefun/GEO/GEOScanner.java index ad32208cb..3f32159d9 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/GEO/GEOScanner.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/GEO/GEOScanner.java @@ -39,13 +39,15 @@ public final class GEOScanner { } int index = 10; - for (OreGenResource resource: OreGenSystem.listResources()) { + for (OreGenResource resource : OreGenSystem.listResources()) { int supply = OreGenSystem.getSupplies(resource, chunk, true); ItemStack item = new CustomItem(resource.getItem(), "&r" + resource.getName(), "&8\u21E8 &e" + supply + ' ' + resource.getMeasurementUnit()); + if (supply > 1) { item.setAmount(supply > item.getMaxStackSize() ? item.getMaxStackSize(): supply); } + menu.addItem(index, item, (pl, slot, stack, action) -> false); index++; diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/Category.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/Category.java index b383b8655..becdae2e4 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/Category.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/Category.java @@ -132,22 +132,6 @@ public class Category { return this.items; } - /** - * Attempts to get the category with the given display item. - * - * @param item the display item of the category to get - * @return Category if found, or null - * - * @since 4.0 - */ - @Deprecated - public static Category getByItem(ItemStack item) { - for (Category c: list()) { - if (c.getItem().isSimilar(item)) return c; - } - return null; - } - /** * Returns the tier of this category. * diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/LockedCategory.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/LockedCategory.java index 505618460..8bd57d720 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/LockedCategory.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/LockedCategory.java @@ -86,7 +86,8 @@ public class LockedCategory extends Category { * @see #removeParent(Category) */ public void addParent(Category category) { - if (category == this) throw new IllegalArgumentException("Category '" + this.getItem().getItemMeta().getDisplayName() + "' cannot be a parent of itself."); + if (category == this || category == null) throw new IllegalArgumentException("Category '" + this.getItem().getItemMeta().getDisplayName() + "' cannot be a parent of itself or have a 'null' parent."); + this.parents.add(category); } @@ -116,8 +117,8 @@ public class LockedCategory extends Category { } public boolean hasUnlocked(Player p, PlayerProfile profile) { - for (Category category: parents) { - for (SlimefunItem item: category.getItems()) { + for (Category category : parents) { + for (SlimefunItem item : category.getItems()) { if (Slimefun.isEnabled(p, item, false) && Slimefun.hasPermission(p, item, false) && item.getResearch() != null @@ -126,6 +127,7 @@ public class LockedCategory extends Category { return false; } } + return true; } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/Research.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/Research.java index 8f80ff3f5..194e4a42f 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/Research.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/Research.java @@ -34,7 +34,7 @@ import me.mrCookieSlime.Slimefun.api.Slimefun; */ public class Research { - private static final int[] research_progress = {23, 44, 57, 92}; + private static final int[] RESEARCH_PROGRESS = {23, 44, 57, 92}; private int id; private String name; @@ -94,32 +94,6 @@ public class Research { return name; } - /** - * Gets the cost in XP levels to unlock the research. - * - * @return The cost in XP levels of the research - * - * @since 4.0 - * @deprecated Moved to {@link #getCost()} - */ - @Deprecated - public int getLevel() { - return getCost(); - } - - /** - * Sets the cost in XP levels to unlock the research. - * - * @param level Cost in XP levels - * - * @since 4.0 - * @deprecated Moved to {@link #setCost(int)} - */ - @Deprecated - public void setLevel(int level) { - setCost(level); - } - /** * Gets the cost in XP levels to unlock the research. * @@ -258,19 +232,19 @@ public class Research { 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++) { + 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] + "%")); + SlimefunPlugin.getLocal().sendMessage(p, "messages.research.progress", true, msg -> msg.replace("%research%", getName()).replace("%progress%", RESEARCH_PROGRESS[j - 1] + "%")); }, i * 20L); } Slimefun.runSync(() -> { runnable.run(); SlimefunPlugin.getUtilities().researching.remove(p.getUniqueId()); - }, (research_progress.length + 1) * 20L); + }, (RESEARCH_PROGRESS.length + 1) * 20L); } } }); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SeasonalCategory.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SeasonalCategory.java index 75d5dbcf2..b3b7b6e82 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SeasonalCategory.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SeasonalCategory.java @@ -18,7 +18,7 @@ import org.bukkit.inventory.ItemStack; */ public class SeasonalCategory extends Category { - private int month = -1; + private final int month; /** * The constructor for a SeasonCategory. @@ -34,6 +34,11 @@ public class SeasonalCategory extends Category { */ public SeasonalCategory(int month, int tier, ItemStack item) { super(item, tier); + + if (month < 1 || month > 12) { + throw new IllegalArgumentException("There is no month no. " + month); + } + this.month = month - 1; } @@ -58,7 +63,6 @@ public class SeasonalCategory extends Category { * @see #getMonth() */ public boolean isUnlocked() { - if (month == -1) return true; Calendar calendar = Calendar.getInstance(); return month == calendar.get(Calendar.MONTH); } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Setup/CSCoreLibLoader.java b/src/main/java/me/mrCookieSlime/Slimefun/Setup/CSCoreLibLoader.java deleted file mode 100644 index 1ff6d7349..000000000 --- a/src/main/java/me/mrCookieSlime/Slimefun/Setup/CSCoreLibLoader.java +++ /dev/null @@ -1,161 +0,0 @@ -package me.mrCookieSlime.Slimefun.Setup; - -import java.io.BufferedInputStream; -import java.io.BufferedReader; -import java.io.File; -import java.io.FileOutputStream; -import java.io.IOException; -import java.io.InputStreamReader; -import java.net.HttpURLConnection; -import java.net.MalformedURLException; -import java.net.URL; -import java.net.URLConnection; -import java.util.logging.Level; - -import org.bukkit.plugin.Plugin; - -import com.google.gson.JsonArray; -import com.google.gson.JsonObject; -import com.google.gson.JsonParser; - -@Deprecated -public class CSCoreLibLoader { - - private Plugin plugin; - private URL url; - private URL download; - private File file; - - public CSCoreLibLoader(Plugin plugin) { - this.plugin = plugin; - try { - this.url = new URL("https://api.curseforge.com/servermods/files?projectIds=88802"); - } catch (MalformedURLException e) { - plugin.getLogger().log(Level.SEVERE, "The Auto-Updater URL is malformed!", e); - } - } - - public boolean load() { - if (plugin.getServer().getPluginManager().isPluginEnabled("CS-CoreLib")) { - return true; - } - else { - plugin.getLogger().log(Level.INFO, " "); - plugin.getLogger().log(Level.INFO, "#################### - INFO - ####################"); - plugin.getLogger().log(Level.INFO, " "); - plugin.getLogger().log(Level.INFO, plugin.getName() + " could not be loaded (yet)."); - plugin.getLogger().log(Level.INFO, "It appears that you have not installed CS-CoreLib."); - plugin.getLogger().log(Level.INFO, "Your Server will now try to download and install"); - plugin.getLogger().log(Level.INFO, "CS-CoreLib for you."); - plugin.getLogger().log(Level.INFO, "You will be asked to restart your Server when it's finished."); - plugin.getLogger().log(Level.INFO, "If this somehow fails, please download and install CS-CoreLib manually:"); - plugin.getLogger().log(Level.INFO, "https://dev.bukkit.org/projects/cs-corelib"); - plugin.getLogger().log(Level.INFO, " "); - plugin.getLogger().log(Level.INFO, "#################### - INFO - ####################"); - plugin.getLogger().log(Level.INFO, " "); - - plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, () -> { - if (connect()) { - install(); - } - }, 10L); - - return false; - } - } - - private boolean connect() { - try { - final URLConnection connection = this.url.openConnection(); - connection.setConnectTimeout(5000); - connection.addRequestProperty("User-Agent", "CS-CoreLib Loader (by mrCookieSlime)"); - connection.setDoOutput(true); - - final BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream())); - final JsonArray array = new JsonParser().parse(reader).getAsJsonArray(); - final JsonObject json = array.get(array.size() - 1).getAsJsonObject(); - - download = traceURL(json.get("downloadUrl").getAsString().replace("https:", "http:")); - file = new File("plugins/" + json.get("name").getAsString() + ".jar"); - - return true; - } catch (IOException e) { - plugin.getLogger().log(Level.WARNING, " "); - plugin.getLogger().log(Level.WARNING, "#################### - WARNING - ####################"); - plugin.getLogger().log(Level.WARNING, " "); - plugin.getLogger().log(Level.WARNING, "Could not connect to BukkitDev."); - plugin.getLogger().log(Level.WARNING, "Please download & install CS-CoreLib manually:"); - plugin.getLogger().log(Level.WARNING, "https://dev.bukkit.org/projects/cs-corelib"); - plugin.getLogger().log(Level.WARNING, " "); - plugin.getLogger().log(Level.WARNING, "#################### - WARNING - ####################"); - plugin.getLogger().log(Level.WARNING, " "); - return false; - } - } - - private URL traceURL(String location) throws IOException { - HttpURLConnection connection = null; - - while (true) { - URL url = new URL(location); - connection = (HttpURLConnection) url.openConnection(); - - connection.setInstanceFollowRedirects(false); - connection.setConnectTimeout(5000); - connection.addRequestProperty("User-Agent", "Auto Updater (by mrCookieSlime)"); - - int response = connection.getResponseCode(); - - if (response == HttpURLConnection.HTTP_MOVED_PERM || response == HttpURLConnection.HTTP_MOVED_TEMP) { - String loc = connection.getHeaderField("Location"); - location = new URL(new URL(location), loc).toExternalForm(); - } - else { - break; - } - } - - return new URL(connection.getURL().toString().replace(" ", "%20")); - } - - private void install() { - BufferedInputStream input = null; - FileOutputStream output = null; - try { - input = new BufferedInputStream(download.openStream()); - output = new FileOutputStream(file); - - final byte[] data = new byte[1024]; - int read; - while ((read = input.read(data, 0, 1024)) != -1) { - output.write(data, 0, read); - } - } catch (Exception ex) { - plugin.getLogger().log(Level.WARNING, " "); - plugin.getLogger().log(Level.WARNING, "#################### - WARNING - ####################"); - plugin.getLogger().log(Level.WARNING, " "); - plugin.getLogger().log(Level.WARNING, "Failed to download CS-CoreLib"); - plugin.getLogger().log(Level.WARNING, "Please download & install CS-CoreLib manually:"); - plugin.getLogger().log(Level.WARNING, "https://dev.bukkit.org/projects/cs-corelib"); - plugin.getLogger().log(Level.WARNING, " "); - plugin.getLogger().log(Level.WARNING, "#################### - WARNING - ####################"); - plugin.getLogger().log(Level.WARNING, " "); - } finally { - try { - if (input != null) input.close(); - if (output != null) output.close(); - plugin.getLogger().log(Level.INFO, " "); - plugin.getLogger().log(Level.INFO, "#################### - INFO - ####################"); - plugin.getLogger().log(Level.INFO, " "); - plugin.getLogger().log(Level.INFO, "Please restart your Server to finish the Installation"); - plugin.getLogger().log(Level.INFO, "of " + plugin.getName() + " and CS-CoreLib"); - plugin.getLogger().log(Level.INFO, " "); - plugin.getLogger().log(Level.INFO, "#################### - INFO - ####################"); - plugin.getLogger().log(Level.INFO, " "); - } catch (IOException x) { - plugin.getLogger().log(Level.SEVERE, "An Error occured while closing the Download Stream for CS-CoreLib", x); - } - } - } - -} diff --git a/src/main/java/me/mrCookieSlime/Slimefun/SlimefunPlugin.java b/src/main/java/me/mrCookieSlime/Slimefun/SlimefunPlugin.java index 2ea2285a6..f7576efa7 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/SlimefunPlugin.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/SlimefunPlugin.java @@ -36,7 +36,6 @@ import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.abstractItems.AContainer; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.abstractItems.AGenerator; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.abstractItems.AReactor; import me.mrCookieSlime.Slimefun.Objects.tasks.ArmorTask; -import me.mrCookieSlime.Slimefun.Setup.CSCoreLibLoader; import me.mrCookieSlime.Slimefun.Setup.Files; import me.mrCookieSlime.Slimefun.Setup.MiscSetup; import me.mrCookieSlime.Slimefun.Setup.ResearchSetup; @@ -106,7 +105,7 @@ public final class SlimefunPlugin extends JavaPlugin { @Override public void onEnable() { - if (new CSCoreLibLoader(this).load()) { + if (getServer().getPluginManager().isPluginEnabled("CS-CoreLib")) { String currentVersion = ReflectionUtils.getVersion(); @@ -317,9 +316,16 @@ public final class SlimefunPlugin extends JavaPlugin { CSCoreLib.getLib().filterLog("([A-Za-z0-9_]{3,16}) issued server command: /sf elevator (.{0,})"); } else { + getLogger().log(Level.INFO, "#################### - INFO - ####################"); + getLogger().log(Level.INFO, " "); + getLogger().log(Level.INFO, "Slimefun could not be loaded (yet)."); + getLogger().log(Level.INFO, "It appears that you have not installed CS-CoreLib."); + getLogger().log(Level.INFO, "Please download and install CS-CoreLib manually:"); + getLogger().log(Level.INFO, "https://thebusybiscuit.github.io/builds/TheBusyBiscuit/CS-CoreLib/master/"); + getCommand("slimefun").setExecutor((sender, cmd, label, args) -> { sender.sendMessage("You have forgotten to install CS-CoreLib! Slimefun is disabled."); - sender.sendMessage("https://dev.bukkit.org/projects/cs-corelib"); + sender.sendMessage("https://thebusybiscuit.github.io/builds/TheBusyBiscuit/CS-CoreLib/master/"); return true; }); } @@ -342,7 +348,7 @@ public final class SlimefunPlugin extends JavaPlugin { if (profile.isDirty()) profile.save(); }); - for (World world: Bukkit.getWorlds()) { + for (World world : Bukkit.getWorlds()) { try { BlockStorage storage = BlockStorage.getStorage(world); @@ -357,7 +363,7 @@ public final class SlimefunPlugin extends JavaPlugin { } } - for (UniversalBlockMenu menu: utilities.universalInventories.values()) { + for (UniversalBlockMenu menu : utilities.universalInventories.values()) { menu.save(); } @@ -375,7 +381,7 @@ public final class SlimefunPlugin extends JavaPlugin { instance = null; - for (Player p: Bukkit.getOnlinePlayers()) { + for (Player p : Bukkit.getOnlinePlayers()) { p.closeInventory(); } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/ancient_altar/AltarRecipe.java b/src/main/java/me/mrCookieSlime/Slimefun/ancient_altar/AltarRecipe.java index 70f827194..75728b669 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/ancient_altar/AltarRecipe.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/ancient_altar/AltarRecipe.java @@ -9,9 +9,9 @@ import me.mrCookieSlime.Slimefun.SlimefunPlugin; public class AltarRecipe { - private ItemStack catalyst; - private List input; - private ItemStack output; + private final ItemStack catalyst; + private final List input; + private final ItemStack output; public AltarRecipe(List input, ItemStack output) { this.catalyst = input.get(4); 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 6574d838b..fd4d3dc90 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/ancient_altar/AncientAltarListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/ancient_altar/AncientAltarListener.java @@ -102,7 +102,7 @@ public class AncientAltarListener implements Listener { if (catalyst.getType() != Material.AIR) { List input = new ArrayList<>(); - for (Block pedestal: pedestals) { + for (Block pedestal : pedestals) { Item stack = findItem(pedestal); if (stack != null) input.add(fixItemStack(stack.getItemStack(), stack.getCustomName())); } @@ -177,7 +177,7 @@ public class AncientAltarListener implements Listener { } public static Item findItem(Block b) { - for (Entity n: b.getChunk().getEntities()) { + for (Entity n : b.getChunk().getEntities()) { if (n instanceof Item && b.getLocation().add(0.5, 1.2, 0.5).distanceSquared(n.getLocation()) < 0.5D && n.getCustomName() != null) return (Item) n; } return null; 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 130b13b3a..fa2acd1aa 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/ancient_altar/Pedestals.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/ancient_altar/Pedestals.java @@ -54,7 +54,8 @@ public final class Pedestals { if (SlimefunManager.isItemSimilar(catalyst, SlimefunItems.BROKEN_SPAWNER, false)) { if (checkRecipe(SlimefunItems.BROKEN_SPAWNER, input) == null) return null; - final ItemStack spawner = SlimefunItems.REPAIRED_SPAWNER.clone(); + + ItemStack spawner = SlimefunItems.REPAIRED_SPAWNER.clone(); ItemMeta im = spawner.getItemMeta(); im.setLore(Arrays.asList(catalyst.getItemMeta().getLore().get(0))); spawner.setItemMeta(im); @@ -65,7 +66,7 @@ public final class Pedestals { } private static ItemStack checkRecipe(ItemStack catalyst, List items) { - for (AltarRecipe recipe: SlimefunPlugin.getUtilities().altarRecipes) { + for (AltarRecipe recipe : SlimefunPlugin.getUtilities().altarRecipes) { if (SlimefunManager.isItemSimilar(catalyst, recipe.getCatalyst(), true)) { for (int i = 0; i < 8; i++) { if (SlimefunManager.isItemSimilar(items.get(i), recipe.getInput().get(0), true)) { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/ancient_altar/RitualAnimation.java b/src/main/java/me/mrCookieSlime/Slimefun/ancient_altar/RitualAnimation.java index 54f640524..f5f7f0e01 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/ancient_altar/RitualAnimation.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/ancient_altar/RitualAnimation.java @@ -49,7 +49,7 @@ public class RitualAnimation implements Runnable { this.running = true; this.stage = 0; - for (Block pedestal: this.pedestals) { + for (Block pedestal : this.pedestals) { Item item = AncientAltarListener.findItem(pedestal); this.itemLock.put(item, item.getLocation().clone()); } @@ -78,7 +78,7 @@ public class RitualAnimation implements Runnable { } private boolean checkLockedItems() { - for (Map.Entry entry: itemLock.entrySet()) { + for (Map.Entry entry : itemLock.entrySet()) { if (entry.getKey().getLocation().distance(entry.getValue()) > 0.3) { return false; } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/autosave/BlockAutoSaver.java b/src/main/java/me/mrCookieSlime/Slimefun/autosave/BlockAutoSaver.java index 24feb444e..ec11f219b 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/autosave/BlockAutoSaver.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/autosave/BlockAutoSaver.java @@ -31,7 +31,7 @@ public class BlockAutoSaver implements Runnable { if (!worlds.isEmpty()) { Slimefun.getLogger().log(Level.INFO, "Auto-Saving Block Data... (Next Auto-Save: " + SlimefunPlugin.getCfg().getInt("options.auto-save-delay-in-minutes") + "m)"); - for (BlockStorage storage: worlds) { + for (BlockStorage storage : worlds) { storage.save(false); } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/commands/SlimefunCommand.java b/src/main/java/me/mrCookieSlime/Slimefun/commands/SlimefunCommand.java index 2beeb7cd5..536390225 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/commands/SlimefunCommand.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/commands/SlimefunCommand.java @@ -92,7 +92,7 @@ public class SlimefunCommand implements CommandExecutor, Listener { return true; } else { - for (SubCommand command: commands) { + for (SubCommand command : commands) { if (args[0].equalsIgnoreCase(command.getName())) { command.onExecute(sender, args); return true; @@ -110,7 +110,8 @@ public class SlimefunCommand implements CommandExecutor, Listener { sender.sendMessage(""); sender.sendMessage(ChatColor.translateAlternateColorCodes('&', "&aSlimefun &2v" + Slimefun.getVersion())); sender.sendMessage(""); - for (SubCommand cmd: commands) { + + for (SubCommand cmd : commands) { sender.sendMessage(ChatColor.translateAlternateColorCodes('&', "&3/sf " + cmd.getName() + " &b") + cmd.getDescription()); } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/commands/SlimefunTabCompleter.java b/src/main/java/me/mrCookieSlime/Slimefun/commands/SlimefunTabCompleter.java index 4c128d4fe..48eff833f 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/commands/SlimefunTabCompleter.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/commands/SlimefunTabCompleter.java @@ -29,9 +29,11 @@ public class SlimefunTabCompleter implements TabCompleter { } else if (args[0].equalsIgnoreCase("research")) { List researches = new ArrayList<>(); + for (Research res : Research.list()) { researches.add(res.getName().toUpperCase().replace(' ', '_')); } + researches.add("all"); researches.add("reset"); return createReturnList(researches, args[2]); @@ -55,11 +57,13 @@ public class SlimefunTabCompleter implements TabCompleter { if (string.equals("")) return list; List returnList = new ArrayList<>(); + for (String item : list) { if (item.toLowerCase().startsWith(string.toLowerCase())) { returnList.add(item); } } + return returnList; } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/hooks/WorldEditHook.java b/src/main/java/me/mrCookieSlime/Slimefun/hooks/WorldEditHook.java index 7d82d6b8a..aa3ca4834 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/hooks/WorldEditHook.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/hooks/WorldEditHook.java @@ -23,10 +23,12 @@ public class WorldEditHook { @Subscribe public void wrapForLogging(final EditSessionEvent event) { event.setExtent(new AbstractDelegateExtent(event.getExtent()) { + @Override public > boolean setBlock(BlockVector3 pos, T block) throws WorldEditException { if (block.getBlockType().getMaterial().isAir()) { World world = Bukkit.getWorld(event.getWorld().getName()); + if (world != null) { Location l = new Location(world, pos.getBlockX(), pos.getBlockY(), pos.getBlockZ()); if (BlockStorage.hasBlockInfo(l)) BlockStorage.clearBlockInfo(l); @@ -34,6 +36,7 @@ public class WorldEditHook { } return getExtent().setBlock(pos, block); } + }); } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/listeners/AndroidKillingListener.java b/src/main/java/me/mrCookieSlime/Slimefun/listeners/AndroidKillingListener.java index a9e219368..9ff093834 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/listeners/AndroidKillingListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/listeners/AndroidKillingListener.java @@ -3,6 +3,7 @@ package me.mrCookieSlime.Slimefun.listeners; import java.util.ArrayList; import java.util.List; import java.util.Random; +import java.util.concurrent.ThreadLocalRandom; import org.bukkit.Bukkit; import org.bukkit.Material; @@ -21,8 +22,6 @@ import me.mrCookieSlime.Slimefun.androids.AndroidEntity; public class AndroidKillingListener implements Listener { - private final Random random = new Random(); - public AndroidKillingListener(SlimefunPlugin plugin) { plugin.getServer().getPluginManager().registerEvents(this, plugin); } @@ -42,6 +41,8 @@ public class AndroidKillingListener implements Listener { } } + Random random = ThreadLocalRandom.current(); + switch (e.getEntityType()) { case BLAZE: items.add(new ItemStack(Material.BLAZE_ROD, 1 + random.nextInt(2))); @@ -58,7 +59,7 @@ public class AndroidKillingListener implements Listener { break; } - obj.getAndroid().addItems(obj.getBlock(), items.toArray(new ItemStack[items.size()])); + obj.getAndroid().addItems(obj.getBlock(), items.toArray(new ItemStack[0])); ExperienceOrb exp = (ExperienceOrb) e.getEntity().getWorld().spawnEntity(e.getEntity().getLocation(), EntityType.EXPERIENCE_ORB); exp.setExperience(1 + random.nextInt(6)); }, 1L); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/listeners/AutonomousToolsListener.java b/src/main/java/me/mrCookieSlime/Slimefun/listeners/AutonomousToolsListener.java index 41ccc545a..449a2aae1 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/listeners/AutonomousToolsListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/listeners/AutonomousToolsListener.java @@ -34,7 +34,7 @@ public class AutonomousToolsListener implements Listener { SlimefunItem machine = BlockStorage.check(dispenser); if (machine != null) { - for (ItemHandler handler: SlimefunItem.getHandlers("AutonomousMachineHandler")) { + for (ItemHandler handler : SlimefunItem.getHandlers("AutonomousMachineHandler")) { if (((AutonomousMachineHandler) handler).onBlockDispense(e, dispenser, d, block, chest, machine)) break; } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/listeners/BackpackListener.java b/src/main/java/me/mrCookieSlime/Slimefun/listeners/BackpackListener.java index 9c1f2bea9..7947ff414 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/listeners/BackpackListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/listeners/BackpackListener.java @@ -49,6 +49,7 @@ public class BackpackListener implements Listener { if (SlimefunPlugin.getUtilities().backpack.containsKey(e.getPlayer().getUniqueId())){ ItemStack item = e.getItemDrop().getItemStack(); SlimefunItem sfItem = SlimefunItem.getByItem(item); + if (sfItem instanceof SlimefunBackpack) e.setCancelled(true); } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/listeners/BlockListener.java b/src/main/java/me/mrCookieSlime/Slimefun/listeners/BlockListener.java index f7c9abc61..eff0d4762 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/listeners/BlockListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/listeners/BlockListener.java @@ -57,7 +57,7 @@ public class BlockListener implements Listener { @EventHandler public void onPistonRetract(BlockPistonRetractEvent e) { if (e.isSticky()) { - for (Block b: e.getBlocks()) { + for (Block b : e.getBlocks()) { if (BlockStorage.hasBlockInfo(b) || b.getRelative(e.getDirection()).getType() == Material.AIR && BlockStorage.hasBlockInfo(b.getRelative(e.getDirection()))) { e.setCancelled(true); return; @@ -75,7 +75,7 @@ public class BlockListener implements Listener { Block b = e.getClickedBlock(); LinkedList multiblocks = new LinkedList<>(); - for (MultiBlock mb: MultiBlock.list()) { + for (MultiBlock mb : MultiBlock.list()) { Block center = b.getRelative(mb.getTriggerBlock()); if (compareMaterials(center, mb.getBuild(), mb.isSymmetric())) { @@ -87,7 +87,7 @@ public class BlockListener implements Listener { e.setCancelled(true); MultiBlock multiblock = multiblocks.getLast(); - for (ItemHandler handler: SlimefunItem.getHandlers("MultiBlockInteractionHandler")) { + for (ItemHandler handler : SlimefunItem.getHandlers("MultiBlockInteractionHandler")) { if (((MultiBlockInteractionHandler) handler).onInteract(p, multiblock, b)) break; } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/listeners/BowListener.java b/src/main/java/me/mrCookieSlime/Slimefun/listeners/BowListener.java index 5a5192f19..7aa47968e 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/listeners/BowListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/listeners/BowListener.java @@ -1,6 +1,5 @@ package me.mrCookieSlime.Slimefun.listeners; -import org.bukkit.Bukkit; import org.bukkit.GameMode; import org.bukkit.Location; import org.bukkit.entity.Arrow; @@ -19,6 +18,7 @@ import me.mrCookieSlime.Slimefun.Lists.SlimefunItems; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem; import me.mrCookieSlime.Slimefun.Objects.handlers.BowShootHandler; import me.mrCookieSlime.Slimefun.Objects.handlers.ItemHandler; +import me.mrCookieSlime.Slimefun.api.Slimefun; public class BowListener implements Listener { @@ -35,10 +35,14 @@ public class BowListener implements Listener { @EventHandler public void onArrowHit(final ProjectileHitEvent e) { - Bukkit.getScheduler().scheduleSyncDelayedTask(SlimefunPlugin.instance, () -> { - if (!e.getEntity().isValid()) return; - SlimefunPlugin.getUtilities().arrows.remove(e.getEntity().getUniqueId()); - if (e.getEntity() instanceof Arrow) handleGrapplingHook((Arrow) e.getEntity()); + Slimefun.runSync(() -> { + if (e.getEntity().isValid()) { + SlimefunPlugin.getUtilities().arrows.remove(e.getEntity().getUniqueId()); + + if (e.getEntity() instanceof Arrow) { + handleGrapplingHook((Arrow) e.getEntity()); + } + } }, 4L); } @@ -58,11 +62,11 @@ public class BowListener implements Listener { p.setVelocity(arrow.getLocation().toVector().subtract(p.getLocation().toVector())); } - for (Entity n: SlimefunPlugin.getUtilities().remove.get(p.getUniqueId())) { + for (Entity n : SlimefunPlugin.getUtilities().remove.get(p.getUniqueId())) { if (n.isValid()) n.remove(); } - Bukkit.getScheduler().scheduleSyncDelayedTask(SlimefunPlugin.instance, () -> { + Slimefun.runSync(() -> { SlimefunPlugin.getUtilities().jumpState.remove(p.getUniqueId()); SlimefunPlugin.getUtilities().remove.remove(p.getUniqueId()); }, 20L); @@ -87,11 +91,11 @@ public class BowListener implements Listener { p.setVelocity(v); - for (Entity n: SlimefunPlugin.getUtilities().remove.get(p.getUniqueId())) { + for (Entity n : SlimefunPlugin.getUtilities().remove.get(p.getUniqueId())) { if (n.isValid()) n.remove(); } - Bukkit.getScheduler().scheduleSyncDelayedTask(SlimefunPlugin.instance, () -> { + Slimefun.runSync(() -> { SlimefunPlugin.getUtilities().jumpState.remove(p.getUniqueId()); SlimefunPlugin.getUtilities().remove.remove(p.getUniqueId()); }, 20L); @@ -103,8 +107,10 @@ public class BowListener implements Listener { public void onArrowSuccessfulHit(EntityDamageByEntityEvent e) { if (e.getDamager() instanceof Arrow) { if (SlimefunPlugin.getUtilities().arrows.containsKey(e.getDamager().getUniqueId()) && e.getEntity() instanceof LivingEntity) { - for (ItemHandler handler: SlimefunItem.getHandlers("BowShootHandler")) { - if (((BowShootHandler) handler).onHit(e, (LivingEntity) e.getEntity())) break; + for (ItemHandler handler : SlimefunItem.getHandlers("BowShootHandler")) { + if (((BowShootHandler) handler).onHit(e, (LivingEntity) e.getEntity())) { + break; + } } SlimefunPlugin.getUtilities().arrows.remove(e.getDamager().getUniqueId()); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/listeners/CoolerListener.java b/src/main/java/me/mrCookieSlime/Slimefun/listeners/CoolerListener.java index dab228807..847cacaa6 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/listeners/CoolerListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/listeners/CoolerListener.java @@ -27,7 +27,7 @@ public class CoolerListener implements Listener { public void onStarve(FoodLevelChangeEvent e) { if (e.getFoodLevel() < ((Player) e.getEntity()).getFoodLevel()) { Player p = (Player) e.getEntity(); - for (ItemStack item: p.getInventory().getContents()) { + for (ItemStack item : p.getInventory().getContents()) { if (SlimefunManager.isItemSimilar(item, SlimefunItems.COOLER, false)) { BackpackInventory backpack = PlayerProfile.getBackpack(item); if (backpack != null) { @@ -45,7 +45,7 @@ public class CoolerListener implements Listener { if (slot >= 0) { PotionMeta im = (PotionMeta) inv.getItem(slot).getItemMeta(); - for (PotionEffect effect: im.getCustomEffects()) { + for (PotionEffect effect : im.getCustomEffects()) { p.addPotionEffect(effect); } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/listeners/ItemListener.java b/src/main/java/me/mrCookieSlime/Slimefun/listeners/ItemListener.java index 2f55f9f11..649ea0d88 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/listeners/ItemListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/listeners/ItemListener.java @@ -359,7 +359,7 @@ public class ItemListener implements Listener { // Remove the glass bottle once drunk final int m = mode; - Bukkit.getScheduler().scheduleSyncDelayedTask(SlimefunPlugin.instance, () -> { + Slimefun.runSync(() -> { if (m == 0) p.getEquipment().getItemInMainHand().setAmount(0); else if (m == 1) p.getEquipment().getItemInOffHand().setAmount(0); else if (m == 2) p.getInventory().removeItem(new ItemStack(Material.GLASS_BOTTLE, 1)); @@ -449,7 +449,7 @@ public class ItemListener implements Listener { @EventHandler public void onItemDrop(PlayerDropItemEvent e) { - for (ItemHandler handler: SlimefunItem.getHandlers("ItemDropHandler")) { + for (ItemHandler handler : SlimefunItem.getHandlers("ItemDropHandler")) { if (((ItemDropHandler) handler).onItemDrop(e, e.getPlayer(), e.getItemDrop())) return; } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/listeners/TalismanListener.java b/src/main/java/me/mrCookieSlime/Slimefun/listeners/TalismanListener.java index 9b2671a9a..e1567e669 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/listeners/TalismanListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/listeners/TalismanListener.java @@ -40,7 +40,7 @@ import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class TalismanListener implements Listener { - private Random random = new Random(); + private final Random random = new Random(); public TalismanListener(SlimefunPlugin plugin) { plugin.getServer().getPluginManager().registerEvents(this, plugin); @@ -81,7 +81,7 @@ public class TalismanListener implements Listener { // Did the tool in our hand broke or was it an Armorpiece? if (!inv.getItem(inv.getHeldItemSlot()).equals(e.getBrokenItem())) { - for (int s: armorSlots) { + for (int s : armorSlots) { if (inv.getItem(s).equals(e.getBrokenItem())) { slot = s; break; @@ -89,7 +89,7 @@ public class TalismanListener implements Listener { } } - final ItemStack item = e.getBrokenItem().clone(); + ItemStack item = e.getBrokenItem().clone(); ItemMeta meta = item.getItemMeta(); if (meta instanceof Damageable) { @@ -98,14 +98,16 @@ public class TalismanListener implements Listener { item.setItemMeta(meta); - final int itemSlot = slot; - SlimefunPlugin.instance.getServer().getScheduler().runTaskLater(SlimefunPlugin.instance, () -> inv.setItem(itemSlot, item), 1L); + int itemSlot = slot; + Slimefun.runSync(() -> inv.setItem(itemSlot, item), 1L); } } @EventHandler public void onSprint(PlayerToggleSprintEvent e) { - if (e.isSprinting()) Talisman.checkFor(e, (SlimefunItemStack) SlimefunItems.TALISMAN_TRAVELLER); + if (e.isSprinting()) { + Talisman.checkFor(e, (SlimefunItemStack) SlimefunItems.TALISMAN_TRAVELLER); + } } @EventHandler diff --git a/src/main/java/me/mrCookieSlime/Slimefun/listeners/TeleporterListener.java b/src/main/java/me/mrCookieSlime/Slimefun/listeners/TeleporterListener.java index 8791d446b..a248d9220 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/listeners/TeleporterListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/listeners/TeleporterListener.java @@ -35,7 +35,7 @@ public class TeleporterListener implements Listener { SlimefunItem teleporter = BlockStorage.check(e.getClickedBlock().getRelative(BlockFace.DOWN)); if (teleporter instanceof Teleporter) { - for (BlockFace face: faces) { + for (BlockFace face : faces) { if (!BlockStorage.check(e.getClickedBlock().getRelative(BlockFace.DOWN).getRelative(face), "GPS_TELEPORTER_PYLON")) return; } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/listeners/ToolListener.java b/src/main/java/me/mrCookieSlime/Slimefun/listeners/ToolListener.java index 3393a13a7..14e799bb2 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/listeners/ToolListener.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/listeners/ToolListener.java @@ -7,6 +7,7 @@ import java.util.List; import java.util.Optional; import java.util.Random; import java.util.Set; +import java.util.concurrent.ThreadLocalRandom; import org.bukkit.GameMode; import org.bukkit.Material; @@ -47,7 +48,6 @@ public class ToolListener implements Listener { // Materials that require a Block under it, e.g. Pressure Plates private final Set sensitiveMaterials = new HashSet<>(); - private final Random random = new Random(); private final Utilities utilities; public ToolListener(SlimefunPlugin plugin) { @@ -164,7 +164,7 @@ public class ToolListener implements Listener { gifts.add(new CustomItem(SlimefunItems.CHRISTMAS_APPLE_PIE, 4)); gifts.add(new ItemStack(Material.EMERALD)); - e.getBlockPlaced().getWorld().dropItemNaturally(e.getBlockPlaced().getLocation(), gifts.get(random.nextInt(gifts.size()))); + e.getBlockPlaced().getWorld().dropItemNaturally(e.getBlockPlaced().getLocation(), gifts.get(ThreadLocalRandom.current().nextInt(gifts.size()))); } else if (SlimefunManager.isItemSimilar(item, SlimefunItems.CARGO_INPUT, false)) { if (e.getBlock().getY() != e.getBlockAgainst().getY()) { @@ -266,6 +266,8 @@ public class ToolListener implements Listener { } else if (item != null) { if (item.getEnchantments().containsKey(Enchantment.LOOT_BONUS_BLOCKS) && !item.getEnchantments().containsKey(Enchantment.SILK_TOUCH)) { + Random random = ThreadLocalRandom.current(); + fortune = random.nextInt(item.getEnchantmentLevel(Enchantment.LOOT_BONUS_BLOCKS) + 2) - 1; if (fortune <= 0) fortune = 1; fortune = (e.getBlock().getType() == Material.LAPIS_ORE ? 4 + random.nextInt(5) : 1) * (fortune + 1); From 33adb7e79a1fb46d0d86faffa7fd476c7fed2672 Mon Sep 17 00:00:00 2001 From: TheBusyBiscuit Date: Tue, 17 Dec 2019 01:37:09 +0100 Subject: [PATCH 5/7] Added Magnesium Salt and Magnesium-powered Generator --- .../Slimefun/Lists/SlimefunItems.java | 3 ++ .../Objects/SlimefunItem/SlimefunMachine.java | 22 ++++++------ .../abstractItems/AGenerator.java | 6 ++-- .../abstractItems/MachineFuel.java | 6 ++-- .../SlimefunItem/machines/BlockPlacer.java | 15 ++++---- .../SlimefunItem/machines/Composter.java | 11 +++--- .../SlimefunItem/machines/Crucible.java | 14 +++++--- .../SlimefunItem/machines/InfusedHopper.java | 8 ++--- .../machines/ReactorAccessPort.java | 2 +- .../SlimefunItem/machines/TrashCan.java | 3 +- .../machines/electric/ElectricSmeltery.java | 13 ++++--- .../machines/electric/Freezer.java | 2 +- .../electric/HeatedPressureChamber.java | 20 +++++------ .../machines/electric/Refinery.java | 19 +++++++---- .../machines/electric/WitherAssembler.java | 25 ++++++++------ .../machines/electric/XPCollector.java | 13 +++---- .../generators/MagnesiumGenerator.java | 34 +++++++++++++++++++ .../SlimefunItem/multiblocks/GrindStone.java | 4 +-- .../SlimefunItem/multiblocks/OreWasher.java | 9 ++++- .../Slimefun/Setup/ResearchSetup.java | 1 + .../Slimefun/Setup/SlimefunSetup.java | 24 ++++++++++--- 21 files changed, 167 insertions(+), 87 deletions(-) create mode 100644 src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/generators/MagnesiumGenerator.java diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Lists/SlimefunItems.java b/src/main/java/me/mrCookieSlime/Slimefun/Lists/SlimefunItems.java index 912ffbfb8..3a57b0005 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Lists/SlimefunItems.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Lists/SlimefunItems.java @@ -827,6 +827,9 @@ public final class SlimefunItems { public static final ItemStack SOULBOUND_ELYTRA = new SlimefunItemStack("SOULBOUND_ELYTRA", ELYTRA, "&cSoulbound Elytra"); public static final ItemStack TOTEM_OF_UNDYING = new ItemStack(Material.TOTEM_OF_UNDYING); + + public static final ItemStack MAGNESIUM_SALT = new SlimefunItemStack("MAGNESIUM_SALT", Material.SUGAR, "&cMagnesium Salt", "", "&7A special type of fuel that can be", "&7used in a Magnesium-powered Generator"); + public static final ItemStack MAGNESIUM_GENERATOR = new SlimefunItemStack("MAGNESIUM_GENERATOR", "eyJ0ZXh0dXJlcyI6eyJTS0lOIjp7InVybCI6Imh0dHA6Ly90ZXh0dXJlcy5taW5lY3JhZnQubmV0L3RleHR1cmUvOTM0M2NlNThkYTU0Yzc5OTI0YTJjOTMzMWNmYzQxN2ZlOGNjYmJlYTliZTQ1YTdhYzg1ODYwYTZjNzMwIn19fQ==", "&cMagnesium-powered Generator", "", MachineTier.MEDIUM.and(MachineType.GENERATOR), "&8\u21E8 &e\u26A1 &7128 J Buffer", "&8\u21E8 &e\u26A1 &736 J/s"); static { INFUSED_ELYTRA.addUnsafeEnchantment(Enchantment.MENDING, 1); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SlimefunMachine.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SlimefunMachine.java index 99f3431df..0aa563ae5 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SlimefunMachine.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SlimefunMachine.java @@ -16,9 +16,9 @@ import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.interfaces.RecipeDisplayIt public class SlimefunMachine extends SlimefunItem implements RecipeDisplayItem { - protected List recipes; - protected List shownRecipes; - private BlockFace trigger; + protected final List recipes; + protected final List shownRecipes; + protected final BlockFace trigger; @Deprecated public SlimefunMachine(Category category, ItemStack item, String id, ItemStack[] recipe, ItemStack[] machineRecipes, Material trigger) { @@ -80,20 +80,20 @@ public class SlimefunMachine extends SlimefunItem implements RecipeDisplayItem { @Override public void install() { - for (ItemStack i: shownRecipes) { - SlimefunItem item = SlimefunItem.getByItem(i); - if (item == null || !SlimefunItem.isDisabled(i)) { - this.recipes.add(new ItemStack[] {i}); + for (ItemStack recipeItem : shownRecipes) { + SlimefunItem item = SlimefunItem.getByItem(recipeItem); + if (item == null || !SlimefunItem.isDisabled(recipeItem)) { + this.recipes.add(new ItemStack[] {recipeItem}); } } } private static Material[] convertItemStacksToMaterial(ItemStack[] items) { List mats = new ArrayList<>(); - for (ItemStack i: items) { - if (i == null) mats.add(null); - else if (i.getType() == Material.FLINT_AND_STEEL) mats.add(Material.FIRE); - else mats.add(i.getType()); + for (ItemStack item : items) { + if (item == null) mats.add(null); + else if (item.getType() == Material.FLINT_AND_STEEL) mats.add(Material.FIRE); + else mats.add(item.getType()); } return mats.toArray(new Material[mats.size()]); 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 2ebd7a84b..7ff66c2f4 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 @@ -224,8 +224,8 @@ public abstract class AGenerator extends SlimefunItem implements RecipeDisplayIt } private MachineFuel findRecipe(BlockMenu menu, Map found) { - for (MachineFuel recipe: recipes) { - for (int slot: getInputSlots()) { + for (MachineFuel recipe : recipes) { + for (int slot : getInputSlots()) { if (SlimefunManager.isItemSimilar(menu.getItemInSlot(slot), recipe.getInput(), true)) { found.put(slot, recipe.getInput().getAmount()); return recipe; @@ -249,7 +249,7 @@ public abstract class AGenerator extends SlimefunItem implements RecipeDisplayIt public List getDisplayRecipes() { List list = new ArrayList<>(); - for (MachineFuel fuel: recipes) { + for (MachineFuel fuel : recipes) { ItemStack item = fuel.getInput().clone(); ItemMeta im = item.getItemMeta(); List lore = new ArrayList<>(); 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 5e05b4e3e..ed36b026a 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,9 +4,9 @@ import org.bukkit.inventory.ItemStack; public class MachineFuel { - private int ticks; - private ItemStack fuel; - private ItemStack output; + private final int ticks; + private final ItemStack fuel; + private final ItemStack output; public MachineFuel(int seconds, ItemStack fuel) { this.ticks = seconds * 2; diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/BlockPlacer.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/BlockPlacer.java index 7be395d9f..0b8f67514 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/BlockPlacer.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/BlockPlacer.java @@ -2,7 +2,6 @@ package me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines; import java.util.List; -import org.bukkit.Bukkit; import org.bukkit.Effect; import org.bukkit.Material; import org.bukkit.Nameable; @@ -54,9 +53,11 @@ public class BlockPlacer extends SimpleSlimefunItem { block.setType(e.getItem().getType()); BlockStorage.store(block, sfItem.getID()); block.getWorld().playEffect(block.getLocation(), Effect.STEP_SOUND, e.getItem().getType()); - if (d.getInventory().containsAtLeast(e.getItem(), 2)) d.getInventory().removeItem(new CustomItem(e.getItem(), 1)); + if (d.getInventory().containsAtLeast(e.getItem(), 2)) { + d.getInventory().removeItem(new CustomItem(e.getItem(), 1)); + } else { - Bukkit.getScheduler().runTaskLater(SlimefunPlugin.instance, () -> d.getInventory().removeItem(e.getItem()), 2L); + Slimefun.runSync(() -> d.getInventory().removeItem(e.getItem()), 2L); } } } @@ -81,9 +82,11 @@ public class BlockPlacer extends SimpleSlimefunItem { } block.getWorld().playEffect(block.getLocation(), Effect.STEP_SOUND, e.getItem().getType()); - if (d.getInventory().containsAtLeast(e.getItem(), 2)) d.getInventory().removeItem(new CustomItem(e.getItem(), 1)); + if (d.getInventory().containsAtLeast(e.getItem(), 2)) { + d.getInventory().removeItem(new CustomItem(e.getItem(), 1)); + } else { - Bukkit.getScheduler().runTaskLater(SlimefunPlugin.instance, () -> d.getInventory().removeItem(e.getItem()), 2L); + Slimefun.runSync(() -> d.getInventory().removeItem(e.getItem()), 2L); } } } @@ -96,6 +99,6 @@ public class BlockPlacer extends SimpleSlimefunItem { @Override public void postRegister() { List list = (List) Slimefun.getItemValue(getID(), "unplaceable-blocks"); - blacklist = list.toArray(new String[list.size()]); + blacklist = list.toArray(new String[0]); } } 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 27537be0b..449a5680c 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 @@ -34,12 +34,12 @@ public class Composter extends SlimefunGadget { private static ItemStack[] getMachineRecipes() { List items = new LinkedList<>(); - for (Material leave: MaterialCollections.getAllLeaves()) { + for (Material leave : MaterialCollections.getAllLeaves()) { items.add(new ItemStack(leave, 8)); items.add(new ItemStack(Material.DIRT)); } - for (Material sapling: MaterialCollections.getAllSaplings()) { + for (Material sapling : MaterialCollections.getAllSaplings()) { items.add(new ItemStack(sapling, 8)); items.add(new ItemStack(Material.DIRT)); } @@ -66,11 +66,11 @@ public class Composter extends SlimefunGadget { String id = BlockStorage.checkID(e.getClickedBlock()); if (id != null && id.equals(getID())) { if (p.hasPermission("slimefun.inventory.bypass") || SlimefunPlugin.getProtectionManager().hasPermission(p, e.getClickedBlock().getLocation(), ProtectableAction.ACCESS_INVENTORIES)) { - final ItemStack input = p.getInventory().getItemInMainHand(); - final Block b = e.getClickedBlock(); + ItemStack input = p.getInventory().getItemInMainHand(); + Block b = e.getClickedBlock(); SlimefunItem machine = SlimefunItem.getByID(id); - for (ItemStack convert: RecipeType.getRecipeInputs(machine)) { + for (ItemStack convert : RecipeType.getRecipeInputs(machine)) { if (convert != null && SlimefunManager.isItemSimilar(input, convert, true)) { ItemStack removing = input.clone(); removing.setAmount(convert.getAmount()); @@ -79,6 +79,7 @@ public class Composter extends SlimefunGadget { for (int i = 1; i < 12; i++) { int j = i; + Bukkit.getScheduler().runTaskLater(SlimefunPlugin.instance, () -> { if (j < 11) { b.getWorld().playEffect(b.getLocation(), Effect.STEP_SOUND, input.getType().isBlock() ? input.getType() : Material.HAY_BLOCK); 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 3fb9dc79e..70b92d65e 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 @@ -46,12 +46,12 @@ public class Crucible extends SlimefunGadget { items.add(new ItemStack(Material.OBSIDIAN, 1)); items.add(new ItemStack(Material.LAVA_BUCKET)); - for (Material leave: MaterialCollections.getAllLeaves()) { + for (Material leave : MaterialCollections.getAllLeaves()) { items.add(new ItemStack(leave, 16)); items.add(new ItemStack(Material.WATER_BUCKET)); } - for (Material sapling: MaterialCollections.getAllTerracottaColors()) { + for (Material sapling : MaterialCollections.getAllTerracottaColors()) { items.add(new ItemStack(sapling, 12)); items.add(new ItemStack(Material.LAVA_BUCKET)); } @@ -70,7 +70,7 @@ public class Crucible extends SlimefunGadget { final Block block = e.getClickedBlock().getRelative(BlockFace.UP); SlimefunItem machine = SlimefunItem.getByID(id); - for (ItemStack convert: RecipeType.getRecipeInputs(machine)) { + for (ItemStack convert : RecipeType.getRecipeInputs(machine)) { if (SlimefunManager.isItemSimilar(input, convert, true)) { e.setCancelled(true); @@ -85,12 +85,14 @@ public class Crucible extends SlimefunGadget { level -= 8; if (level == 0) { block.getWorld().playSound(block.getLocation(), water ? Sound.ENTITY_PLAYER_SPLASH : Sound.BLOCK_LAVA_POP, 1F, 1F); - } else { + } + 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)) { + } + 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); @@ -136,11 +138,13 @@ public class Crucible extends SlimefunGadget { 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/InfusedHopper.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/InfusedHopper.java index 94cc4c537..62447d966 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/InfusedHopper.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/InfusedHopper.java @@ -34,7 +34,7 @@ public class InfusedHopper extends SimpleSlimefunItem { return new BlockTicker() { @Override - public void tick(Block b, SlimefunItem item, Config data) { + public void tick(Block b, SlimefunItem sfItem, Config data) { if (b.getType() != Material.HOPPER) { // we're no longer a hopper, we were probably destroyed. skipping this tick. BlockStorage.clearBlockInfo(b); @@ -44,9 +44,9 @@ public class InfusedHopper extends SimpleSlimefunItem { Location l = b.getLocation().add(0.5, 1.2, 0.5); boolean sound = false; - for (Entity n: b.getWorld().getNearbyEntities(l, 3.5D, 3.5D, 3.5D, n -> n instanceof Item && n.isValid() && !n.hasMetadata("no_pickup") && n.getLocation().distanceSquared(l) > 0.1)) { - n.setVelocity(new Vector(0, 0.1, 0)); - n.teleport(l); + for (Entity item : b.getWorld().getNearbyEntities(l, 3.5D, 3.5D, 3.5D, n -> n instanceof Item && n.isValid() && !n.hasMetadata("no_pickup") && n.getLocation().distanceSquared(l) > 0.1)) { + item.setVelocity(new Vector(0, 0.1, 0)); + item.teleport(l); sound = true; } 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 8f6f0f02e..0b310deb2 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 @@ -50,7 +50,7 @@ public class ReactorAccessPort extends SlimefunItem { if (reactor != null) { menu.replaceExistingItem(INFO_SLOT, new CustomItem(new ItemStack(Material.GREEN_WOOL), "&7Reactor", "", "&6Detected", "", "&7> Click to view Reactor")); menu.addMenuClickHandler(INFO_SLOT, (p, slot, item, action) -> { - if(reactor != null) { + if (reactor != null) { reactor.open(p); } newInstance(menu, b); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/TrashCan.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/TrashCan.java index 7960257cb..c9c1a2128 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/TrashCan.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/TrashCan.java @@ -48,7 +48,8 @@ public class TrashCan extends SlimefunItem implements InventoryBlock { @Override public void tick(Block b, SlimefunItem item, Config data) { BlockMenu menu = BlockStorage.getInventory(b); - for (int slot: getInputSlots()) { + + for (int slot : getInputSlots()) { menu.replaceExistingItem(slot, null); } } 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 293597d5b..e09e8237a 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 @@ -20,6 +20,7 @@ import me.mrCookieSlime.Slimefun.Objects.Category; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.abstractItems.AContainer; import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; import me.mrCookieSlime.Slimefun.api.BlockStorage; +import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; import me.mrCookieSlime.Slimefun.api.inventory.BlockMenu; import me.mrCookieSlime.Slimefun.api.inventory.BlockMenuPreset; import me.mrCookieSlime.Slimefun.api.item_transport.ItemTransportFlow; @@ -31,10 +32,10 @@ public abstract class ElectricSmeltery extends AContainer { private static final int[] border_in = {0, 1, 2, 3, 9, 12, 18, 21, 27, 30, 36, 37, 38, 39}; private static final int[] border_out = {14, 15, 16, 17, 23, 26, 32, 33, 34, 35}; - public ElectricSmeltery(Category category, ItemStack item, String name, RecipeType recipeType, ItemStack[] recipe) { - super(category, item, name, recipeType, recipe); + public ElectricSmeltery(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) { + super(category, item, recipeType, recipe); - new BlockMenuPreset(name, getInventoryTitle()) { + new BlockMenuPreset(getID(), getInventoryTitle()) { @Override public void init() { @@ -68,7 +69,6 @@ public abstract class ElectricSmeltery extends AContainer { } else { Collections.sort(slots, new RecipeSorter(menu)); - int[] array = new int[slots.size()]; for (int i = 0; i < slots.size(); i++) { @@ -80,8 +80,9 @@ public abstract class ElectricSmeltery extends AContainer { } }; - registerBlockHandler(name, (p, b, tool, reason) -> { + registerBlockHandler(getID(), (p, b, tool, reason) -> { BlockMenu inv = BlockStorage.getInventory(b); + if (inv != null) { for (int slot : getInputSlots()) { if (inv.getItemInSlot(slot) != null) { @@ -89,6 +90,7 @@ public abstract class ElectricSmeltery extends AContainer { inv.replaceExistingItem(slot, null); } } + for (int slot : getOutputSlots()) { if (inv.getItemInSlot(slot) != null) { b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot)); @@ -96,6 +98,7 @@ public abstract class ElectricSmeltery extends AContainer { } } } + progress.remove(b); processing.remove(b); return true; diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/Freezer.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/Freezer.java index d856e1e25..5bd3cba76 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/Freezer.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/Freezer.java @@ -33,7 +33,7 @@ public abstract class Freezer extends AContainer implements RecipeDisplayItem { public List getDisplayRecipes() { List displayRecipes = new ArrayList<>(recipes.size() * 2); - for (MachineRecipe recipe: recipes) { + for (MachineRecipe recipe : recipes) { displayRecipes.add(recipe.getInput()[0]); displayRecipes.add(recipe.getOutput()[recipe.getOutput().length - 1]); } 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 a56ce33d4..73a48e86f 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 @@ -61,7 +61,7 @@ public abstract class HeatedPressureChamber extends AContainer { List slots = new ArrayList<>(); - for (int slot: getInputSlots()) { + for (int slot : getInputSlots()) { if (SlimefunManager.isItemSimilar(menu.getItemInSlot(slot), item, true)) { slots.add(slot); } @@ -72,7 +72,6 @@ public abstract class HeatedPressureChamber extends AContainer { } else { Collections.sort(slots, new RecipeSorter(menu)); - int[] array = new int[slots.size()]; for (int i = 0; i < slots.size(); i++) { @@ -94,8 +93,9 @@ public abstract class HeatedPressureChamber extends AContainer { registerRecipe(30, new ItemStack[] {SlimefunItems.BLISTERING_INGOT, SlimefunItems.CARBONADO}, new ItemStack[] {SlimefunItems.BLISTERING_INGOT_2}); registerRecipe(60, new ItemStack[] {SlimefunItems.BLISTERING_INGOT_2, new ItemStack(Material.NETHER_STAR)}, new ItemStack[] {SlimefunItems.BLISTERING_INGOT_3}); registerRecipe(90, new ItemStack[] {SlimefunItems.PLUTONIUM, SlimefunItems.URANIUM}, new ItemStack[] {SlimefunItems.BOOSTED_URANIUM}); - registerRecipe(60, new ItemStack[] {SlimefunItems.NETHER_ICE, SlimefunItems.PLUTONIUM}, new ItemStack[]{new CustomItem(SlimefunItems.ENRICHED_NETHER_ICE, 4)}); - registerRecipe(45, new ItemStack[] {SlimefunItems.ENRICHED_NETHER_ICE}, new ItemStack[]{new CustomItem(SlimefunItems.NETHER_ICE_COOLANT_CELL, 8)}); + registerRecipe(60, new ItemStack[] {SlimefunItems.NETHER_ICE, SlimefunItems.PLUTONIUM}, new ItemStack[] {new CustomItem(SlimefunItems.ENRICHED_NETHER_ICE, 4)}); + registerRecipe(45, new ItemStack[] {SlimefunItems.ENRICHED_NETHER_ICE}, new ItemStack[] {new CustomItem(SlimefunItems.NETHER_ICE_COOLANT_CELL, 8)}); + registerRecipe(12, new ItemStack[] {SlimefunItems.MAGNESIUM_DUST, SlimefunItems.SALT}, new ItemStack[] {SlimefunItems.MAGNESIUM_SALT}); } @Override @@ -153,7 +153,7 @@ public abstract class HeatedPressureChamber 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], getOutputSlots()); progress.remove(b); processing.remove(b); @@ -164,9 +164,9 @@ public abstract class HeatedPressureChamber extends AContainer { MachineRecipe recipe = findRecipe(menu, found); if (recipe != null) { - if (!fits(b, recipe.getOutput())) return; + if (!menu.fits(recipe.getOutput()[0], getOutputSlots())) return; - for (Map.Entry entry: found.entrySet()) { + for (Map.Entry entry : found.entrySet()) { menu.replaceExistingItem(entry.getKey(), InvUtils.decreaseItem(menu.getItemInSlot(entry.getKey()), entry.getValue())); } @@ -177,9 +177,9 @@ public abstract class HeatedPressureChamber extends AContainer { } private MachineRecipe findRecipe(BlockMenu menu, Map found) { - for (MachineRecipe recipe: recipes) { - for (ItemStack input: recipe.getInput()) { - for (int slot: getInputSlots()) { + for (MachineRecipe recipe : recipes) { + for (ItemStack input : recipe.getInput()) { + for (int slot : getInputSlots()) { 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 1d582210a..0e1f33053 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 @@ -19,6 +19,7 @@ import me.mrCookieSlime.Slimefun.Setup.SlimefunManager; import me.mrCookieSlime.Slimefun.api.BlockStorage; import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; import me.mrCookieSlime.Slimefun.api.energy.ChargableBlock; +import me.mrCookieSlime.Slimefun.api.inventory.BlockMenu; import me.mrCookieSlime.Slimefun.utils.MachineHelper; public abstract class Refinery extends AContainer implements RecipeDisplayItem { @@ -49,32 +50,36 @@ public abstract class Refinery extends AContainer implements RecipeDisplayItem { @Override protected void tick(Block b) { + BlockMenu menu = BlockStorage.getInventory(b); + if (isProcessing(b)) { int timeleft = progress.get(b); + if (timeleft > 0) { - MachineHelper.updateProgressbar(BlockStorage.getInventory(b), 22, timeleft, processing.get(b).getTicks(), getProgressBar()); + MachineHelper.updateProgressbar(menu, 22, timeleft, processing.get(b).getTicks(), getProgressBar()); if (ChargableBlock.isChargable(b)) { if (ChargableBlock.getCharge(b) < getEnergyConsumption()) return; + ChargableBlock.addCharge(b, -getEnergyConsumption()); progress.put(b, timeleft - 1); } else progress.put(b, timeleft - 1); } else { - BlockStorage.getInventory(b).replaceExistingItem(22, new CustomItem(new ItemStack(Material.BLACK_STAINED_GLASS_PANE), " ")); - pushItems(b, processing.get(b).getOutput()); + menu.replaceExistingItem(22, new CustomItem(new ItemStack(Material.BLACK_STAINED_GLASS_PANE), " ")); + menu.pushItem(processing.get(b).getOutput()[0], getOutputSlots()); progress.remove(b); processing.remove(b); } } else { - for (int slot: getInputSlots()) { - if (SlimefunManager.isItemSimilar(BlockStorage.getInventory(b).getItemInSlot(slot), SlimefunItems.BUCKET_OF_OIL, true)) { + for (int slot : getInputSlots()) { + if (SlimefunManager.isItemSimilar(menu.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)); + if (!menu.fits(SlimefunItems.BUCKET_OF_FUEL, getOutputSlots())) return; + menu.replaceExistingItem(slot, InvUtils.decreaseItem(menu.getItemInSlot(slot), 1)); processing.put(b, r); progress.put(b, r.getTicks()); break; 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 19000c38b..ab3a5140a 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 @@ -2,7 +2,6 @@ package me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric; import java.util.logging.Level; -import org.bukkit.Bukkit; import org.bukkit.Location; import org.bukkit.Material; import org.bukkit.block.Block; @@ -25,6 +24,7 @@ import me.mrCookieSlime.Slimefun.Objects.handlers.BlockTicker; 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; import me.mrCookieSlime.Slimefun.api.inventory.BlockMenuPreset; @@ -40,10 +40,10 @@ public class WitherAssembler extends SlimefunItem { protected int energyConsumption = 4096; - public WitherAssembler(Category category, ItemStack item, String name, RecipeType recipeType, ItemStack[] recipe) { - super(category, item, name, recipeType, recipe); + public WitherAssembler(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) { + super(category, item, recipeType, recipe); - new BlockMenuPreset(name, "&5Wither Assembler") { + new BlockMenuPreset(getID(), "&5Wither Assembler") { @Override public void init() { @@ -105,7 +105,7 @@ public class WitherAssembler extends SlimefunItem { } }; - registerBlockHandler(name, new SlimefunBlockHandler() { + registerBlockHandler(getID(), new SlimefunBlockHandler() { @Override public void onPlace(Player p, Block b, SlimefunItem item) { @@ -117,13 +117,15 @@ public class WitherAssembler extends SlimefunItem { public boolean onBreak(Player p, Block b, SlimefunItem item, UnregisterReason reason) { if (reason == UnregisterReason.EXPLODE) return false; BlockMenu inv = BlockStorage.getInventory(b); + if (inv != null) { - for (int slot: getSoulSandSlots()) { + for (int slot : getSoulSandSlots()) { if (inv.getItemInSlot(slot) != null) { b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot)); inv.replaceExistingItem(slot, null); } } + for (int slot : getWitherSkullSlots()) { if (inv.getItemInSlot(slot) != null) { b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot)); @@ -216,7 +218,8 @@ public class WitherAssembler extends SlimefunItem { if (soulsand > 3 && skulls > 2) { for (int slot : getSoulSandSlots()) { if (SlimefunManager.isItemSimilar(BlockStorage.getInventory(b).getItemInSlot(slot), new ItemStack(Material.SOUL_SAND), true)) { - final int amount = BlockStorage.getInventory(b).getItemInSlot(slot).getAmount(); + int amount = BlockStorage.getInventory(b).getItemInSlot(slot).getAmount(); + if (amount >= soulsand) { BlockStorage.getInventory(b).replaceExistingItem(slot, InvUtils.decreaseItem(BlockStorage.getInventory(b).getItemInSlot(slot), soulsand)); break; @@ -230,7 +233,8 @@ public class WitherAssembler extends SlimefunItem { for (int slot : getWitherSkullSlots()) { if (SlimefunManager.isItemSimilar(BlockStorage.getInventory(b).getItemInSlot(slot), new ItemStack(Material.WITHER_SKELETON_SKULL), true)) { - final int amount = BlockStorage.getInventory(b).getItemInSlot(slot).getAmount(); + int amount = BlockStorage.getInventory(b).getItemInSlot(slot).getAmount(); + if (amount >= skulls) { BlockStorage.getInventory(b).replaceExistingItem(slot, InvUtils.decreaseItem(BlockStorage.getInventory(b).getItemInSlot(slot), skulls)); break; @@ -243,10 +247,9 @@ public class WitherAssembler extends SlimefunItem { } ChargableBlock.addCharge(b, -energyConsumption); + double offset = Double.parseDouble(BlockStorage.getLocationInfo(b.getLocation(), "offset")); - final double offset = Double.parseDouble(BlockStorage.getLocationInfo(b.getLocation(), "offset")); - - Bukkit.getScheduler().scheduleSyncDelayedTask(SlimefunPlugin.instance, () -> b.getWorld().spawnEntity(new Location(b.getWorld(), b.getX() + 0.5D, b.getY() + offset, b.getZ() + 0.5D), EntityType.WITHER)); + Slimefun.runSync(() -> b.getWorld().spawnEntity(new Location(b.getWorld(), b.getX() + 0.5D, b.getY() + offset, b.getZ() + 0.5D), EntityType.WITHER)); } } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/XPCollector.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/XPCollector.java index 2f7a62312..48f878cee 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/XPCollector.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/XPCollector.java @@ -47,7 +47,7 @@ public class XPCollector extends SlimefunItem implements InventoryBlock { public boolean onBreak(Player p, Block b, SlimefunItem item, UnregisterReason reason) { BlockMenu inv = BlockStorage.getInventory(b); if (inv != 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); @@ -70,10 +70,8 @@ public class XPCollector extends SlimefunItem implements InventoryBlock { } protected void constructMenu(BlockMenuPreset preset) { - for (int i : border) { - preset.addItem(i, new CustomItem(new ItemStack(Material.PURPLE_STAINED_GLASS_PANE), " "), - (p, slot, item, action) -> false - ); + for (int slot : border) { + preset.addItem(slot, new CustomItem(new ItemStack(Material.PURPLE_STAINED_GLASS_PANE), " "), (p, s, item, action) -> false); } } @@ -112,6 +110,7 @@ public class XPCollector extends SlimefunItem implements InventoryBlock { int withdrawn = 0; BlockMenu menu = BlockStorage.getInventory(b); + for (int level = 0; level < getEXP(b); level = level + 10) { if (menu.fits(new CustomItem(Material.EXPERIENCE_BOTTLE, "&aFlask of Knowledge"), getOutputSlots())) { withdrawn = withdrawn + 10; @@ -124,7 +123,9 @@ public class XPCollector extends SlimefunItem implements InventoryBlock { private int getEXP(Block b) { Config cfg = BlockStorage.getLocationInfo(b.getLocation()); - if (cfg.contains("stored-exp")) return Integer.parseInt(cfg.getString("stored-exp")); + if (cfg.contains("stored-exp")) { + return Integer.parseInt(cfg.getString("stored-exp")); + } else { BlockStorage.addBlockInfo(b, "stored-exp", "0"); return 0; diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/generators/MagnesiumGenerator.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/generators/MagnesiumGenerator.java new file mode 100644 index 000000000..40cb1ed87 --- /dev/null +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/generators/MagnesiumGenerator.java @@ -0,0 +1,34 @@ +package me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.generators; + +import org.bukkit.Material; +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.abstractItems.AGenerator; +import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.abstractItems.MachineFuel; +import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; + +public abstract class MagnesiumGenerator extends AGenerator { + + public MagnesiumGenerator(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) { + super(category, item, recipeType, recipe); + } + + @Override + public void registerDefaultRecipes() { + registerFuel(new MachineFuel(10, SlimefunItems.MAGNESIUM_SALT)); + } + + @Override + public ItemStack getProgressBar() { + return new ItemStack(Material.FLINT_AND_STEEL); + } + + @Override + public String getInventoryTitle() { + return "&cMagnesium-powered Generator"; + } + +} 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 22402962f..f0d14dbe5 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 @@ -55,8 +55,8 @@ public class GrindStone extends MultiBlockMachine { Dispenser disp = (Dispenser) dispBlock.getState(); Inventory inv = disp.getInventory(); - for (ItemStack current: inv.getContents()) { - for (ItemStack convert: RecipeType.getRecipeInputs(this)) { + for (ItemStack current : inv.getContents()) { + for (ItemStack convert : RecipeType.getRecipeInputs(this)) { 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/OreWasher.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/OreWasher.java index 56b055c4e..428120ebe 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 @@ -1,6 +1,8 @@ package me.mrCookieSlime.Slimefun.Objects.SlimefunItem.multiblocks; +import java.util.List; import java.util.Random; +import java.util.stream.Collectors; import org.bukkit.Effect; import org.bukkit.Material; @@ -41,6 +43,11 @@ public class OreWasher extends MultiBlockMachine { ); } + @Override + public List getDisplayRecipes() { + return recipes.stream().map(items -> items[0]).collect(Collectors.toList()); + } + @Override public void onInteract(Player p, Block b) { Block dispBlock = b.getRelative(BlockFace.UP); @@ -48,7 +55,7 @@ public class OreWasher extends MultiBlockMachine { Inventory inv = disp.getInventory(); ItemStack[] items = SlimefunPlugin.getUtilities().oreWasherOutputs; - for (ItemStack current: inv.getContents()) { + for (ItemStack current : inv.getContents()) { if (current != null) { if (SlimefunManager.isItemSimilar(current, SlimefunItems.SIFTED_ORE, true)) { ItemStack adding = items[new Random().nextInt(items.length)]; diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Setup/ResearchSetup.java b/src/main/java/me/mrCookieSlime/Slimefun/Setup/ResearchSetup.java index 91bcb4254..040099b6f 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Setup/ResearchSetup.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Setup/ResearchSetup.java @@ -248,5 +248,6 @@ public final class ResearchSetup { 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); + Slimefun.registerResearch(new Research(253, "Power from Magnesium", 20), SlimefunItems.MAGNESIUM_SALT, SlimefunItems.MAGNESIUM_GENERATOR); } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Setup/SlimefunSetup.java b/src/main/java/me/mrCookieSlime/Slimefun/Setup/SlimefunSetup.java index 6396d922c..64f2ec24d 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Setup/SlimefunSetup.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Setup/SlimefunSetup.java @@ -146,6 +146,7 @@ import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.generato import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.generators.CoalGenerator; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.generators.CombustionGenerator; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.generators.LavaGenerator; +import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.generators.MagnesiumGenerator; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.geo.GEOMiner; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.geo.GEOScannerBlock; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.geo.NetherDrill; @@ -2092,6 +2093,20 @@ public final class SlimefunSetup { } }.registerChargeableBlock(true, 1024); + + new SlimefunItem(Categories.RESOURCES, (SlimefunItemStack) SlimefunItems.MAGNESIUM_SALT, RecipeType.HEATED_PRESSURE_CHAMBER, + new ItemStack[] {SlimefunItems.MAGNESIUM_DUST, SlimefunItems.SALT, null, null, null, null, null, null, null}) + .register(true); + + new MagnesiumGenerator(Categories.ELECTRICITY, (SlimefunItemStack) SlimefunItems.MAGNESIUM_GENERATOR, RecipeType.ENHANCED_CRAFTING_TABLE, + new ItemStack[] {null, SlimefunItems.ELECTRIC_MOTOR, null, SlimefunItems.COMPRESSED_CARBON, new ItemStack(Material.WATER_BUCKET), SlimefunItems.COMPRESSED_CARBON, SlimefunItems.DURALUMIN_INGOT, SlimefunItems.DURALUMIN_INGOT, SlimefunItems.DURALUMIN_INGOT}) { + + @Override + public int getEnergyProduction() { + return 18; + } + + }.registerUnrechargeableBlock(true, 128); 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}) @@ -2789,7 +2804,7 @@ public final class SlimefunSetup { .register(true); new SlimefunItem(Categories.RESOURCES, (SlimefunItemStack) SlimefunItems.BLISTERING_INGOT_3, RecipeType.HEATED_PRESSURE_CHAMBER, - new ItemStack[] {SlimefunItems.BLISTERING_INGOT_2,new ItemStack(Material.NETHER_STAR), null, null, null, null, null, null, null}) + new ItemStack[] {SlimefunItems.BLISTERING_INGOT_2, new ItemStack(Material.NETHER_STAR), null, null, null, null, null, null, null}) .register(true); new SlimefunItem(Categories.RESOURCES, (SlimefunItemStack) SlimefunItems.ENRICHED_NETHER_ICE, RecipeType.HEATED_PRESSURE_CHAMBER, @@ -3225,7 +3240,7 @@ public final class SlimefunSetup { }.registerChargeableBlock(true, 512); - new ElectricSmeltery(Categories.ELECTRICITY, SlimefunItems.ELECTRIC_SMELTERY, "ELECTRIC_SMELTERY", RecipeType.ENHANCED_CRAFTING_TABLE, + new ElectricSmeltery(Categories.ELECTRICITY, (SlimefunItemStack) SlimefunItems.ELECTRIC_SMELTERY, RecipeType.ENHANCED_CRAFTING_TABLE, new ItemStack[] {new ItemStack(Material.NETHER_BRICKS), SlimefunItems.ELECTRIC_MOTOR, new ItemStack(Material.NETHER_BRICKS), SlimefunItems.HEATING_COIL, SlimefunItems.ELECTRIC_INGOT_FACTORY, SlimefunItems.HEATING_COIL, SlimefunItems.GILDED_IRON, SlimefunItems.ELECTRIC_MOTOR, SlimefunItems.GILDED_IRON}) { @Override @@ -3240,7 +3255,7 @@ public final class SlimefunSetup { }.registerChargeableBlock(true, 512); - new ElectricSmeltery(Categories.ELECTRICITY, SlimefunItems.ELECTRIC_SMELTERY_2, "ELECTRIC_SMELTERY_2", RecipeType.ENHANCED_CRAFTING_TABLE, + new ElectricSmeltery(Categories.ELECTRICITY, (SlimefunItemStack) SlimefunItems.ELECTRIC_SMELTERY_2, RecipeType.ENHANCED_CRAFTING_TABLE, new ItemStack[] {SlimefunItems.DAMASCUS_STEEL_INGOT, SlimefunItems.POWER_CRYSTAL, SlimefunItems.DAMASCUS_STEEL_INGOT, SlimefunItems.HEATING_COIL, SlimefunItems.ELECTRIC_SMELTERY, SlimefunItems.HEATING_COIL, SlimefunItems.GILDED_IRON, SlimefunItems.ELECTRIC_MOTOR, SlimefunItems.GILDED_IRON}) { @Override @@ -3255,10 +3270,9 @@ public final class SlimefunSetup { }.registerChargeableBlock(true, 1024); - new WitherAssembler(Categories.ELECTRICITY, SlimefunItems.WITHER_ASSEMBLER, "WITHER_ASSEMBLER", RecipeType.ENHANCED_CRAFTING_TABLE, + new WitherAssembler(Categories.ELECTRICITY, (SlimefunItemStack) SlimefunItems.WITHER_ASSEMBLER, RecipeType.ENHANCED_CRAFTING_TABLE, new ItemStack[] {SlimefunItems.BLISTERING_INGOT_3, new ItemStack(Material.NETHER_STAR), SlimefunItems.BLISTERING_INGOT_3, SlimefunItems.WITHER_PROOF_OBSIDIAN, SlimefunItems.ANDROID_MEMORY_CORE, SlimefunItems.WITHER_PROOF_OBSIDIAN, SlimefunItems.ELECTRIC_MOTOR, SlimefunItems.REINFORCED_ALLOY_INGOT, SlimefunItems.CARBONADO_EDGED_CAPACITOR}) .registerChargeableBlock(true, 4096); - } public static void registerPostHandler(PostSlimefunLoadingHandler handler) { From b1ae5c9047bae909507125cc6104435569fdd121 Mon Sep 17 00:00:00 2001 From: J3fftw1 <44972470+J3fftw1@users.noreply.github.com> Date: Tue, 17 Dec 2019 23:03:56 +0100 Subject: [PATCH 6/7] added a way to automate sand production --- .../Slimefun/Objects/SlimefunItem/multiblocks/OreCrusher.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) 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 25963640d..911713838 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 @@ -37,7 +37,8 @@ public class OreCrusher extends MultiBlockMachine { SlimefunItems.PURE_ORE_CLUSTER, SlimefunItems.TINY_URANIUM, new ItemStack(Material.COBBLESTONE, 8), new ItemStack(Material.SAND, 1), new ItemStack(Material.GOLD_INGOT), SlimefunItems.GOLD_DUST, - SlimefunItems.GOLD_4K, SlimefunItems.GOLD_DUST + SlimefunItems.GOLD_4K, SlimefunItems.GOLD_DUST, + new ItemStack(Material.GRAVEL), new ItemStack(Material.SAND) }, BlockFace.SELF ); From f7fa6e2972c403228db088e940959b2b78d60152 Mon Sep 17 00:00:00 2001 From: TheBusyBiscuit Date: Wed, 18 Dec 2019 01:07:04 +0100 Subject: [PATCH 7/7] [CI skip] Reduced technical debt and tweaked Magnesium Salt --- .../Slimefun/Objects/Category.java | 10 ++-- .../Objects/SlimefunItem/EnhancedFurnace.java | 16 +++--- .../Objects/SlimefunItem/ItemState.java | 1 + .../Objects/SlimefunItem/JetBoots.java | 2 +- .../SlimefunItem/SlimefunArmorPiece.java | 2 +- .../SlimefunItem/SlimefunBackpack.java | 2 +- .../Objects/SlimefunItem/SlimefunBow.java | 1 + .../Objects/SlimefunItem/Talisman.java | 1 + .../Objects/SlimefunItem/VanillaItem.java | 1 + .../SlimefunItem/machines/BlockPlacer.java | 4 +- .../electric/AnimalGrowthAccelerator.java | 8 +-- .../machines/electric/AutoAnvil.java | 5 +- .../machines/electric/AutoDisenchanter.java | 20 ++++---- .../machines/electric/AutoDrier.java | 2 +- .../machines/electric/AutoEnchanter.java | 17 ++++--- .../electric/AutomatedCraftingChamber.java | 4 +- .../machines/electric/ChargingBench.java | 4 +- .../electric/CropGrowthAccelerator.java | 8 +-- .../machines/electric/ElectricDustWasher.java | 6 +-- .../machines/electric/ElectricFurnace.java | 4 +- .../machines/electric/ElectricGoldPan.java | 2 +- .../electric/ElectricIngotPulverizer.java | 2 +- .../machines/electric/FluidPump.java | 1 + .../electric/HeatedPressureChamber.java | 2 +- .../machines/electric/Refinery.java | 2 + .../machines/electric/WitherAssembler.java | 50 ++++++++----------- .../machines/electric/XPCollector.java | 6 +-- .../generators/MagnesiumGenerator.java | 2 +- .../machines/electric/geo/GEOMiner.java | 6 ++- .../electric/{ => gps}/ElevatorPlate.java | 3 +- .../SlimefunItem/multiblocks/ArmorForge.java | 3 ++ .../SlimefunItem/multiblocks/Compressor.java | 9 ++-- .../multiblocks/EnhancedCraftingTable.java | 5 +- .../SlimefunItem/multiblocks/Juicer.java | 5 +- .../multiblocks/MagicWorkbench.java | 13 +++-- .../SlimefunItem/multiblocks/OreCrusher.java | 5 +- .../SlimefunItem/multiblocks/TableSaw.java | 2 +- .../Slimefun/Setup/SlimefunSetup.java | 2 +- .../Slimefun/api/BlockInfoConfig.java | 2 +- .../Slimefun/api/BlockStorage.java | 45 ++++++++++++----- .../Slimefun/api/GuideHandler.java | 1 + 41 files changed, 161 insertions(+), 125 deletions(-) rename src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/{ => gps}/ElevatorPlate.java (99%) diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/Category.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/Category.java index becdae2e4..8103249b2 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/Category.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/Category.java @@ -4,13 +4,17 @@ import java.util.ArrayList; import java.util.Collections; import java.util.List; +import org.bukkit.entity.Player; import org.bukkit.inventory.ItemFlag; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.ItemMeta; +import io.github.thebusybiscuit.slimefun4.core.guide.SlimefunGuideLayout; +import me.mrCookieSlime.Slimefun.SlimefunGuide; import me.mrCookieSlime.Slimefun.SlimefunPlugin; import me.mrCookieSlime.Slimefun.Lists.Categories; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem; +import me.mrCookieSlime.Slimefun.api.PlayerProfile; /** * Statically handles categories. @@ -25,9 +29,9 @@ import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem; */ public class Category { - private ItemStack item; - private List items; - private int tier; + private final ItemStack item; + private final List items; + private final int tier; /** * Constructs a Category with the given display item. diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/EnhancedFurnace.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/EnhancedFurnace.java index af32247d7..45a6f77dd 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/EnhancedFurnace.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/EnhancedFurnace.java @@ -15,9 +15,9 @@ import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class EnhancedFurnace extends SimpleSlimefunItem { - private int speed; - private int efficiency; - private int fortune; + private final int speed; + private final int efficiency; + private final int fortune; public EnhancedFurnace(int speed, int efficiency, int fortune, SlimefunItemStack item, ItemStack[] recipe) { super(Categories.MACHINES_1, item, RecipeType.ENHANCED_CRAFTING_TABLE, recipe); @@ -36,11 +36,11 @@ public class EnhancedFurnace extends SimpleSlimefunItem { } public int getOutput() { - int fortune = this.fortune; - fortune = new Random().nextInt(fortune + 2) - 1; - if (fortune <= 0) fortune = 0; - fortune++; - return fortune; + int bonus = this.fortune; + bonus = new Random().nextInt(bonus + 2) - 1; + if (bonus <= 0) bonus = 0; + bonus++; + return bonus; } @Override diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/ItemState.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/ItemState.java index 80c611478..6bf0e1e72 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/ItemState.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/ItemState.java @@ -6,6 +6,7 @@ package me.mrCookieSlime.Slimefun.Objects.SlimefunItem; * @since 4.1.10 */ public enum ItemState { + /** * This SlimefunItem is enabled. */ diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/JetBoots.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/JetBoots.java index f06fa21ab..bd870f10b 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/JetBoots.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/JetBoots.java @@ -8,7 +8,7 @@ import org.bukkit.inventory.ItemStack; public class JetBoots extends DamagableChargableItem { - private double speed; + private final double speed; public JetBoots(SlimefunItemStack item, ItemStack[] recipe, double speed) { super(Categories.TECH, item, RecipeType.ENHANCED_CRAFTING_TABLE, recipe, "Jet Boots"); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SlimefunArmorPiece.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SlimefunArmorPiece.java index 397993821..afd7dcde7 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SlimefunArmorPiece.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SlimefunArmorPiece.java @@ -9,7 +9,7 @@ import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class SlimefunArmorPiece extends SlimefunItem { - private PotionEffect[] effects; + private final PotionEffect[] effects; public SlimefunArmorPiece(Category category, ItemStack item, String id, RecipeType recipeType, ItemStack[] recipe, PotionEffect[] effects) { super(category, item, id, recipeType, recipe); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SlimefunBackpack.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SlimefunBackpack.java index 3e246c1fd..146d0d1af 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SlimefunBackpack.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SlimefunBackpack.java @@ -8,7 +8,7 @@ import me.mrCookieSlime.Slimefun.api.SlimefunItemStack; public class SlimefunBackpack extends SlimefunItem { - private int size; + private final int size; public SlimefunBackpack(int size, Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) { super(category, item, recipeType, recipe); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SlimefunBow.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SlimefunBow.java index c1cf9e81e..802ac4f23 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SlimefunBow.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/SlimefunBow.java @@ -12,6 +12,7 @@ public class SlimefunBow extends SlimefunItem { super(Categories.WEAPONS, item, id, RecipeType.MAGIC_WORKBENCH, recipe); } + @Deprecated public SlimefunBow(SlimefunItemStack item, ItemStack[] recipe) { super(Categories.WEAPONS, item, RecipeType.MAGIC_WORKBENCH, recipe); } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/Talisman.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/Talisman.java index 0869d07fe..65bffeac2 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/Talisman.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/Talisman.java @@ -100,6 +100,7 @@ public class Talisman extends SlimefunItem { public void install() { EnderTalisman talisman = (EnderTalisman) SlimefunItem.getByItem(upgrade()); Research research = Research.getByID(112); + if (talisman != null) { Slimefun.addOfficialWikiPage(talisman.getID(), "Talismans"); if (research != null) talisman.bindToResearch(research); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/VanillaItem.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/VanillaItem.java index 30a1707c3..5663346b3 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/VanillaItem.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/VanillaItem.java @@ -27,6 +27,7 @@ public class VanillaItem extends SlimefunItem { */ public VanillaItem(Category category, ItemStack item, String id, RecipeType recipeType, ItemStack[] recipe) { super(category, item, id, recipeType, recipe); + useableInWorkbench = true; } } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/BlockPlacer.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/BlockPlacer.java index 0b8f67514..765d7ece2 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/BlockPlacer.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/BlockPlacer.java @@ -10,7 +10,7 @@ import org.bukkit.inventory.BlockInventoryHolder; import org.bukkit.inventory.ItemStack; import org.bukkit.inventory.meta.BlockStateMeta; -import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.Item.CustomItem; +import io.github.thebusybiscuit.cscorelib2.item.CustomItem; import me.mrCookieSlime.Slimefun.SlimefunPlugin; import me.mrCookieSlime.Slimefun.Lists.RecipeType; import me.mrCookieSlime.Slimefun.Objects.Category; @@ -77,7 +77,7 @@ public class BlockPlacer extends SimpleSlimefunItem { //Changing the inventory of the block based on the inventory of the block's itemstack (Currently only applies to shulker boxes) //Inventory has to be changed after blockState.update() as updating it will create a different Inventory for the object if (block.getState() instanceof BlockInventoryHolder) { - ((BlockInventoryHolder) block.getState()).getInventory().setContents(((BlockInventoryHolder) itemBlockState).getInventory().getContents());; + ((BlockInventoryHolder) block.getState()).getInventory().setContents(((BlockInventoryHolder) itemBlockState).getInventory().getContents()); } } 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 e50d6cc96..a183ff773 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 @@ -73,11 +73,7 @@ public class AnimalGrowthAccelerator extends SlimefunItem implements InventoryBl @Override public void tick(Block b, SlimefunItem sf, Config data) { - try { - AnimalGrowthAccelerator.this.tick(b); - } catch (Exception x) { - Slimefun.getLogger().log(Level.SEVERE, "An Error occured while ticking an Animal Growth Accelerator for Slimefun " + Slimefun.getVersion(), x); - } + AnimalGrowthAccelerator.this.tick(b); } @Override @@ -89,7 +85,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()) { + for (int slot : getInputSlots()) { if (SlimefunManager.isItemSimilar(BlockStorage.getInventory(b).getItemInSlot(slot), SlimefunItems.ORGANIC_FOOD, false)) { if (ChargableBlock.getCharge(b) < energyConsumption) return; 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 2b98d2bf2..1d58de3c3 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 @@ -75,7 +75,7 @@ public abstract class AutoAnvil extends AContainer { else { MachineRecipe recipe = null; - for (int slot: getInputSlots()) { + for (int slot : getInputSlots()) { ItemStack target = menu.getItemInSlot(slot == getInputSlots()[0] ? getInputSlots()[1]: getInputSlots()[0]); ItemStack item = menu.getItemInSlot(slot); @@ -96,9 +96,10 @@ public abstract class AutoAnvil extends AContainer { if (recipe != null) { if (!menu.fits(recipe.getOutput()[0], getOutputSlots())) return; - for (int slot: getInputSlots()) { + for (int slot : getInputSlots()) { menu.replaceExistingItem(slot, InvUtils.decreaseItem(menu.getItemInSlot(slot), 1)); } + processing.put(b, recipe); progress.put(b, recipe.getTicks()); } 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 c8454ca91..418b195e5 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 @@ -81,7 +81,7 @@ public class AutoDisenchanter extends AContainer { else { MachineRecipe recipe = null; Map enchantments = new HashMap<>(); - Set enchantments2 = new HashSet<>(); + Set emeraldEnchantments = new HashSet<>(); for (int slot : getInputSlots()) { ItemStack target = menu.getItemInSlot(slot == getInputSlots()[0] ? getInputSlots()[1]: getInputSlots()[0]); @@ -108,15 +108,15 @@ public class AutoDisenchanter extends AContainer { if (item != null && target != null && target.getType() == Material.BOOK) { int amount = 0; - for (Map.Entry e : item.getEnchantments().entrySet()) { - enchantments.put(e.getKey(), e.getValue()); + for (Map.Entry entry : item.getEnchantments().entrySet()) { + enchantments.put(entry.getKey(), entry.getValue()); amount++; } if (SlimefunPlugin.getHooks().isEmeraldEnchantsInstalled()) { for (ItemEnchantment enchantment : EmeraldEnchants.getInstance().getRegistry().getEnchantments(item)) { amount++; - enchantments2.add(enchantment); + emeraldEnchantments.add(enchantment); } } @@ -136,16 +136,16 @@ public class AutoDisenchanter extends AContainer { EnchantmentStorageMeta meta = (EnchantmentStorageMeta) book.getItemMeta(); - for (Map.Entry e : enchantments.entrySet()) { - newItem.removeEnchantment(e.getKey()); - meta.addStoredEnchant(e.getKey(), e.getValue(), true); + for (Map.Entry entry : enchantments.entrySet()) { + newItem.removeEnchantment(entry.getKey()); + meta.addStoredEnchant(entry.getKey(), entry.getValue(), true); } book.setItemMeta(meta); - for (ItemEnchantment e : enchantments2) { - EmeraldEnchants.getInstance().getRegistry().applyEnchantment(book, e.getEnchantment(), e.getLevel()); - EmeraldEnchants.getInstance().getRegistry().applyEnchantment(newItem, e.getEnchantment(), 0); + for (ItemEnchantment ench : emeraldEnchantments) { + EmeraldEnchants.getInstance().getRegistry().applyEnchantment(book, ench.getEnchantment(), ench.getLevel()); + EmeraldEnchants.getInstance().getRegistry().applyEnchantment(newItem, ench.getEnchantment(), 0); } recipe = new MachineRecipe(100 * amount, new ItemStack[] {target, item}, new ItemStack[] {newItem, book}); 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 0d1cc6d73..f8b891f72 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 @@ -113,7 +113,7 @@ public class AutoDrier extends AContainer implements RecipeDisplayItem { MachineRecipe r = null; int inputSlot = -1; - for (int slot: getInputSlots()) { + for (int slot : getInputSlots()) { ItemStack item = menu.getItemInSlot(slot); if (item != null) { Material mat = item.getType(); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutoEnchanter.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutoEnchanter.java index e96796373..a6a8beaa8 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutoEnchanter.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/AutoEnchanter.java @@ -74,7 +74,7 @@ public class AutoEnchanter extends AContainer { else { MachineRecipe recipe = null; - for (int slot: getInputSlots()) { + for (int slot : getInputSlots()) { ItemStack target = menu.getItemInSlot(slot == getInputSlots()[0] ? getInputSlots()[1]: getInputSlots()[0]); // Check if enchantable SlimefunItem sfTarget = SlimefunItem.getByItem(target); @@ -85,7 +85,7 @@ public class AutoEnchanter extends AContainer { // Enchant if (item != null && item.getType() == Material.ENCHANTED_BOOK && target != null) { Map enchantments = new HashMap<>(); - Set enchantments2 = new HashSet<>(); + Set emeraldEnchantments = new HashSet<>(); int amount = 0; int specialAmount = 0; EnchantmentStorageMeta meta = (EnchantmentStorageMeta) item.getItemMeta(); @@ -98,11 +98,11 @@ public class AutoEnchanter extends AContainer { } if (SlimefunPlugin.getHooks().isEmeraldEnchantsInstalled()) { - for (ItemEnchantment enchantment: EmeraldEnchants.getInstance().getRegistry().getEnchantments(item)) { + for (ItemEnchantment enchantment : EmeraldEnchants.getInstance().getRegistry().getEnchantments(item)) { if (EmeraldEnchants.getInstance().getRegistry().isApplicable(target, enchantment.getEnchantment()) && EmeraldEnchants.getInstance().getRegistry().getEnchantmentLevel(target, enchantment.getEnchantment().getName()) < enchantment.getLevel()) { amount++; specialAmount++; - enchantments2.add(enchantment); + emeraldEnchantments.add(enchantment); } } specialAmount += EmeraldEnchants.getInstance().getRegistry().getEnchantments(target).size(); @@ -110,12 +110,13 @@ public class AutoEnchanter extends AContainer { if (amount > 0 && specialAmount <= SlimefunPlugin.getSettings().emeraldEnchantsLimit) { ItemStack newItem = target.clone(); - for (Map.Entry e: enchantments.entrySet()) { - newItem.addUnsafeEnchantment(e.getKey(), e.getValue()); + + for (Map.Entry entry : enchantments.entrySet()) { + newItem.addUnsafeEnchantment(entry.getKey(), entry.getValue()); } - for (ItemEnchantment e: enchantments2) { - EmeraldEnchants.getInstance().getRegistry().applyEnchantment(newItem, e.getEnchantment(), e.getLevel()); + for (ItemEnchantment ench: emeraldEnchantments) { + EmeraldEnchants.getInstance().getRegistry().applyEnchantment(newItem, ench.getEnchantment(), ench.getLevel()); } recipe = new MachineRecipe(75 * amount, new ItemStack[] {target, item}, new ItemStack[] {newItem, new ItemStack(Material.BOOK)}); 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 93ac9de05..7e319abe9 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 @@ -110,13 +110,13 @@ public abstract class AutomatedCraftingChamber extends SlimefunItem implements I public boolean onBreak(Player p, Block b, SlimefunItem item, UnregisterReason reason) { BlockMenu inv = BlockStorage.getInventory(b); if (inv != null) { - for (int slot: getInputSlots()) { + for (int slot : getInputSlots()) { if (inv.getItemInSlot(slot) != null) { b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot)); inv.replaceExistingItem(slot, 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); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ChargingBench.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ChargingBench.java index 0164ca0e3..b452fe158 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ChargingBench.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ChargingBench.java @@ -39,13 +39,15 @@ public class ChargingBench extends AContainer { if (ChargableBlock.getCharge(b) < getEnergyConsumption()) return; BlockMenu menu = BlockStorage.getInventory(b); - for (int slot: getInputSlots()) { + + for (int slot : getInputSlots()) { ItemStack stack = menu.getItemInSlot(slot); if (ItemEnergy.getMaxEnergy(stack) > 0) { if (ItemEnergy.getStoredEnergy(stack) < ItemEnergy.getMaxEnergy(stack)) { ChargableBlock.addCharge(b, -getEnergyConsumption()); float rest = ItemEnergy.addStoredEnergy(stack, getEnergyConsumption() / 2F); + if (rest > 0F) { if (menu.fits(stack, getOutputSlots())) { menu.pushItem(stack, getOutputSlots()); 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 1789b0f3d..da7032542 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 @@ -49,7 +49,7 @@ public abstract class CropGrowthAccelerator extends SlimefunItem implements Inve registerBlockHandler(getID(), (p, b, tool, reason) -> { BlockMenu inv = BlockStorage.getInventory(b); if (inv != null) { - for (int slot: getInputSlots()) { + for (int slot : getInputSlots()) { if (inv.getItemInSlot(slot) != null) { b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot)); inv.replaceExistingItem(slot, null); @@ -88,11 +88,7 @@ public abstract class CropGrowthAccelerator extends SlimefunItem implements Inve @Override public void tick(Block b, SlimefunItem sf, Config data) { - try { - CropGrowthAccelerator.this.tick(b); - } catch (Exception x) { - Slimefun.getLogger().log(Level.SEVERE, "An Error occured while ticking a Crop Growth Accelerator for Slimefun " + Slimefun.getVersion(), x); - } + CropGrowthAccelerator.this.tick(b); } @Override 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 dcadb222a..f31815163 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 @@ -68,13 +68,13 @@ public abstract class ElectricDustWasher extends AContainer { else { ItemStack[] items = SlimefunPlugin.getUtilities().oreWasherOutputs; - for (int slot: getInputSlots()) { + for (int slot : getInputSlots()) { if (SlimefunManager.isItemSimilar(menu.getItemInSlot(slot), SlimefunItems.SIFTED_ORE, true)) { if (!SlimefunPlugin.getSettings().legacyDustWasher) { boolean emptySlot = false; - for (int output_slot: getOutputSlots()) { - if (menu.getItemInSlot(output_slot) == null) { + for (int outputSlot : getOutputSlots()) { + if (menu.getItemInSlot(outputSlot) == null) { emptySlot = true; break; } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricFurnace.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricFurnace.java index fec068a96..552a3207c 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricFurnace.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricFurnace.java @@ -31,8 +31,8 @@ public abstract class ElectricFurnace extends AContainer { } //Bukkit Recipe Iterator does not seem to include _LOG's of any type for charcoal... Manually adding them all. - for (Material mat:Tag.LOGS.getValues()) { - registerRecipe(4, new ItemStack[] {new ItemStack(mat,1)}, new ItemStack[] {new ItemStack(Material.CHARCOAL, 1)}); + for (Material log : Tag.LOGS.getValues()) { + registerRecipe(4, new ItemStack[] {new ItemStack(log, 1)}, new ItemStack[] {new ItemStack(Material.CHARCOAL, 1)}); } } 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 445642067..53abda614 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 @@ -115,7 +115,7 @@ public abstract class ElectricGoldPan extends AContainer implements RecipeDispla } } else { - for (int slot: getInputSlots()) { + for (int slot : getInputSlots()) { if (SlimefunManager.isItemSimilar(menu.getItemInSlot(slot), new ItemStack(Material.GRAVEL), true)) { ItemStack output = randomizer.getRandom(); diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricIngotPulverizer.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricIngotPulverizer.java index 5a24e08aa..f5763d35e 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricIngotPulverizer.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElectricIngotPulverizer.java @@ -47,7 +47,7 @@ public class ElectricIngotPulverizer extends AContainer implements RecipeDisplay public List getDisplayRecipes() { List displayRecipes = new ArrayList<>(recipes.size() * 2); - for (MachineRecipe recipe: recipes) { + for (MachineRecipe recipe : recipes) { displayRecipes.add(recipe.getInput()[0]); displayRecipes.add(recipe.getOutput()[0]); } 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 d7a49a850..be3ae3c5f 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 @@ -92,6 +92,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.isItemSimilar(menu.getItemInSlot(slot), new ItemStack(Material.BUCKET), true)) { if (!menu.fits(output, getOutputSlots())) return; 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 73a48e86f..d73ce1b6f 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 @@ -95,7 +95,7 @@ public abstract class HeatedPressureChamber extends AContainer { registerRecipe(90, new ItemStack[] {SlimefunItems.PLUTONIUM, SlimefunItems.URANIUM}, new ItemStack[] {SlimefunItems.BOOSTED_URANIUM}); registerRecipe(60, new ItemStack[] {SlimefunItems.NETHER_ICE, SlimefunItems.PLUTONIUM}, new ItemStack[] {new CustomItem(SlimefunItems.ENRICHED_NETHER_ICE, 4)}); registerRecipe(45, new ItemStack[] {SlimefunItems.ENRICHED_NETHER_ICE}, new ItemStack[] {new CustomItem(SlimefunItems.NETHER_ICE_COOLANT_CELL, 8)}); - registerRecipe(12, new ItemStack[] {SlimefunItems.MAGNESIUM_DUST, SlimefunItems.SALT}, new ItemStack[] {SlimefunItems.MAGNESIUM_SALT}); + registerRecipe(8, new ItemStack[] {SlimefunItems.MAGNESIUM_DUST, SlimefunItems.SALT}, new ItemStack[] {SlimefunItems.MAGNESIUM_SALT}); } @Override 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 0e1f33053..7063baa91 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 @@ -78,7 +78,9 @@ public abstract class Refinery extends AContainer implements RecipeDisplayItem { for (int slot : getInputSlots()) { if (SlimefunManager.isItemSimilar(menu.getItemInSlot(slot), SlimefunItems.BUCKET_OF_OIL, true)) { MachineRecipe r = new MachineRecipe(40, new ItemStack[0], new ItemStack[] {SlimefunItems.BUCKET_OF_FUEL}); + if (!menu.fits(SlimefunItems.BUCKET_OF_FUEL, 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/WitherAssembler.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/WitherAssembler.java index ab3a5140a..6820f810e 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 @@ -1,7 +1,5 @@ package me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric; -import java.util.logging.Level; - import org.bukkit.Location; import org.bukkit.Material; import org.bukkit.block.Block; @@ -52,36 +50,32 @@ public class WitherAssembler extends SlimefunItem { @Override public void newInstance(final BlockMenu menu, final Block b) { - try { - if (!BlockStorage.hasBlockInfo(b) || BlockStorage.getLocationInfo(b.getLocation(), "enabled") == null || BlockStorage.getLocationInfo(b.getLocation(), "enabled").equals("false")) { - menu.replaceExistingItem(22, new CustomItem(new ItemStack(Material.GUNPOWDER), "&7Enabled: &4\u2718", "", "&e> Click to enable this Machine")); - menu.addMenuClickHandler(22, (p, slot, item, action) -> { - BlockStorage.addBlockInfo(b, "enabled", "true"); - newInstance(menu, b); - return false; - }); - } - else { - menu.replaceExistingItem(22, new CustomItem(new ItemStack(Material.REDSTONE), "&7Enabled: &2\u2714", "", "&e> Click to disable this Machine")); - menu.addMenuClickHandler(22, (p, slot, item, action) -> { - BlockStorage.addBlockInfo(b, "enabled", "false"); - newInstance(menu, b); - return false; - }); - } - - double offset = (!BlockStorage.hasBlockInfo(b) || BlockStorage.getLocationInfo(b.getLocation(), "offset") == null) ? 3.0F: Double.valueOf(BlockStorage.getLocationInfo(b.getLocation(), "offset")); - - menu.replaceExistingItem(31, new CustomItem(new ItemStack(Material.PISTON), "&7Offset: &3" + offset + " Block(s)", "", "&rLeft Click: &7+0.1", "&rRight Click: &7-0.1")); - menu.addMenuClickHandler(31, (p, slot, item, action) -> { - double offsetv = DoubleHandler.fixDouble(Double.valueOf(BlockStorage.getLocationInfo(b.getLocation(), "offset")) + (action.isRightClicked() ? -0.1F : 0.1F)); - BlockStorage.addBlockInfo(b, "offset", String.valueOf(offsetv)); + if (!BlockStorage.hasBlockInfo(b) || BlockStorage.getLocationInfo(b.getLocation(), "enabled") == null || BlockStorage.getLocationInfo(b.getLocation(), "enabled").equals("false")) { + menu.replaceExistingItem(22, new CustomItem(new ItemStack(Material.GUNPOWDER), "&7Enabled: &4\u2718", "", "&e> Click to enable this Machine")); + menu.addMenuClickHandler(22, (p, slot, item, action) -> { + BlockStorage.addBlockInfo(b, "enabled", "true"); newInstance(menu, b); return false; }); - } catch(Exception x) { - Slimefun.getLogger().log(Level.SEVERE, "An Error occured while creating a Wither Assembler for Slimefun " + Slimefun.getVersion(), x); } + else { + menu.replaceExistingItem(22, new CustomItem(new ItemStack(Material.REDSTONE), "&7Enabled: &2\u2714", "", "&e> Click to disable this Machine")); + menu.addMenuClickHandler(22, (p, slot, item, action) -> { + BlockStorage.addBlockInfo(b, "enabled", "false"); + newInstance(menu, b); + return false; + }); + } + + double offset = (!BlockStorage.hasBlockInfo(b) || BlockStorage.getLocationInfo(b.getLocation(), "offset") == null) ? 3.0F: Double.valueOf(BlockStorage.getLocationInfo(b.getLocation(), "offset")); + + menu.replaceExistingItem(31, new CustomItem(new ItemStack(Material.PISTON), "&7Offset: &3" + offset + " Block(s)", "", "&rLeft Click: &7+0.1", "&rRight Click: &7-0.1")); + menu.addMenuClickHandler(31, (p, slot, item, action) -> { + double offsetv = DoubleHandler.fixDouble(Double.valueOf(BlockStorage.getLocationInfo(b.getLocation(), "offset")) + (action.isRightClicked() ? -0.1F : 0.1F)); + BlockStorage.addBlockInfo(b, "offset", String.valueOf(offsetv)); + newInstance(menu, b); + return false; + }); } @Override diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/XPCollector.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/XPCollector.java index 48f878cee..f5e2336fb 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/XPCollector.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/XPCollector.java @@ -81,11 +81,7 @@ public class XPCollector extends SlimefunItem implements InventoryBlock { @Override public void tick(Block b, SlimefunItem sf, Config data) { - try { - XPCollector.this.tick(b); - } catch (Exception x) { - Slimefun.getLogger().log(Level.SEVERE, "An Error occured while ticking an Exp Collector for Slimefun " + Slimefun.getVersion(), x); - } + XPCollector.this.tick(b); } @Override diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/generators/MagnesiumGenerator.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/generators/MagnesiumGenerator.java index 40cb1ed87..36ae4be0b 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/generators/MagnesiumGenerator.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/generators/MagnesiumGenerator.java @@ -18,7 +18,7 @@ public abstract class MagnesiumGenerator extends AGenerator { @Override public void registerDefaultRecipes() { - registerFuel(new MachineFuel(10, SlimefunItems.MAGNESIUM_SALT)); + registerFuel(new MachineFuel(12, SlimefunItems.MAGNESIUM_SALT)); } @Override 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 3c70437be..cad09950d 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 @@ -109,7 +109,8 @@ public abstract class GEOMiner extends AContainer implements InventoryBlock, Rec @Override public List getDisplayRecipes() { List displayRecipes = new LinkedList<>(); - for (OreGenResource resource: OreGenSystem.listResources()) { + + for (OreGenResource resource : OreGenSystem.listResources()) { if (!resource.isLiquid()) { displayRecipes.add(new CustomItem(resource.getItem(), "&r" + resource.getName())); } @@ -174,7 +175,7 @@ public abstract class GEOMiner extends AContainer implements InventoryBlock, Rec else { Chunk chunk = b.getChunk(); - for (OreGenResource resource: OreGenSystem.listResources()) { + for (OreGenResource resource : OreGenSystem.listResources()) { if (!resource.isLiquid()) { if (!OreGenSystem.wasResourceGenerated(resource, chunk)) { SimpleHologram.update(b, "&4GEO-Scan required!"); @@ -182,6 +183,7 @@ public abstract class GEOMiner extends AContainer implements InventoryBlock, Rec } else { int supplies = OreGenSystem.getSupplies(resource, chunk, false); + if (supplies > 0) { MachineRecipe r = new MachineRecipe(getProcessingTime() / getSpeed(), new ItemStack[0], new ItemStack[] {resource.getItem().clone()}); if (!menu.fits(r.getOutput()[0], getOutputSlots())) return; diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElevatorPlate.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/gps/ElevatorPlate.java similarity index 99% rename from src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElevatorPlate.java rename to src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/gps/ElevatorPlate.java index 9db54096e..e290ca4c7 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/ElevatorPlate.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/machines/electric/gps/ElevatorPlate.java @@ -1,4 +1,4 @@ -package me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric; +package me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.gps; import org.bukkit.block.Block; import org.bukkit.entity.Player; @@ -44,6 +44,7 @@ public class ElevatorPlate extends SimpleSlimefunItem { public ItemInteractionHandler getItemHandler() { return (e, p, item) -> { if (e.getClickedBlock() == null) return false; + String id = BlockStorage.checkID(e.getClickedBlock()); if (id == null || !id.equals(getID())) return false; 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 cf43a72ec..a66e3506d 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 @@ -52,8 +52,10 @@ public class ArmorForge extends MultiBlockMachine { if (craft) { final ItemStack adding = RecipeType.getRecipeOutputList(this, inputs.get(i)).clone(); + if (Slimefun.hasUnlocked(p, adding, true)) { Inventory outputInv = findOutputInventory(adding, dispBlock, inv); + if (outputInv != null) { for (int j = 0; j < 9; j++) { ItemStack item = inv.getContents()[j]; @@ -64,6 +66,7 @@ public class ArmorForge extends MultiBlockMachine { for (int j = 0; j < 4; j++) { int current = j; + Bukkit.getScheduler().runTaskLater(SlimefunPlugin.instance, () -> { if (current < 3) { p.getWorld().playSound(p.getLocation(), Sound.BLOCK_ANVIL_USE, 1F, 2F); 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 63294b1c5..8341f43e6 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 @@ -46,15 +46,18 @@ public class Compressor extends MultiBlockMachine { Block dispBlock = b.getRelative(BlockFace.DOWN); Dispenser disp = (Dispenser) dispBlock.getState(); Inventory inv = disp.getInventory(); - for (ItemStack current: inv.getContents()) { - for (ItemStack convert: RecipeType.getRecipeInputs(this)) { + + for (ItemStack current : inv.getContents()) { + for (ItemStack convert : RecipeType.getRecipeInputs(this)) { if (convert != null && SlimefunManager.isItemSimilar(current, convert, true)) { final ItemStack adding = RecipeType.getRecipeOutput(this, convert); Inventory outputInv = findOutputInventory(adding, dispBlock, inv); + if (outputInv != null) { ItemStack removing = current.clone(); removing.setAmount(convert.getAmount()); inv.removeItem(removing); + for (int i = 0; i < 4; i++) { int j = i; @@ -66,7 +69,7 @@ public class Compressor extends MultiBlockMachine { p.getWorld().playSound(p.getLocation(), Sound.ENTITY_ARROW_HIT_PLAYER, 1F, 1F); outputInv.addItem(adding); } - }, i*20L); + }, i * 20L); } } else SlimefunPlugin.getLocal().sendMessage(p, "machines.full-inventory", true); 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 13bac965e..75a4eceba 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 @@ -54,6 +54,7 @@ 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.isItemSimilar(inv.getContents()[j], inputs.get(i)[j], true)) { if (SlimefunItem.getByItem(inputs.get(i)[j]) instanceof SlimefunBackpack) { @@ -92,11 +93,12 @@ public class EnhancedCraftingTable extends MultiBlockMachine { break; } } + String id = ""; int size = ((SlimefunBackpack) sfItem).getSize(); if (backpack != null) { - for (String line: backpack.getItemMeta().getLore()) { + for (String line : backpack.getItemMeta().getLore()) { if (line.startsWith(ChatColor.translateAlternateColorCodes('&', "&7ID: ")) && line.contains("#")) { id = line.replace(ChatColor.translateAlternateColorCodes('&', "&7ID: "), ""); PlayerProfile.fromUUID(UUID.fromString(id.split("#")[0])).getBackpack(Integer.parseInt(id.split("#")[1])).setSize(size); @@ -131,6 +133,7 @@ public class EnhancedCraftingTable extends MultiBlockMachine { for (int j = 0; j < 9; j++) { ItemStack item = inv.getContents()[j]; + if (item != null && item.getType() != Material.AIR) { ItemUtils.consumeItem(item, true); } 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 274076b2a..2706f9cf1 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 @@ -43,8 +43,9 @@ public class Juicer extends MultiBlockMachine { Block dispBlock = b.getRelative(BlockFace.DOWN); Dispenser disp = (Dispenser) dispBlock.getState(); Inventory inv = disp.getInventory(); - for (ItemStack current: inv.getContents()) { - for (ItemStack convert: RecipeType.getRecipeInputs(this)) { + + for (ItemStack current : inv.getContents()) { + for (ItemStack convert : RecipeType.getRecipeInputs(this)) { 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 e6dbc03fb..f9e573b03 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 @@ -52,11 +52,12 @@ public class MagicWorkbench extends MultiBlockMachine { else if (b.getRelative(0, 0, -1).getType() == Material.DISPENSER) dispBlock = b.getRelative(0, 0, -1); Dispenser disp = (Dispenser) dispBlock.getState(); - final Inventory inv = disp.getInventory(); + Inventory inv = disp.getInventory(); List inputs = RecipeType.getRecipeInputList(this); for (int i = 0; i < inputs.size(); i++) { boolean craft = true; + for (int j = 0; j < inv.getContents().length; j++) { if (!SlimefunManager.isItemSimilar(inv.getContents()[j], inputs.get(i)[j], true)) { if (SlimefunItem.getByItem(inputs.get(i)[j]) instanceof SlimefunBackpack) { @@ -73,7 +74,8 @@ public class MagicWorkbench extends MultiBlockMachine { } if (craft) { - final ItemStack adding = RecipeType.getRecipeOutputList(this, inputs.get(i)).clone(); + ItemStack adding = RecipeType.getRecipeOutputList(this, inputs.get(i)).clone(); + if (Slimefun.hasUnlocked(p, adding, true)) { Inventory inv2 = Bukkit.createInventory(null, 9, "test"); @@ -99,7 +101,7 @@ public class MagicWorkbench extends MultiBlockMachine { int size = ((SlimefunBackpack) sfItem).getSize(); if (backpack != null) { - for (String line: backpack.getItemMeta().getLore()) { + for (String line : backpack.getItemMeta().getLore()) { if (line.startsWith(ChatColor.translateAlternateColorCodes('&', "&7ID: ")) && line.contains("#")) { id = line.replace(ChatColor.translateAlternateColorCodes('&', "&7ID: "), ""); PlayerProfile.fromUUID(UUID.fromString(id.split("#")[0])).getBackpack(Integer.parseInt(id.split("#")[1])).setSize(size); @@ -137,14 +139,17 @@ public class MagicWorkbench extends MultiBlockMachine { else inv.setItem(j, null); } } + for (int j = 0; j < 4; j++) { int current = j; Bukkit.getScheduler().runTaskLater(SlimefunPlugin.instance, () -> { p.getWorld().playEffect(b.getLocation(), Effect.MOBSPAWNER_FLAMES, 1); p.getWorld().playEffect(b.getLocation(), Effect.ENDER_SIGNAL, 1); + if (current < 3) { p.getWorld().playSound(b.getLocation(), Sound.BLOCK_WOODEN_BUTTON_CLICK_ON, 1F, 1F); - } else { + } + else { p.getWorld().playSound(p.getLocation(), Sound.ENTITY_ARROW_HIT_PLAYER, 1F, 1F); outputInv.addItem(adding); } 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 911713838..5f715e9d8 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 @@ -59,8 +59,9 @@ public class OreCrusher extends MultiBlockMachine { Block dispBlock = b.getRelative(BlockFace.DOWN); Dispenser disp = (Dispenser) dispBlock.getState(); Inventory inv = disp.getInventory(); - for (ItemStack current: inv.getContents()) { - for (ItemStack convert: RecipeType.getRecipeInputs(this)) { + + for (ItemStack current : inv.getContents()) { + for (ItemStack convert : RecipeType.getRecipeInputs(this)) { 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/TableSaw.java b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/TableSaw.java index 6240228b2..a9b401e86 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/TableSaw.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunItem/multiblocks/TableSaw.java @@ -33,7 +33,7 @@ public class TableSaw extends MultiBlockMachine { BlockFace.SELF ); - for (Material log: Tag.LOGS.getValues()) { + for (Material log : Tag.LOGS.getValues()) { Optional planks = MaterialConverter.getPlanksFromLog(log); if (planks.isPresent()) { diff --git a/src/main/java/me/mrCookieSlime/Slimefun/Setup/SlimefunSetup.java b/src/main/java/me/mrCookieSlime/Slimefun/Setup/SlimefunSetup.java index 64f2ec24d..aa5bd297e 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/Setup/SlimefunSetup.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/Setup/SlimefunSetup.java @@ -132,7 +132,6 @@ import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.Electric 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; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.EnergyRegulator; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.FluidPump; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.FoodComposter; @@ -151,6 +150,7 @@ import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.geo.GEOM import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.geo.GEOScannerBlock; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.geo.NetherDrill; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.geo.OilPump; +import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.gps.ElevatorPlate; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.machines.electric.gps.GPSTransmitter; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.multiblocks.ArmorForge; import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.multiblocks.AutomatedPanningMachine; diff --git a/src/main/java/me/mrCookieSlime/Slimefun/api/BlockInfoConfig.java b/src/main/java/me/mrCookieSlime/Slimefun/api/BlockInfoConfig.java index d0251dc5a..06176b74d 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/api/BlockInfoConfig.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/api/BlockInfoConfig.java @@ -142,4 +142,4 @@ public class BlockInfoConfig extends Config { return new GsonBuilder().create().toJson(data); } -} +} \ No newline at end of file diff --git a/src/main/java/me/mrCookieSlime/Slimefun/api/BlockStorage.java b/src/main/java/me/mrCookieSlime/Slimefun/api/BlockStorage.java index e923dac80..f6e2c46e9 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/api/BlockStorage.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/api/BlockStorage.java @@ -96,7 +96,7 @@ public class BlockStorage { long totalBlocks = 0; try { - for (File file: f.listFiles()) { + for (File file : f.listFiles()) { if (file.getName().equals("null.sfb")) { Slimefun.getLogger().log(Level.WARNING, "Corrupted file detected!"); Slimefun.getLogger().log(Level.WARNING, "Slimefun will simply skip this File, but you"); @@ -110,7 +110,7 @@ public class BlockStorage { } FileConfiguration cfg = YamlConfiguration.loadConfiguration(file); - for (String key: cfg.getKeys(false)) { + for (String key : cfg.getKeys(false)) { Location l = deserializeLocation(key); String chunkString = locationToChunkString(l); try { @@ -158,9 +158,11 @@ public class BlockStorage { else f.mkdirs(); File chunks = new File(path_chunks + "chunks.sfc"); + if (chunks.exists()) { FileConfiguration cfg = YamlConfiguration.loadConfiguration(chunks); - for (String key: cfg.getKeys(false)) { + + for (String key : cfg.getKeys(false)) { try { if (world.getName().equals(key.split(";")[0])) { SlimefunPlugin.getUtilities().mapChunks.put(key, new BlockInfoConfig(parseJSON(cfg.getString(key)))); @@ -173,13 +175,14 @@ public class BlockStorage { SlimefunPlugin.getUtilities().worlds.put(world.getName(), this); - for (File file: new File("data-storage/Slimefun/stored-inventories").listFiles()) { + for (File file : new File("data-storage/Slimefun/stored-inventories").listFiles()) { if (file.getName().startsWith(w.getName()) && file.getName().endsWith(".sfi")) { Location l = deserializeLocation(file.getName().replace(".sfi", "")); Config cfg = new Config(file); try { BlockMenuPreset preset = BlockMenuPreset.getPreset(cfg.getString("preset")); + if (preset == null) { preset = BlockMenuPreset.getPreset(checkID(l)); } @@ -194,7 +197,7 @@ public class BlockStorage { } } - for (File file: new File("data-storage/Slimefun/universal-inventories").listFiles()) { + for (File file : new File("data-storage/Slimefun/universal-inventories").listFiles()) { if (file.getName().endsWith(".sfi")) { Config cfg = new Config(file); BlockMenuPreset preset = BlockMenuPreset.getPreset(cfg.getString("preset")); @@ -213,12 +216,12 @@ public class BlockStorage { changes = blocksCache.size() + chunkChanges; Map inventories2 = new HashMap<>(inventories); - for (Map.Entry entry: inventories2.entrySet()) { + for (Map.Entry entry : inventories2.entrySet()) { changes += entry.getValue().getUnsavedChanges(); } Map universalInventories2 = new HashMap<>(SlimefunPlugin.getUtilities().universalInventories); - for (Map.Entry entry: universalInventories2.entrySet()) { + for (Map.Entry entry : universalInventories2.entrySet()) { changes += entry.getValue().getUnsavedChanges(); } } @@ -239,7 +242,7 @@ public class BlockStorage { Map cache = new HashMap<>(blocksCache); - for (Map.Entry entry: cache.entrySet()) { + for (Map.Entry entry : cache.entrySet()) { blocksCache.remove(entry.getKey()); Config cfg = entry.getValue(); @@ -263,13 +266,13 @@ public class BlockStorage { Map inventories2 = new HashMap<>(inventories); - for (Map.Entry entry: inventories2.entrySet()) { + for (Map.Entry entry : inventories2.entrySet()) { entry.getValue().save(entry.getKey()); } Map universalInventories2 = new HashMap<>(SlimefunPlugin.getUtilities().universalInventories); - for (Map.Entry entry: universalInventories2.entrySet()) { + for (Map.Entry entry : universalInventories2.entrySet()) { entry.getValue().save(); } @@ -277,7 +280,7 @@ public class BlockStorage { File chunks = new File(path_chunks + "chunks.sfc"); Config cfg = new Config(path_chunks + "chunks.temp"); - for (Map.Entry entry: SlimefunPlugin.getUtilities().mapChunks.entrySet()) { + for (Map.Entry entry : SlimefunPlugin.getUtilities().mapChunks.entrySet()) { cfg.setValue(entry.getKey(), entry.getValue().toJSON()); } @@ -342,7 +345,8 @@ public class BlockStorage { if (json != null && json.length() > 2) { JsonParser parser = new JsonParser(); JsonObject obj = parser.parse(json).getAsJsonObject(); - for (Map.Entry entry: obj.entrySet()) { + + for (Map.Entry entry : obj.entrySet()) { map.put(entry.getKey(), entry.getValue().getAsString()); } } @@ -367,9 +371,11 @@ public class BlockStorage { private static String serializeBlockInfo(Config cfg) { JsonObject json = new JsonObject(); + for (String key : cfg.getKeys()) { json.add(key, new JsonPrimitive(cfg.getString(key))); } + return json.toString(); } @@ -426,6 +432,7 @@ public class BlockStorage { public static void setBlockInfo(Location l, Config cfg, boolean updateTicker) { BlockStorage storage = getStorage(l.getWorld()); storage.storage.put(l, cfg); + if (BlockMenuPreset.isInventory(cfg.getString("id"))) { if (BlockMenuPreset.isUniversalInventory(cfg.getString("id"))) { if (!SlimefunPlugin.getUtilities().universalInventories.containsKey(cfg.getString("id"))) { @@ -439,6 +446,7 @@ public class BlockStorage { else storage.loadInventory(l, BlockMenuPreset.getPreset(cfg.getString("id"))); } } + refreshCache(getStorage(l.getWorld()), l, cfg.getString("id"), serializeBlockInfo(cfg), updateTicker); } @@ -470,6 +478,7 @@ public class BlockStorage { public static void _integrated_removeBlockInfo(Location l, boolean destroy) { BlockStorage storage = getStorage(l.getWorld()); + if (hasBlockInfo(l)) { refreshCache(storage, l, getLocationInfo(l).getString("id"), null, destroy); storage.storage.remove(l); @@ -477,14 +486,17 @@ public class BlockStorage { if (destroy) { if (storage.hasInventory(l)) storage.clearInventory(l); + if (storage.hasUniversalInventory(l)) { storage.getUniversalInventory(l).close(); storage.getUniversalInventory(l).save(); } + String chunkString = locationToChunkString(l); if (SlimefunPlugin.getUtilities().tickingChunks.containsKey(chunkString)) { Set locations = SlimefunPlugin.getUtilities().tickingChunks.get(chunkString); locations.remove(l); + if (locations.isEmpty()) { SlimefunPlugin.getUtilities().tickingChunks.remove(chunkString); SlimefunPlugin.getUtilities().loadedTickers.remove(chunkString); @@ -513,6 +525,7 @@ public class BlockStorage { BlockStorage storage = getStorage(from.getWorld()); setBlockInfo(to, getLocationInfo(from), true); + if (storage.inventories.containsKey(from)) { BlockMenu menu = storage.inventories.get(from); storage.inventories.put(to, menu); @@ -524,9 +537,11 @@ public class BlockStorage { storage.storage.remove(from); String chunkString = locationToChunkString(from); + if (SlimefunPlugin.getUtilities().tickingChunks.containsKey(chunkString)) { Set locations = SlimefunPlugin.getUtilities().tickingChunks.get(chunkString); locations.remove(from); + if (locations.isEmpty()) { SlimefunPlugin.getUtilities().tickingChunks.remove(chunkString); SlimefunPlugin.getUtilities().loadedTickers.remove(chunkString); @@ -541,8 +556,10 @@ public class BlockStorage { if (updateTicker) { SlimefunItem item = SlimefunItem.getByID(key); + if (item != null && item.isTicking()) { String chunkString = locationToChunkString(l); + if (value != null) { Set locations = SlimefunPlugin.getUtilities().tickingChunks.get(chunkString); if (locations == null) locations = new HashSet<>(); @@ -615,9 +632,11 @@ public class BlockStorage { @Deprecated public static Set getTickingBlocks(String chunk) { Set ret = new HashSet<>(); - for (Location l: getTickingLocations(chunk)) { + + for (Location l : getTickingLocations(chunk)) { ret.add(l.getBlock()); } + return ret; } diff --git a/src/main/java/me/mrCookieSlime/Slimefun/api/GuideHandler.java b/src/main/java/me/mrCookieSlime/Slimefun/api/GuideHandler.java index 0ca3fc145..6f9750946 100644 --- a/src/main/java/me/mrCookieSlime/Slimefun/api/GuideHandler.java +++ b/src/main/java/me/mrCookieSlime/Slimefun/api/GuideHandler.java @@ -7,6 +7,7 @@ import org.bukkit.entity.Player; import me.mrCookieSlime.CSCoreLibPlugin.PlayerRunnable; import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.ChestMenu; +@Deprecated public interface GuideHandler { public abstract void addEntry(List texts, List tooltips);