mirror of
https://github.com/StarWishsama/Slimefun4.git
synced 2024-09-19 19:25:48 +00:00
commit
5d5decbf45
@ -47,6 +47,7 @@
|
||||
|
||||
#### Changes
|
||||
* Tree Growth Accelerators can now actually cause the Tree to fully grow (1.17+ only)
|
||||
* Slimefun now requires Java 16
|
||||
|
||||
#### Fixes
|
||||
* Fixed #3597
|
||||
|
@ -31,6 +31,7 @@ Here is a full summary of the differences between the two different versions of
|
||||
| | development (latest) | "stable" |
|
||||
| ------------------ | -------- | -------- |
|
||||
| **Minecraft version(s)** | :video_game: **1.14.\* - 1.19.\*** | :video_game: **1.14.\* - 1.19.\*** |
|
||||
| **Java version** | :computer: **Java 16 (or higher)** | :computer: **Java 8 (or higher)** |
|
||||
| **automatic updates** | :heavy_check_mark: | :heavy_check_mark: |
|
||||
| **frequent updates** | :heavy_check_mark: | :x: |
|
||||
| **latest content** | :heavy_check_mark: | :x: |
|
||||
|
6
pom.xml
6
pom.xml
@ -21,9 +21,9 @@
|
||||
<!-- UTF-8 is our standard encoding for source files -->
|
||||
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
|
||||
|
||||
<!-- Target Java 8 -->
|
||||
<maven.compiler.source>1.8</maven.compiler.source>
|
||||
<maven.compiler.target>1.8</maven.compiler.target>
|
||||
<!-- Target Java 16 -->
|
||||
<maven.compiler.source>16</maven.compiler.source>
|
||||
<maven.compiler.target>16</maven.compiler.target>
|
||||
|
||||
<!-- Spigot properties -->
|
||||
<spigot.version>1.19</spigot.version>
|
||||
|
@ -111,8 +111,8 @@ public class GPSNetwork {
|
||||
for (Location l : locations) {
|
||||
SlimefunItem item = BlockStorage.check(l);
|
||||
|
||||
if (item instanceof GPSTransmitter) {
|
||||
level += ((GPSTransmitter) item).getMultiplier(Math.max(l.getBlockY(), 0));
|
||||
if (item instanceof GPSTransmitter transmitter) {
|
||||
level += transmitter.getMultiplier(Math.max(l.getBlockY(), 0));
|
||||
}
|
||||
}
|
||||
|
||||
@ -172,10 +172,10 @@ public class GPSNetwork {
|
||||
|
||||
SlimefunItem sfi = BlockStorage.check(l);
|
||||
|
||||
if (sfi instanceof GPSTransmitter) {
|
||||
if (sfi instanceof GPSTransmitter transmitter) {
|
||||
int slot = inventory[index];
|
||||
|
||||
menu.addItem(slot, new CustomItemStack(SlimefunItems.GPS_TRANSMITTER, "&bGPS Transmitter", "&8\u21E8 &7World: &f" + l.getWorld().getName(), "&8\u21E8 &7X: &f" + l.getX(), "&8\u21E8 &7Y: &f" + l.getY(), "&8\u21E8 &7Z: &f" + l.getZ(), "", "&8\u21E8 &7Signal Strength: &f" + ((GPSTransmitter) sfi).getMultiplier(l.getBlockY()), "&8\u21E8 &7Ping: &f" + NumberUtils.roundDecimalNumber(1000D / l.getY()) + "ms"));
|
||||
menu.addItem(slot, new CustomItemStack(SlimefunItems.GPS_TRANSMITTER, "&bGPS Transmitter", "&8\u21E8 &7World: &f" + l.getWorld().getName(), "&8\u21E8 &7X: &f" + l.getX(), "&8\u21E8 &7Y: &f" + l.getY(), "&8\u21E8 &7Z: &f" + l.getZ(), "", "&8\u21E8 &7Signal Strength: &f" + transmitter.getMultiplier(l.getBlockY()), "&8\u21E8 &7Ping: &f" + NumberUtils.roundDecimalNumber(1000D / l.getY()) + "ms"));
|
||||
menu.addMenuClickHandler(slot, ChestMenuUtils.getEmptyClickHandler());
|
||||
|
||||
index++;
|
||||
|
@ -61,8 +61,8 @@ public final class HashedArmorpiece {
|
||||
this.hash = copy.hashCode();
|
||||
}
|
||||
|
||||
if (item instanceof SlimefunArmorPiece) {
|
||||
this.item = Optional.of((SlimefunArmorPiece) item);
|
||||
if (item instanceof SlimefunArmorPiece armorPiece) {
|
||||
this.item = Optional.of(armorPiece);
|
||||
} else {
|
||||
this.item = Optional.empty();
|
||||
}
|
||||
|
@ -351,8 +351,8 @@ public class ItemGroup implements Keyed {
|
||||
|
||||
@Override
|
||||
public final boolean equals(Object obj) {
|
||||
if (obj instanceof ItemGroup) {
|
||||
return ((ItemGroup) obj).getKey().equals(getKey());
|
||||
if (obj instanceof ItemGroup group) {
|
||||
return group.getKey().equals(this.getKey());
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
|
@ -482,8 +482,8 @@ public class SlimefunItem implements Placeable {
|
||||
}
|
||||
|
||||
// Lock the SlimefunItemStack from any accidental manipulations
|
||||
if (itemStackTemplate instanceof SlimefunItemStack && isItemStackImmutable()) {
|
||||
((SlimefunItemStack) itemStackTemplate).lock();
|
||||
if (itemStackTemplate instanceof SlimefunItemStack stack && isItemStackImmutable()) {
|
||||
stack.lock();
|
||||
}
|
||||
|
||||
postRegister();
|
||||
@ -755,8 +755,8 @@ public class SlimefunItem implements Placeable {
|
||||
}
|
||||
|
||||
// If the given item is a SlimefunitemStack, simply compare the id
|
||||
if (item instanceof SlimefunItemStack) {
|
||||
return getId().equals(((SlimefunItemStack) item).getItemId());
|
||||
if (item instanceof SlimefunItemStack stack) {
|
||||
return getId().equals(stack.getItemId());
|
||||
}
|
||||
|
||||
if (item.hasItemMeta()) {
|
||||
@ -807,10 +807,10 @@ public class SlimefunItem implements Placeable {
|
||||
itemhandlers.put(handler.getIdentifier(), handler);
|
||||
|
||||
// Tickers are a special case (at the moment at least)
|
||||
if (handler instanceof BlockTicker) {
|
||||
if (handler instanceof BlockTicker ticker) {
|
||||
ticking = true;
|
||||
Slimefun.getRegistry().getTickerBlocks().add(getId());
|
||||
blockTicker = (BlockTicker) handler;
|
||||
blockTicker = ticker;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1036,8 +1036,8 @@ public class SlimefunItem implements Placeable {
|
||||
addon.getLogger().log(Level.SEVERE, message, throwable);
|
||||
|
||||
// We definitely want to re-throw them during Unit Tests
|
||||
if (throwable instanceof RuntimeException && Slimefun.getMinecraftVersion() == MinecraftVersion.UNIT_TEST) {
|
||||
throw (RuntimeException) throwable;
|
||||
if (throwable instanceof RuntimeException e && Slimefun.getMinecraftVersion() == MinecraftVersion.UNIT_TEST) {
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
|
||||
@ -1138,8 +1138,8 @@ public class SlimefunItem implements Placeable {
|
||||
|
||||
@Override
|
||||
public final boolean equals(Object obj) {
|
||||
if (obj instanceof SlimefunItem) {
|
||||
return ((SlimefunItem) obj).getId().equals(getId());
|
||||
if (obj instanceof SlimefunItem item) {
|
||||
return item.getId().equals(this.getId());
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
@ -1173,8 +1173,8 @@ public class SlimefunItem implements Placeable {
|
||||
return null;
|
||||
}
|
||||
|
||||
if (item instanceof SlimefunItemStack) {
|
||||
return getById(((SlimefunItemStack) item).getItemId());
|
||||
if (item instanceof SlimefunItemStack stack) {
|
||||
return getById(stack.getItemId());
|
||||
}
|
||||
|
||||
Optional<String> itemID = Slimefun.getItemDataService().getItemData(item);
|
||||
|
@ -128,12 +128,12 @@ public class SlimefunItemStack extends ItemStack {
|
||||
im.setLore(lines);
|
||||
}
|
||||
|
||||
if (im instanceof LeatherArmorMeta) {
|
||||
((LeatherArmorMeta) im).setColor(color);
|
||||
if (im instanceof LeatherArmorMeta leatherArmorMeta) {
|
||||
leatherArmorMeta.setColor(color);
|
||||
}
|
||||
|
||||
if (im instanceof PotionMeta) {
|
||||
((PotionMeta) im).setColor(color);
|
||||
if (im instanceof PotionMeta potionMeta) {
|
||||
potionMeta.setColor(color);
|
||||
}
|
||||
});
|
||||
}
|
||||
@ -154,9 +154,9 @@ public class SlimefunItemStack extends ItemStack {
|
||||
im.setLore(lines);
|
||||
}
|
||||
|
||||
if (im instanceof PotionMeta) {
|
||||
((PotionMeta) im).setColor(color);
|
||||
((PotionMeta) im).addCustomEffect(effect, true);
|
||||
if (im instanceof PotionMeta potionMeta) {
|
||||
potionMeta.setColor(color);
|
||||
potionMeta.addCustomEffect(effect, true);
|
||||
|
||||
if (effect.getType().equals(PotionEffectType.SATURATION)) {
|
||||
im.addItemFlags(ItemFlag.HIDE_POTION_EFFECTS);
|
||||
|
@ -40,14 +40,12 @@ public class MaterialTagSetting extends ItemSetting<List<String>> {
|
||||
*
|
||||
* @return The default {@link Tag}
|
||||
*/
|
||||
@Nonnull
|
||||
public Tag<Material> getDefaultTag() {
|
||||
public @Nonnull Tag<Material> getDefaultTag() {
|
||||
return defaultTag;
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
@Override
|
||||
protected String getErrorMessage() {
|
||||
protected @Nonnull String getErrorMessage() {
|
||||
return "This List can only contain Materials in the format of e.g. REDSTONE_BLOCK";
|
||||
}
|
||||
|
||||
@ -74,10 +72,10 @@ public class MaterialTagSetting extends ItemSetting<List<String>> {
|
||||
*
|
||||
* @param tag
|
||||
* Our {@link Tag}
|
||||
*
|
||||
* @return The {@link String} {@link List}
|
||||
*/
|
||||
@Nonnull
|
||||
private static List<String> getAsStringList(@Nonnull Tag<Material> tag) {
|
||||
private static @Nonnull List<String> getAsStringList(@Nonnull Tag<Material> tag) {
|
||||
return tag.getValues().stream().map(Material::name).collect(Collectors.toList());
|
||||
}
|
||||
|
||||
|
@ -487,9 +487,7 @@ public class PlayerProfile {
|
||||
|
||||
if (!armorPiece.isPresent()) {
|
||||
setId = null;
|
||||
} else if (armorPiece.get() instanceof ProtectiveArmor) {
|
||||
ProtectiveArmor protectedArmor = (ProtectiveArmor) armorPiece.get();
|
||||
|
||||
} else if (armorPiece.get() instanceof ProtectiveArmor protectedArmor) {
|
||||
if (setId == null && protectedArmor.isFullSetRequired()) {
|
||||
setId = protectedArmor.getArmorSetId();
|
||||
}
|
||||
@ -517,7 +515,7 @@ public class PlayerProfile {
|
||||
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
return obj instanceof PlayerProfile && uuid.equals(((PlayerProfile) obj).uuid);
|
||||
return obj instanceof PlayerProfile profile && uuid.equals(profile.uuid);
|
||||
}
|
||||
|
||||
@Override
|
||||
|
@ -99,8 +99,8 @@ public class RecipeType implements Keyed {
|
||||
this.key = key;
|
||||
this.consumer = callback;
|
||||
|
||||
if (item instanceof SlimefunItemStack) {
|
||||
this.machine = ((SlimefunItemStack) item).getItemId();
|
||||
if (item instanceof SlimefunItemStack slimefunItemStack) {
|
||||
this.machine = slimefunItemStack.getItemId();
|
||||
} else {
|
||||
this.machine = "";
|
||||
}
|
||||
@ -109,7 +109,7 @@ public class RecipeType implements Keyed {
|
||||
public RecipeType(NamespacedKey key, ItemStack item) {
|
||||
this.key = key;
|
||||
this.item = item;
|
||||
this.machine = item instanceof SlimefunItemStack ? ((SlimefunItemStack) item).getItemId() : "";
|
||||
this.machine = item instanceof SlimefunItemStack slimefunItemStack ? slimefunItemStack.getItemId() : "";
|
||||
}
|
||||
|
||||
public RecipeType(MinecraftRecipe<?> recipe) {
|
||||
@ -124,8 +124,8 @@ public class RecipeType implements Keyed {
|
||||
} else {
|
||||
SlimefunItem slimefunItem = SlimefunItem.getById(this.machine);
|
||||
|
||||
if (slimefunItem instanceof MultiBlockMachine) {
|
||||
((MultiBlockMachine) slimefunItem).addRecipe(recipe, result);
|
||||
if (slimefunItem instanceof MultiBlockMachine mbm) {
|
||||
mbm.addRecipe(recipe, result);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -149,8 +149,8 @@ public class RecipeType implements Keyed {
|
||||
|
||||
@Override
|
||||
public final boolean equals(Object obj) {
|
||||
if (obj instanceof RecipeType) {
|
||||
return ((RecipeType) obj).getKey().equals(this.getKey());
|
||||
if (obj instanceof RecipeType recipeType) {
|
||||
return recipeType.getKey().equals(this.getKey());
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
|
@ -80,10 +80,9 @@ public abstract class SubCommand {
|
||||
*
|
||||
* @return A possibly localized description of this {@link SubCommand}
|
||||
*/
|
||||
@Nonnull
|
||||
public String getDescription(@Nonnull CommandSender sender) {
|
||||
if (sender instanceof Player) {
|
||||
return Slimefun.getLocalization().getMessage((Player) sender, getDescription());
|
||||
public @Nonnull String getDescription(@Nonnull CommandSender sender) {
|
||||
if (sender instanceof Player player) {
|
||||
return Slimefun.getLocalization().getMessage(player, getDescription());
|
||||
} else {
|
||||
return Slimefun.getLocalization().getMessage(getDescription());
|
||||
}
|
||||
|
@ -40,7 +40,7 @@ class BackpackCommand extends SubCommand {
|
||||
|
||||
@Override
|
||||
public void onExecute(CommandSender sender, String[] args) {
|
||||
if (sender instanceof Player) {
|
||||
if (sender instanceof Player player) {
|
||||
if (sender.hasPermission("slimefun.command.backpack")) {
|
||||
if (args.length != 3) {
|
||||
Slimefun.getLocalization().sendMessage(sender, "messages.usage", true, msg -> msg.replace("%usage%", "/sf backpack <Player> <ID>"));
|
||||
@ -71,7 +71,7 @@ class BackpackCommand extends SubCommand {
|
||||
Slimefun.runSync(() -> {
|
||||
ItemStack item = SlimefunItems.RESTORED_BACKPACK.clone();
|
||||
Slimefun.getBackpackListener().setBackpackId(backpackOwner, item, 2, id);
|
||||
((Player) sender).getInventory().addItem(item);
|
||||
player.getInventory().addItem(item);
|
||||
Slimefun.getLocalization().sendMessage(sender, "commands.backpack.restored-backpack-given");
|
||||
});
|
||||
});
|
||||
|
@ -33,14 +33,12 @@ class ChargeCommand extends SubCommand {
|
||||
|
||||
@Override
|
||||
public void onExecute(CommandSender sender, String[] args) {
|
||||
if (sender instanceof Player) {
|
||||
if (sender instanceof Player player) {
|
||||
if (sender.hasPermission("slimefun.command.charge")) {
|
||||
Player p = (Player) sender;
|
||||
ItemStack item = p.getInventory().getItemInMainHand();
|
||||
ItemStack item = player.getInventory().getItemInMainHand();
|
||||
SlimefunItem slimefunItem = SlimefunItem.getByItem(item);
|
||||
|
||||
if (slimefunItem instanceof Rechargeable) {
|
||||
Rechargeable rechargeableItem = (Rechargeable) slimefunItem;
|
||||
if (slimefunItem instanceof Rechargeable rechargeableItem) {
|
||||
rechargeableItem.setItemCharge(item, rechargeableItem.getMaxItemCharge(item));
|
||||
Slimefun.getLocalization().sendMessage(sender, "commands.charge.charge-success", true);
|
||||
} else {
|
||||
|
@ -19,9 +19,9 @@ class CheatCommand extends SubCommand {
|
||||
|
||||
@Override
|
||||
public void onExecute(CommandSender sender, String[] args) {
|
||||
if (sender instanceof Player) {
|
||||
if (sender instanceof Player player) {
|
||||
if (sender.hasPermission("slimefun.cheat.items")) {
|
||||
SlimefunGuide.openCheatMenu((Player) sender);
|
||||
SlimefunGuide.openCheatMenu(player);
|
||||
} else {
|
||||
Slimefun.getLocalization().sendMessage(sender, "messages.no-permission", true);
|
||||
}
|
||||
|
@ -19,8 +19,8 @@ class DebugFishCommand extends SubCommand {
|
||||
|
||||
@Override
|
||||
public void onExecute(CommandSender sender, String[] args) {
|
||||
if (sender instanceof Player && sender.hasPermission("slimefun.debugging")) {
|
||||
((Player) sender).getInventory().addItem(SlimefunItems.DEBUG_FISH.clone());
|
||||
if (sender instanceof Player player && sender.hasPermission("slimefun.debugging")) {
|
||||
player.getInventory().addItem(SlimefunItems.DEBUG_FISH.clone());
|
||||
} else {
|
||||
Slimefun.getLocalization().sendMessage(sender, "messages.no-permission", true);
|
||||
}
|
||||
|
@ -20,10 +20,10 @@ class GuideCommand extends SubCommand {
|
||||
|
||||
@Override
|
||||
public void onExecute(CommandSender sender, String[] args) {
|
||||
if (sender instanceof Player) {
|
||||
if (sender instanceof Player player) {
|
||||
if (sender.hasPermission("slimefun.command.guide")) {
|
||||
SlimefunGuideMode design = SlimefunGuide.getDefaultMode();
|
||||
((Player) sender).getInventory().addItem(SlimefunGuide.getItem(design).clone());
|
||||
player.getInventory().addItem(SlimefunGuide.getItem(design).clone());
|
||||
} else {
|
||||
Slimefun.getLocalization().sendMessage(sender, "messages.no-permission", true);
|
||||
}
|
||||
|
@ -21,9 +21,9 @@ class OpenGuideCommand extends SubCommand {
|
||||
@Override
|
||||
@ParametersAreNonnullByDefault
|
||||
public void onExecute(CommandSender sender, String[] args) {
|
||||
if (sender instanceof Player) {
|
||||
if (sender instanceof Player player) {
|
||||
if (sender.hasPermission("slimefun.command.open_guide")) {
|
||||
SlimefunGuide.openGuide((Player) sender, SlimefunGuideMode.SURVIVAL_MODE);
|
||||
SlimefunGuide.openGuide(player, SlimefunGuideMode.SURVIVAL_MODE);
|
||||
} else {
|
||||
Slimefun.getLocalization().sendMessage(sender, "messages.no-permission", true);
|
||||
}
|
||||
|
@ -23,11 +23,11 @@ class SearchCommand extends SubCommand {
|
||||
|
||||
@Override
|
||||
public void onExecute(CommandSender sender, String[] args) {
|
||||
if (sender instanceof Player) {
|
||||
if (sender instanceof Player player) {
|
||||
if (sender.hasPermission("slimefun.command.search")) {
|
||||
if (args.length > 1) {
|
||||
String query = String.join(" ", Arrays.copyOfRange(args, 1, args.length));
|
||||
PlayerProfile.get((Player) sender, profile -> SlimefunGuide.openSearch(profile, query, SlimefunGuideMode.SURVIVAL_MODE, true));
|
||||
PlayerProfile.get(player, profile -> SlimefunGuide.openSearch(profile, query, SlimefunGuideMode.SURVIVAL_MODE, true));
|
||||
} else {
|
||||
Slimefun.getLocalization().sendMessage(sender, "messages.usage", true, msg -> msg.replace("%usage%", "/sf search <SearchTerm>"));
|
||||
}
|
||||
|
@ -35,8 +35,8 @@ class StatsCommand extends SubCommand {
|
||||
} else {
|
||||
Slimefun.getLocalization().sendMessage(sender, "messages.no-permission", true);
|
||||
}
|
||||
} else if (sender instanceof Player) {
|
||||
PlayerProfile.get((Player) sender, profile -> profile.sendStats(sender));
|
||||
} else if (sender instanceof Player player) {
|
||||
PlayerProfile.get(player, profile -> profile.sendStats(sender));
|
||||
} else {
|
||||
Slimefun.getLocalization().sendMessage(sender, "messages.only-players", true);
|
||||
}
|
||||
|
@ -21,18 +21,17 @@ class TeleporterCommand extends SubCommand {
|
||||
|
||||
@Override
|
||||
public void onExecute(CommandSender sender, String[] args) {
|
||||
if (sender instanceof Player) {
|
||||
if (sender instanceof Player player) {
|
||||
if (sender.hasPermission("slimefun.command.teleporter")) {
|
||||
if (args.length == 1) {
|
||||
Player p = (Player) sender;
|
||||
Slimefun.getGPSNetwork().getTeleportationManager().openTeleporterGUI(p, p.getUniqueId(), p.getLocation().getBlock().getRelative(BlockFace.DOWN), 999999999);
|
||||
Slimefun.getGPSNetwork().getTeleportationManager().openTeleporterGUI(player, player.getUniqueId(), player.getLocation().getBlock().getRelative(BlockFace.DOWN), 999999999);
|
||||
} else if (args.length == 2) {
|
||||
|
||||
@SuppressWarnings("deprecation")
|
||||
OfflinePlayer player = Bukkit.getOfflinePlayer(args[1]);
|
||||
OfflinePlayer targetPlayer = Bukkit.getOfflinePlayer(args[1]);
|
||||
|
||||
if (player.getName() != null) {
|
||||
Slimefun.getGPSNetwork().getTeleportationManager().openTeleporterGUI((Player) sender, player.getUniqueId(), ((Player) sender).getLocation().getBlock().getRelative(BlockFace.DOWN), 999999999);
|
||||
if (targetPlayer.getName() != null) {
|
||||
Slimefun.getGPSNetwork().getTeleportationManager().openTeleporterGUI(player, targetPlayer.getUniqueId(), player.getLocation().getBlock().getRelative(BlockFace.DOWN), 999999999);
|
||||
} else {
|
||||
Slimefun.getLocalization().sendMessage(sender, "messages.unknown-player", msg -> msg.replace("%player%", args[1]));
|
||||
}
|
||||
|
@ -88,8 +88,8 @@ class TimingsCommand extends SubCommand {
|
||||
|
||||
@Nonnull
|
||||
private PerformanceInspector inspectorOf(@Nonnull CommandSender sender, boolean verbose) {
|
||||
if (sender instanceof Player) {
|
||||
return new PlayerPerformanceInspector((Player) sender);
|
||||
if (sender instanceof Player player) {
|
||||
return new PlayerPerformanceInspector(player);
|
||||
} else {
|
||||
return new ConsolePerformanceInspector(sender, verbose);
|
||||
}
|
||||
|
@ -146,7 +146,7 @@ class VersionsCommand extends SubCommand {
|
||||
secondaryColor = ChatColor.DARK_GREEN;
|
||||
String authors = String.join(", ", plugin.getDescription().getAuthors());
|
||||
|
||||
if (plugin instanceof SlimefunAddon && ((SlimefunAddon) plugin).getBugTrackerURL() != null) {
|
||||
if (plugin instanceof SlimefunAddon addon && addon.getBugTrackerURL() != null) {
|
||||
// @formatter:off
|
||||
hoverEvent = new HoverEvent(HoverEvent.Action.SHOW_TEXT, new Text(new ComponentBuilder()
|
||||
.append("Author(s): ")
|
||||
@ -158,7 +158,7 @@ class VersionsCommand extends SubCommand {
|
||||
));
|
||||
// @formatter:on
|
||||
|
||||
clickEvent = new ClickEvent(ClickEvent.Action.OPEN_URL, ((SlimefunAddon) plugin).getBugTrackerURL());
|
||||
clickEvent = new ClickEvent(ClickEvent.Action.OPEN_URL, addon.getBugTrackerURL());
|
||||
} else {
|
||||
// @formatter:off
|
||||
hoverEvent = new HoverEvent(HoverEvent.Action.SHOW_TEXT, new Text(new ComponentBuilder()
|
||||
@ -173,7 +173,7 @@ class VersionsCommand extends SubCommand {
|
||||
primaryColor = ChatColor.RED;
|
||||
secondaryColor = ChatColor.DARK_RED;
|
||||
|
||||
if (plugin instanceof SlimefunAddon && ((SlimefunAddon) plugin).getBugTrackerURL() != null) {
|
||||
if (plugin instanceof SlimefunAddon addon && addon.getBugTrackerURL() != null) {
|
||||
// @formatter:off
|
||||
hoverEvent = new HoverEvent(HoverEvent.Action.SHOW_TEXT, new Text(new ComponentBuilder()
|
||||
.append("This plugin is disabled.\nCheck the console for an error message.")
|
||||
@ -184,8 +184,6 @@ class VersionsCommand extends SubCommand {
|
||||
));
|
||||
// @formatter:on
|
||||
|
||||
SlimefunAddon addon = (SlimefunAddon) plugin;
|
||||
|
||||
if (addon.getBugTrackerURL() != null) {
|
||||
clickEvent = new ClickEvent(ClickEvent.Action.OPEN_URL, addon.getBugTrackerURL());
|
||||
}
|
||||
|
@ -188,14 +188,14 @@ public class GuideHistory {
|
||||
private <T> void open(@Nonnull SlimefunGuideImplementation guide, @Nullable GuideEntry<T> entry) {
|
||||
if (entry == null) {
|
||||
guide.openMainMenu(profile, mainMenuPage);
|
||||
} else if (entry.getIndexedObject() instanceof ItemGroup) {
|
||||
guide.openItemGroup(profile, (ItemGroup) entry.getIndexedObject(), entry.getPage());
|
||||
} else if (entry.getIndexedObject() instanceof SlimefunItem) {
|
||||
guide.displayItem(profile, (SlimefunItem) entry.getIndexedObject(), false);
|
||||
} else if (entry.getIndexedObject() instanceof ItemStack) {
|
||||
guide.displayItem(profile, (ItemStack) entry.getIndexedObject(), entry.getPage(), false);
|
||||
} else if (entry.getIndexedObject() instanceof String) {
|
||||
guide.openSearch(profile, (String) entry.getIndexedObject(), false);
|
||||
} else if (entry.getIndexedObject() instanceof ItemGroup group) {
|
||||
guide.openItemGroup(profile, group, entry.getPage());
|
||||
} else if (entry.getIndexedObject() instanceof SlimefunItem item) {
|
||||
guide.displayItem(profile, item, false);
|
||||
} else if (entry.getIndexedObject() instanceof ItemStack stack) {
|
||||
guide.displayItem(profile, stack, entry.getPage(), false);
|
||||
} else if (entry.getIndexedObject() instanceof String query) {
|
||||
guide.openSearch(profile, query, false);
|
||||
} else {
|
||||
throw new IllegalStateException("Unknown GuideHistory entry: " + entry.getIndexedObject());
|
||||
}
|
||||
|
@ -76,10 +76,10 @@ public class RainbowTickHandler extends BlockTicker {
|
||||
}
|
||||
|
||||
for (Material type : materials) {
|
||||
/**
|
||||
* This BlockData is purely virtual and only created on startup, it should have
|
||||
* no impact on performance, in fact it should save performance as it preloads
|
||||
* the data but also saves heavy calls for other Materials
|
||||
/*
|
||||
This BlockData is purely virtual and only created on startup, it should have
|
||||
no impact on performance, in fact it should save performance as it preloads
|
||||
the data but also saves heavy calls for other Materials
|
||||
*/
|
||||
if (type.createBlockData() instanceof GlassPane) {
|
||||
return true;
|
||||
@ -92,9 +92,9 @@ public class RainbowTickHandler extends BlockTicker {
|
||||
@Override
|
||||
public void tick(Block b, SlimefunItem item, Config data) {
|
||||
if (b.getType() == Material.AIR) {
|
||||
/**
|
||||
* The block was broken, setting the Material now would result in a
|
||||
* duplication glitch
|
||||
/*
|
||||
The block was broken, setting the Material now would result in a
|
||||
duplication glitch
|
||||
*/
|
||||
return;
|
||||
}
|
||||
@ -102,12 +102,9 @@ public class RainbowTickHandler extends BlockTicker {
|
||||
if (glassPanes) {
|
||||
BlockData blockData = b.getBlockData();
|
||||
|
||||
if (blockData instanceof GlassPane) {
|
||||
if (blockData instanceof GlassPane previousData) {
|
||||
BlockData block = material.createBlockData(bd -> {
|
||||
if (bd instanceof GlassPane) {
|
||||
GlassPane previousData = (GlassPane) blockData;
|
||||
GlassPane nextData = (GlassPane) bd;
|
||||
|
||||
if (bd instanceof GlassPane nextData) {
|
||||
nextData.setWaterlogged(previousData.isWaterlogged());
|
||||
|
||||
for (BlockFace face : previousData.getAllowedFaces()) {
|
||||
|
@ -94,21 +94,14 @@ public class CargoNet extends AbstractItemNetwork implements HologramOwner {
|
||||
return null;
|
||||
}
|
||||
|
||||
switch (id) {
|
||||
case "CARGO_MANAGER":
|
||||
return NetworkComponent.REGULATOR;
|
||||
case "CARGO_NODE":
|
||||
return NetworkComponent.CONNECTOR;
|
||||
case "CARGO_NODE_INPUT":
|
||||
case "CARGO_NODE_OUTPUT":
|
||||
case "CARGO_NODE_OUTPUT_ADVANCED":
|
||||
case "CT_IMPORT_BUS":
|
||||
case "CT_EXPORT_BUS":
|
||||
case "CHEST_TERMINAL":
|
||||
return NetworkComponent.TERMINUS;
|
||||
default:
|
||||
return null;
|
||||
}
|
||||
return switch (id) {
|
||||
case "CARGO_MANAGER" -> NetworkComponent.REGULATOR;
|
||||
case "CARGO_NODE" -> NetworkComponent.CONNECTOR;
|
||||
case "CARGO_NODE_INPUT",
|
||||
"CARGO_NODE_OUTPUT",
|
||||
"CARGO_NODE_OUTPUT_ADVANCED" -> NetworkComponent.TERMINUS;
|
||||
default -> null;
|
||||
};
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -123,15 +116,10 @@ public class CargoNet extends AbstractItemNetwork implements HologramOwner {
|
||||
if (to == NetworkComponent.TERMINUS) {
|
||||
String id = BlockStorage.checkID(l);
|
||||
switch (id) {
|
||||
case "CARGO_NODE_INPUT":
|
||||
inputNodes.add(l);
|
||||
break;
|
||||
case "CARGO_NODE_OUTPUT":
|
||||
case "CARGO_NODE_OUTPUT_ADVANCED":
|
||||
outputNodes.add(l);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
case "CARGO_NODE_INPUT" -> inputNodes.add(l);
|
||||
case "CARGO_NODE_OUTPUT",
|
||||
"CARGO_NODE_OUTPUT_ADVANCED" -> outputNodes.add(l);
|
||||
default -> {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -70,21 +70,20 @@ final class CargoUtils {
|
||||
|
||||
Material type = block.getType();
|
||||
|
||||
switch (type) {
|
||||
case CHEST:
|
||||
case TRAPPED_CHEST:
|
||||
case FURNACE:
|
||||
case DISPENSER:
|
||||
case DROPPER:
|
||||
case HOPPER:
|
||||
case BREWING_STAND:
|
||||
case BARREL:
|
||||
case BLAST_FURNACE:
|
||||
case SMOKER:
|
||||
return true;
|
||||
default:
|
||||
return SlimefunTag.SHULKER_BOXES.isTagged(type);
|
||||
}
|
||||
// TODO: Add designated SlimefunTag
|
||||
return switch (type) {
|
||||
case CHEST,
|
||||
TRAPPED_CHEST,
|
||||
FURNACE,
|
||||
DISPENSER,
|
||||
DROPPER,
|
||||
HOPPER,
|
||||
BREWING_STAND,
|
||||
BARREL,
|
||||
BLAST_FURNACE,
|
||||
SMOKER -> true;
|
||||
default -> SlimefunTag.SHULKER_BOXES.isTagged(type);
|
||||
};
|
||||
}
|
||||
|
||||
@Nonnull
|
||||
@ -145,8 +144,8 @@ final class CargoUtils {
|
||||
|
||||
BlockState state = PaperLib.getBlockState(target, false).getState();
|
||||
|
||||
if (state instanceof InventoryHolder) {
|
||||
inventory = ((InventoryHolder) state).getInventory();
|
||||
if (state instanceof InventoryHolder inventoryHolder) {
|
||||
inventory = inventoryHolder.getInventory();
|
||||
inventories.put(target.getLocation(), inventory);
|
||||
return withdrawFromVanillaInventory(network, node, template, inventory);
|
||||
}
|
||||
@ -230,8 +229,8 @@ final class CargoUtils {
|
||||
|
||||
BlockState state = PaperLib.getBlockState(target, false).getState();
|
||||
|
||||
if (state instanceof InventoryHolder) {
|
||||
inventory = ((InventoryHolder) state).getInventory();
|
||||
if (state instanceof InventoryHolder inventoryHolder) {
|
||||
inventory = inventoryHolder.getInventory();
|
||||
inventories.put(target.getLocation(), inventory);
|
||||
return withdrawFromVanillaInventory(network, node, inventory);
|
||||
}
|
||||
@ -278,8 +277,8 @@ final class CargoUtils {
|
||||
|
||||
BlockState state = PaperLib.getBlockState(target, false).getState();
|
||||
|
||||
if (state instanceof InventoryHolder) {
|
||||
inventory = ((InventoryHolder) state).getInventory();
|
||||
if (state instanceof InventoryHolder inventoryHolder) {
|
||||
inventory = inventoryHolder.getInventory();
|
||||
inventories.put(target.getLocation(), inventory);
|
||||
return insertIntoVanillaInventory(stack, wrapper, smartFill, inventory);
|
||||
}
|
||||
|
@ -75,16 +75,13 @@ public class EnergyNet extends Network implements HologramOwner {
|
||||
if (component == null) {
|
||||
return null;
|
||||
} else {
|
||||
switch (component.getEnergyComponentType()) {
|
||||
case CONNECTOR:
|
||||
case CAPACITOR:
|
||||
return NetworkComponent.CONNECTOR;
|
||||
case CONSUMER:
|
||||
case GENERATOR:
|
||||
return NetworkComponent.TERMINUS;
|
||||
default:
|
||||
return null;
|
||||
}
|
||||
return switch (component.getEnergyComponentType()) {
|
||||
case CONNECTOR,
|
||||
CAPACITOR -> NetworkComponent.CONNECTOR;
|
||||
case CONSUMER,
|
||||
GENERATOR -> NetworkComponent.TERMINUS;
|
||||
default -> null;
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
@ -106,10 +103,10 @@ public class EnergyNet extends Network implements HologramOwner {
|
||||
consumers.put(l, component);
|
||||
break;
|
||||
case GENERATOR:
|
||||
if (component instanceof EnergyNetProvider) {
|
||||
generators.put(l, (EnergyNetProvider) component);
|
||||
} else if (component instanceof SlimefunItem) {
|
||||
((SlimefunItem) component).warn("This Item is marked as a GENERATOR but does not implement the interface EnergyNetProvider!");
|
||||
if (component instanceof EnergyNetProvider provider) {
|
||||
generators.put(l, provider);
|
||||
} else if (component instanceof SlimefunItem item) {
|
||||
item.warn("This Item is marked as a GENERATOR but does not implement the interface EnergyNetProvider!");
|
||||
}
|
||||
break;
|
||||
default:
|
||||
@ -275,8 +272,8 @@ public class EnergyNet extends Network implements HologramOwner {
|
||||
private static EnergyNetComponent getComponent(@Nonnull Location l) {
|
||||
SlimefunItem item = BlockStorage.check(l);
|
||||
|
||||
if (item instanceof EnergyNetComponent) {
|
||||
return ((EnergyNetComponent) item);
|
||||
if (item instanceof EnergyNetComponent component) {
|
||||
return component;
|
||||
}
|
||||
|
||||
return null;
|
||||
|
@ -72,9 +72,9 @@ public class BlockDataService implements Keyed {
|
||||
*/
|
||||
BlockState state = b.getState();
|
||||
|
||||
if (state instanceof TileState) {
|
||||
if (state instanceof TileState tileState) {
|
||||
try {
|
||||
PersistentDataContainer container = ((TileState) state).getPersistentDataContainer();
|
||||
PersistentDataContainer container = tileState.getPersistentDataContainer();
|
||||
container.set(namespacedKey, PersistentDataType.STRING, value);
|
||||
state.update();
|
||||
} catch (Exception x) {
|
||||
@ -111,8 +111,8 @@ public class BlockDataService implements Keyed {
|
||||
|
||||
@Nullable
|
||||
private PersistentDataContainer getPersistentDataContainer(@Nonnull BlockState state) {
|
||||
if (state instanceof TileState) {
|
||||
return ((TileState) state).getPersistentDataContainer();
|
||||
if (state instanceof TileState tileState) {
|
||||
return tileState.getPersistentDataContainer();
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
@ -137,31 +137,32 @@ public class BlockDataService implements Keyed {
|
||||
return false;
|
||||
}
|
||||
|
||||
switch (type) {
|
||||
case PLAYER_HEAD:
|
||||
case PLAYER_WALL_HEAD:
|
||||
case CHEST:
|
||||
case DISPENSER:
|
||||
case BREWING_STAND:
|
||||
case DROPPER:
|
||||
case FURNACE:
|
||||
case BLAST_FURNACE:
|
||||
case HOPPER:
|
||||
case LECTERN:
|
||||
case JUKEBOX:
|
||||
case ENDER_CHEST:
|
||||
case ENCHANTING_TABLE:
|
||||
case DAYLIGHT_DETECTOR:
|
||||
case SMOKER:
|
||||
case BARREL:
|
||||
case SPAWNER:
|
||||
case BEACON:
|
||||
// TODO: Add designated SlimefunTag
|
||||
return switch (type) {
|
||||
case PLAYER_HEAD,
|
||||
PLAYER_WALL_HEAD,
|
||||
CHEST,
|
||||
DISPENSER,
|
||||
BREWING_STAND,
|
||||
DROPPER,
|
||||
FURNACE,
|
||||
BLAST_FURNACE,
|
||||
HOPPER,
|
||||
LECTERN,
|
||||
JUKEBOX,
|
||||
ENDER_CHEST,
|
||||
ENCHANTING_TABLE,
|
||||
DAYLIGHT_DETECTOR,
|
||||
SMOKER,
|
||||
BARREL,
|
||||
SPAWNER,
|
||||
BEACON ->
|
||||
// All of the above Materials are Tile Entities
|
||||
return true;
|
||||
default:
|
||||
true;
|
||||
default ->
|
||||
// Otherwise we assume they're not Tile Entities
|
||||
return false;
|
||||
}
|
||||
false;
|
||||
};
|
||||
}
|
||||
|
||||
}
|
@ -99,8 +99,7 @@ public class MinecraftRecipeService {
|
||||
*
|
||||
* @return An {@link Optional} describing the furnace output of the given {@link ItemStack}
|
||||
*/
|
||||
@Nonnull
|
||||
public Optional<ItemStack> getFurnaceOutput(@Nullable ItemStack input) {
|
||||
public @Nonnull Optional<ItemStack> getFurnaceOutput(@Nullable ItemStack input) {
|
||||
if (snapshot == null || input == null) {
|
||||
return Optional.empty();
|
||||
}
|
||||
@ -132,18 +131,17 @@ public class MinecraftRecipeService {
|
||||
*
|
||||
* @return An Array of {@link RecipeChoice} representing the shape of this {@link Recipe}
|
||||
*/
|
||||
@Nonnull
|
||||
public RecipeChoice[] getRecipeShape(@Nonnull Recipe recipe) {
|
||||
public @Nonnull RecipeChoice[] getRecipeShape(@Nonnull Recipe recipe) {
|
||||
Validate.notNull(recipe, "Recipe must not be null!");
|
||||
|
||||
if (recipe instanceof ShapedRecipe) {
|
||||
if (recipe instanceof ShapedRecipe shapedRecipe) {
|
||||
List<RecipeChoice> choices = new LinkedList<>();
|
||||
|
||||
for (String row : ((ShapedRecipe) recipe).getShape()) {
|
||||
for (String row : shapedRecipe.getShape()) {
|
||||
int columns = row.toCharArray().length;
|
||||
|
||||
for (char key : row.toCharArray()) {
|
||||
choices.add(((ShapedRecipe) recipe).getChoiceMap().get(key));
|
||||
choices.add(shapedRecipe.getChoiceMap().get(key));
|
||||
}
|
||||
|
||||
while (columns < 3) {
|
||||
@ -167,8 +165,7 @@ public class MinecraftRecipeService {
|
||||
*
|
||||
* @return An array of {@link Recipe Recipes} to craft the given {@link ItemStack}
|
||||
*/
|
||||
@Nonnull
|
||||
public Recipe[] getRecipesFor(@Nullable ItemStack item) {
|
||||
public @Nonnull Recipe[] getRecipesFor(@Nullable ItemStack item) {
|
||||
if (snapshot == null || item == null) {
|
||||
return new Recipe[0];
|
||||
} else {
|
||||
@ -187,8 +184,7 @@ public class MinecraftRecipeService {
|
||||
*
|
||||
* @return The corresponding {@link Recipe} or null
|
||||
*/
|
||||
@Nullable
|
||||
public Recipe getRecipe(@Nonnull NamespacedKey key) {
|
||||
public @Nullable Recipe getRecipe(@Nonnull NamespacedKey key) {
|
||||
Validate.notNull(key, "The NamespacedKey should not be null");
|
||||
|
||||
if (snapshot != null) {
|
||||
|
@ -82,7 +82,7 @@ class GitHubTask implements Runnable {
|
||||
}
|
||||
|
||||
for (GitHubConnector connector : gitHubService.getConnectors()) {
|
||||
if (connector instanceof ContributionsConnector && !((ContributionsConnector) connector).hasFinished()) {
|
||||
if (connector instanceof ContributionsConnector contributionsConnector && !contributionsConnector.hasFinished()) {
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
@ -62,9 +62,9 @@ class Hologram {
|
||||
ArmorStand getArmorStand() {
|
||||
Entity n = Bukkit.getEntity(uniqueId);
|
||||
|
||||
if (n instanceof ArmorStand && n.isValid()) {
|
||||
if (n instanceof ArmorStand armorStand && n.isValid()) {
|
||||
this.lastAccess = System.currentTimeMillis();
|
||||
return (ArmorStand) n;
|
||||
return armorStand;
|
||||
} else {
|
||||
this.lastAccess = 0;
|
||||
return null;
|
||||
|
@ -191,11 +191,9 @@ public class HologramsService {
|
||||
* @return Whether this could be a hologram
|
||||
*/
|
||||
private boolean isHologram(@Nonnull Entity n) {
|
||||
if (n instanceof ArmorStand) {
|
||||
ArmorStand armorstand = (ArmorStand) n;
|
||||
|
||||
if (n instanceof ArmorStand armorStand) {
|
||||
// The absolute minimum requirements to count as a hologram
|
||||
return !armorstand.isVisible() && armorstand.isSilent() && !armorstand.hasGravity();
|
||||
return !armorStand.isVisible() && armorStand.isSilent() && !armorStand.hasGravity();
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
@ -216,22 +214,20 @@ public class HologramsService {
|
||||
*/
|
||||
@Nullable
|
||||
private Hologram getAsHologram(@Nonnull BlockPosition position, @Nonnull Entity entity, @Nonnull PersistentDataContainer container) {
|
||||
if (entity instanceof ArmorStand) {
|
||||
ArmorStand armorstand = (ArmorStand) entity;
|
||||
|
||||
armorstand.setVisible(false);
|
||||
armorstand.setInvulnerable(true);
|
||||
armorstand.setSilent(true);
|
||||
armorstand.setMarker(true);
|
||||
armorstand.setAI(false);
|
||||
armorstand.setGravity(false);
|
||||
armorstand.setRemoveWhenFarAway(false);
|
||||
if (entity instanceof ArmorStand armorStand) {
|
||||
armorStand.setVisible(false);
|
||||
armorStand.setInvulnerable(true);
|
||||
armorStand.setSilent(true);
|
||||
armorStand.setMarker(true);
|
||||
armorStand.setAI(false);
|
||||
armorStand.setGravity(false);
|
||||
armorStand.setRemoveWhenFarAway(false);
|
||||
|
||||
// Set a persistent tag to re-identify the correct hologram later
|
||||
container.set(persistentDataKey, PersistentDataType.LONG, position.getPosition());
|
||||
|
||||
// Store in cache for faster access
|
||||
Hologram hologram = new Hologram(armorstand.getUniqueId());
|
||||
Hologram hologram = new Hologram(armorStand.getUniqueId());
|
||||
cache.put(position, hologram);
|
||||
|
||||
return hologram;
|
||||
|
@ -348,8 +348,8 @@ public abstract class SlimefunLocalization implements Keyed {
|
||||
|
||||
String prefix = addPrefix ? getChatPrefix() : "";
|
||||
|
||||
if (recipient instanceof Player) {
|
||||
recipient.sendMessage(ChatColors.color(prefix + getMessage((Player) recipient, key)));
|
||||
if (recipient instanceof Player player) {
|
||||
recipient.sendMessage(ChatColors.color(prefix + getMessage(player, key)));
|
||||
} else {
|
||||
recipient.sendMessage(ChatColor.stripColor(ChatColors.color(prefix + getMessage(key))));
|
||||
}
|
||||
@ -383,8 +383,8 @@ public abstract class SlimefunLocalization implements Keyed {
|
||||
|
||||
String prefix = addPrefix ? getChatPrefix() : "";
|
||||
|
||||
if (recipient instanceof Player) {
|
||||
recipient.sendMessage(ChatColors.color(prefix + function.apply(getMessage((Player) recipient, key))));
|
||||
if (recipient instanceof Player player) {
|
||||
recipient.sendMessage(ChatColors.color(prefix + function.apply(getMessage(player, key))));
|
||||
} else {
|
||||
recipient.sendMessage(ChatColor.stripColor(ChatColors.color(prefix + function.apply(getMessage(key)))));
|
||||
}
|
||||
@ -393,8 +393,8 @@ public abstract class SlimefunLocalization implements Keyed {
|
||||
public void sendMessages(@Nonnull CommandSender recipient, @Nonnull String key) {
|
||||
String prefix = getChatPrefix();
|
||||
|
||||
if (recipient instanceof Player) {
|
||||
for (String translation : getMessages((Player) recipient, key)) {
|
||||
if (recipient instanceof Player player) {
|
||||
for (String translation : getMessages(player, key)) {
|
||||
String message = ChatColors.color(prefix + translation);
|
||||
recipient.sendMessage(message);
|
||||
}
|
||||
@ -410,8 +410,8 @@ public abstract class SlimefunLocalization implements Keyed {
|
||||
public void sendMessages(CommandSender recipient, String key, boolean addPrefix, UnaryOperator<String> function) {
|
||||
String prefix = addPrefix ? getChatPrefix() : "";
|
||||
|
||||
if (recipient instanceof Player) {
|
||||
for (String translation : getMessages((Player) recipient, key)) {
|
||||
if (recipient instanceof Player player) {
|
||||
for (String translation : getMessages(player, key)) {
|
||||
String message = ChatColors.color(prefix + function.apply(translation));
|
||||
recipient.sendMessage(message);
|
||||
}
|
||||
|
@ -95,9 +95,9 @@ class PerformanceSummary {
|
||||
List<Entry<String, Long>> results = stream.sorted(Map.Entry.comparingByValue(Comparator.reverseOrder())).collect(Collectors.toList());
|
||||
String prefix = count + " " + name + (count != 1 ? 's' : "");
|
||||
|
||||
if (inspector instanceof PlayerPerformanceInspector) {
|
||||
if (inspector instanceof PlayerPerformanceInspector playerPerformanceInspector) {
|
||||
TextComponent component = summarizeAsTextComponent(count, prefix, results, formatter);
|
||||
((PlayerPerformanceInspector) inspector).sendMessage(component);
|
||||
playerPerformanceInspector.sendMessage(component);
|
||||
} else {
|
||||
String text = summarizeAsString(inspector, count, prefix, results, formatter);
|
||||
inspector.sendMessage(text);
|
||||
|
@ -143,9 +143,8 @@ final class ProfiledBlock {
|
||||
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
if (obj instanceof ProfiledBlock) {
|
||||
ProfiledBlock block = (ProfiledBlock) obj;
|
||||
return position == block.position && Objects.equals(world, block.world);
|
||||
if (obj instanceof ProfiledBlock profiledBlock) {
|
||||
return position == profiledBlock.position && Objects.equals(world, profiledBlock.world);
|
||||
}
|
||||
|
||||
return false;
|
||||
|
@ -134,6 +134,11 @@ import me.mrCookieSlime.Slimefun.api.inventory.UniversalBlockMenu;
|
||||
*/
|
||||
public final class Slimefun extends JavaPlugin implements SlimefunAddon {
|
||||
|
||||
/**
|
||||
* This is the Java version we recommend server owners to use.
|
||||
* This does not necessarily mean that it's the minimum version
|
||||
* required to run Slimefun.
|
||||
*/
|
||||
private static final int RECOMMENDED_JAVA_VERSION = 17;
|
||||
|
||||
/**
|
||||
|
@ -54,7 +54,7 @@ public class CheatSheetSlimefunGuide extends SurvivalSlimefunGuide {
|
||||
List<ItemGroup> groups = new LinkedList<>();
|
||||
|
||||
for (ItemGroup group : Slimefun.getRegistry().getAllItemGroups()) {
|
||||
if (!(group instanceof FlexItemGroup) || ((FlexItemGroup) group).isVisible(p, profile, getMode())) {
|
||||
if (!(group instanceof FlexItemGroup flexItemGroup) || flexItemGroup.isVisible(p, profile, getMode())) {
|
||||
groups.add(group);
|
||||
}
|
||||
}
|
||||
|
@ -119,8 +119,8 @@ public class SurvivalSlimefunGuide implements SlimefunGuideImplementation {
|
||||
|
||||
for (ItemGroup group : Slimefun.getRegistry().getAllItemGroups()) {
|
||||
try {
|
||||
if (group instanceof FlexItemGroup) {
|
||||
if (((FlexItemGroup) group).isVisible(p, profile, getMode())) {
|
||||
if (group instanceof FlexItemGroup flexItemGroup) {
|
||||
if (flexItemGroup.isVisible(p, profile, getMode())) {
|
||||
groups.add(group);
|
||||
}
|
||||
} else if (!group.isHidden(p)) {
|
||||
@ -233,8 +233,8 @@ public class SurvivalSlimefunGuide implements SlimefunGuideImplementation {
|
||||
return;
|
||||
}
|
||||
|
||||
if (itemGroup instanceof FlexItemGroup) {
|
||||
((FlexItemGroup) itemGroup).open(p, profile, getMode());
|
||||
if (itemGroup instanceof FlexItemGroup flexItemGroup) {
|
||||
flexItemGroup.open(p, profile, getMode());
|
||||
return;
|
||||
}
|
||||
|
||||
@ -493,19 +493,19 @@ public class SurvivalSlimefunGuide implements SlimefunGuideImplementation {
|
||||
private <T extends Recipe> void showRecipeChoices(T recipe, ItemStack[] recipeItems, AsyncRecipeChoiceTask task) {
|
||||
RecipeChoice[] choices = Slimefun.getMinecraftRecipeService().getRecipeShape(recipe);
|
||||
|
||||
if (choices.length == 1 && choices[0] instanceof MaterialChoice) {
|
||||
recipeItems[4] = new ItemStack(((MaterialChoice) choices[0]).getChoices().get(0));
|
||||
if (choices.length == 1 && choices[0] instanceof MaterialChoice materialChoice) {
|
||||
recipeItems[4] = new ItemStack(materialChoice.getChoices().get(0));
|
||||
|
||||
if (((MaterialChoice) choices[0]).getChoices().size() > 1) {
|
||||
task.add(recipeSlots[4], (MaterialChoice) choices[0]);
|
||||
if (materialChoice.getChoices().size() > 1) {
|
||||
task.add(recipeSlots[4], materialChoice);
|
||||
}
|
||||
} else {
|
||||
for (int i = 0; i < choices.length; i++) {
|
||||
if (choices[i] instanceof MaterialChoice) {
|
||||
recipeItems[i] = new ItemStack(((MaterialChoice) choices[i]).getChoices().get(0));
|
||||
if (choices[i] instanceof MaterialChoice materialChoice) {
|
||||
recipeItems[i] = new ItemStack(materialChoice.getChoices().get(0));
|
||||
|
||||
if (((MaterialChoice) choices[i]).getChoices().size() > 1) {
|
||||
task.add(recipeSlots[i], (MaterialChoice) choices[i]);
|
||||
if (materialChoice.getChoices().size() > 1) {
|
||||
task.add(recipeSlots[i], materialChoice);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -545,8 +545,8 @@ public class SurvivalSlimefunGuide implements SlimefunGuideImplementation {
|
||||
|
||||
displayItem(menu, profile, p, item, result, recipeType, recipe, task);
|
||||
|
||||
if (item instanceof RecipeDisplayItem) {
|
||||
displayRecipes(p, profile, menu, (RecipeDisplayItem) item, 0);
|
||||
if (item instanceof RecipeDisplayItem recipeDisplayItem) {
|
||||
displayRecipes(p, profile, menu, recipeDisplayItem, 0);
|
||||
}
|
||||
|
||||
menu.open(p);
|
||||
|
@ -78,8 +78,8 @@ public class VanillaInventoryDropHandler<T extends BlockState & InventoryHolder>
|
||||
|
||||
@Nonnull
|
||||
protected Inventory getInventory(@Nonnull T inventoryHolder) {
|
||||
if (inventoryHolder instanceof Chest) {
|
||||
return ((Chest) inventoryHolder).getBlockInventory();
|
||||
if (inventoryHolder instanceof Chest chest) {
|
||||
return chest.getBlockInventory();
|
||||
} else {
|
||||
return inventoryHolder.getInventory();
|
||||
}
|
||||
|
@ -86,8 +86,8 @@ public class AncientPedestal extends SimpleSlimefunItem<BlockDispenseHandler> {
|
||||
Location l = pedestal.getLocation().add(0.5, 1.2, 0.5);
|
||||
|
||||
for (Entity n : l.getWorld().getNearbyEntities(l, 0.5, 0.5, 0.5, this::testItem)) {
|
||||
if (n instanceof Item) {
|
||||
return Optional.of((Item) n);
|
||||
if (n instanceof Item item) {
|
||||
return Optional.of(item);
|
||||
}
|
||||
}
|
||||
|
||||
@ -95,8 +95,7 @@ public class AncientPedestal extends SimpleSlimefunItem<BlockDispenseHandler> {
|
||||
}
|
||||
|
||||
private boolean testItem(@Nullable Entity n) {
|
||||
if (n instanceof Item && n.isValid()) {
|
||||
Item item = (Item) n;
|
||||
if (n instanceof Item item && n.isValid()) {
|
||||
ItemMeta meta = item.getItemStack().getItemMeta();
|
||||
|
||||
return meta.hasDisplayName() && meta.getDisplayName().startsWith(ITEM_PREFIX);
|
||||
|
@ -2,6 +2,8 @@ package io.github.thebusybiscuit.slimefun4.implementation.items.androids;
|
||||
|
||||
import java.util.function.Predicate;
|
||||
|
||||
import javax.annotation.ParametersAreNonnullByDefault;
|
||||
|
||||
import org.bukkit.block.Block;
|
||||
import org.bukkit.block.BlockFace;
|
||||
import org.bukkit.entity.ArmorStand;
|
||||
@ -20,6 +22,7 @@ public class ButcherAndroid extends ProgrammableAndroid {
|
||||
|
||||
private static final String METADATA_KEY = "android_killer";
|
||||
|
||||
@ParametersAreNonnullByDefault
|
||||
public ButcherAndroid(ItemGroup itemGroup, int tier, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) {
|
||||
super(itemGroup, tier, item, recipeType, recipe);
|
||||
}
|
||||
@ -34,27 +37,17 @@ public class ButcherAndroid extends ProgrammableAndroid {
|
||||
double damage = getTier() >= 3 ? 20D : 4D * getTier();
|
||||
double radius = 4.0 + getTier();
|
||||
|
||||
for (Entity n : b.getWorld().getNearbyEntities(b.getLocation(), radius, radius, radius, n -> n instanceof LivingEntity && !(n instanceof ArmorStand) && !(n instanceof Player) && n.isValid() && predicate.test((LivingEntity) n))) {
|
||||
boolean attack = false;
|
||||
for (Entity n : b.getWorld().getNearbyEntities(b.getLocation(), radius, radius, radius, n -> n instanceof LivingEntity livingEntity && !(n instanceof ArmorStand) && !(n instanceof Player) && n.isValid() && predicate.test(livingEntity))) {
|
||||
// Check if our android is facing this entity.
|
||||
boolean willAttack = switch (face) {
|
||||
case NORTH -> n.getLocation().getZ() < b.getZ();
|
||||
case EAST -> n.getLocation().getX() > b.getX();
|
||||
case SOUTH -> n.getLocation().getZ() > b.getZ();
|
||||
case WEST -> n.getLocation().getX() < b.getX();
|
||||
default -> false;
|
||||
};
|
||||
|
||||
switch (face) {
|
||||
case NORTH:
|
||||
attack = n.getLocation().getZ() < b.getZ();
|
||||
break;
|
||||
case EAST:
|
||||
attack = n.getLocation().getX() > b.getX();
|
||||
break;
|
||||
case SOUTH:
|
||||
attack = n.getLocation().getZ() > b.getZ();
|
||||
break;
|
||||
case WEST:
|
||||
attack = n.getLocation().getX() < b.getX();
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
if (attack) {
|
||||
if (willAttack) {
|
||||
if (n.hasMetadata(METADATA_KEY)) {
|
||||
n.removeMetadata(METADATA_KEY, Slimefun.instance());
|
||||
}
|
||||
|
@ -42,7 +42,7 @@ public class FarmerAndroid extends ProgrammableAndroid {
|
||||
return;
|
||||
}
|
||||
|
||||
if (data instanceof Ageable && ((Ageable) data).getAge() >= ((Ageable) data).getMaximumAge()) {
|
||||
if (data instanceof Ageable ageable && ageable.getAge() >= ageable.getMaximumAge()) {
|
||||
drop = getDropFromCrop(blockType);
|
||||
}
|
||||
|
||||
@ -57,8 +57,8 @@ public class FarmerAndroid extends ProgrammableAndroid {
|
||||
if (drop != null && menu.pushItem(drop, getOutputSlots()) == null) {
|
||||
block.getWorld().playEffect(block.getLocation(), Effect.STEP_SOUND, blockType);
|
||||
|
||||
if (data instanceof Ageable) {
|
||||
((Ageable) data).setAge(0);
|
||||
if (data instanceof Ageable ageable) {
|
||||
ageable.setAge(0);
|
||||
block.setBlockData(data);
|
||||
}
|
||||
}
|
||||
@ -68,24 +68,16 @@ public class FarmerAndroid extends ProgrammableAndroid {
|
||||
private ItemStack getDropFromCrop(Material crop) {
|
||||
Random random = ThreadLocalRandom.current();
|
||||
|
||||
switch (crop) {
|
||||
case WHEAT:
|
||||
return new ItemStack(Material.WHEAT, random.nextInt(2) + 1);
|
||||
case POTATOES:
|
||||
return new ItemStack(Material.POTATO, random.nextInt(3) + 1);
|
||||
case CARROTS:
|
||||
return new ItemStack(Material.CARROT, random.nextInt(3) + 1);
|
||||
case BEETROOTS:
|
||||
return new ItemStack(Material.BEETROOT, random.nextInt(3) + 1);
|
||||
case COCOA:
|
||||
return new ItemStack(Material.COCOA_BEANS, random.nextInt(3) + 1);
|
||||
case NETHER_WART:
|
||||
return new ItemStack(Material.NETHER_WART, random.nextInt(3) + 1);
|
||||
case SWEET_BERRY_BUSH:
|
||||
return new ItemStack(Material.SWEET_BERRIES, random.nextInt(3) + 1);
|
||||
default:
|
||||
return null;
|
||||
}
|
||||
return switch (crop) {
|
||||
case WHEAT -> new ItemStack(Material.WHEAT, random.nextInt(2) + 1);
|
||||
case POTATOES -> new ItemStack(Material.POTATO, random.nextInt(3) + 1);
|
||||
case CARROTS -> new ItemStack(Material.CARROT, random.nextInt(3) + 1);
|
||||
case BEETROOTS -> new ItemStack(Material.BEETROOT, random.nextInt(3) + 1);
|
||||
case COCOA -> new ItemStack(Material.COCOA_BEANS, random.nextInt(3) + 1);
|
||||
case NETHER_WART -> new ItemStack(Material.NETHER_WART, random.nextInt(3) + 1);
|
||||
case SWEET_BERRY_BUSH -> new ItemStack(Material.SWEET_BERRIES, random.nextInt(3) + 1);
|
||||
default -> null;
|
||||
};
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -156,8 +156,8 @@ public class ProgrammableAndroid extends SlimefunItem implements InventoryBlock,
|
||||
BlockStorage.addBlockInfo(b, "paused", "true");
|
||||
|
||||
BlockData blockData = Material.PLAYER_HEAD.createBlockData(data -> {
|
||||
if (data instanceof Rotatable) {
|
||||
((Rotatable) data).setRotation(p.getFacing());
|
||||
if (data instanceof Rotatable rotatable) {
|
||||
rotatable.setRotation(p.getFacing());
|
||||
}
|
||||
});
|
||||
|
||||
@ -207,16 +207,12 @@ public class ProgrammableAndroid extends SlimefunItem implements InventoryBlock,
|
||||
* @return The required type of fuel
|
||||
*/
|
||||
public AndroidFuelSource getFuelSource() {
|
||||
switch (getTier()) {
|
||||
case 1:
|
||||
return AndroidFuelSource.SOLID;
|
||||
case 2:
|
||||
return AndroidFuelSource.LIQUID;
|
||||
case 3:
|
||||
return AndroidFuelSource.NUCLEAR;
|
||||
default:
|
||||
throw new IllegalStateException("Cannot convert the following Android tier to a fuel type: " + getTier());
|
||||
}
|
||||
return switch (getTier()) {
|
||||
case 1 -> AndroidFuelSource.SOLID;
|
||||
case 2 -> AndroidFuelSource.LIQUID;
|
||||
case 3 -> AndroidFuelSource.NUCLEAR;
|
||||
default -> throw new IllegalStateException("Cannot convert the following Android tier to a fuel type: " + getTier());
|
||||
};
|
||||
}
|
||||
|
||||
@Override
|
||||
@ -602,7 +598,7 @@ public class ProgrammableAndroid extends SlimefunItem implements InventoryBlock,
|
||||
|
||||
private void registerDefaultFuelTypes() {
|
||||
switch (getFuelSource()) {
|
||||
case SOLID:
|
||||
case SOLID -> {
|
||||
registerFuelType(new MachineFuel(80, new ItemStack(Material.COAL_BLOCK)));
|
||||
registerFuelType(new MachineFuel(45, new ItemStack(Material.BLAZE_ROD)));
|
||||
registerFuelType(new MachineFuel(70, new ItemStack(Material.DRIED_KELP_BLOCK)));
|
||||
@ -620,20 +616,18 @@ public class ProgrammableAndroid extends SlimefunItem implements InventoryBlock,
|
||||
for (Material mat : Tag.PLANKS.getValues()) {
|
||||
registerFuelType(new MachineFuel(1, new ItemStack(mat)));
|
||||
}
|
||||
|
||||
break;
|
||||
case LIQUID:
|
||||
}
|
||||
case LIQUID -> {
|
||||
registerFuelType(new MachineFuel(100, new ItemStack(Material.LAVA_BUCKET)));
|
||||
registerFuelType(new MachineFuel(200, SlimefunItems.OIL_BUCKET));
|
||||
registerFuelType(new MachineFuel(500, SlimefunItems.FUEL_BUCKET));
|
||||
break;
|
||||
case NUCLEAR:
|
||||
}
|
||||
case NUCLEAR -> {
|
||||
registerFuelType(new MachineFuel(2500, SlimefunItems.URANIUM));
|
||||
registerFuelType(new MachineFuel(1200, SlimefunItems.NEPTUNIUM));
|
||||
registerFuelType(new MachineFuel(3000, SlimefunItems.BOOSTED_URANIUM));
|
||||
break;
|
||||
default:
|
||||
throw new IllegalStateException("Unhandled Fuel Source: " + getFuelSource());
|
||||
}
|
||||
default -> throw new IllegalStateException("Unhandled Fuel Source: " + getFuelSource());
|
||||
}
|
||||
}
|
||||
|
||||
@ -760,8 +754,7 @@ public class ProgrammableAndroid extends SlimefunItem implements InventoryBlock,
|
||||
BlockFace rotation = POSSIBLE_ROTATIONS.get(index);
|
||||
|
||||
BlockData blockData = Material.PLAYER_HEAD.createBlockData(data -> {
|
||||
if (data instanceof Rotatable) {
|
||||
Rotatable rotatable = ((Rotatable) data);
|
||||
if (data instanceof Rotatable rotatable) {
|
||||
rotatable.setRotation(rotation.getOppositeFace());
|
||||
}
|
||||
});
|
||||
@ -774,14 +767,12 @@ public class ProgrammableAndroid extends SlimefunItem implements InventoryBlock,
|
||||
if (facedBlock.getType() == Material.DISPENSER && BlockStorage.check(facedBlock, "ANDROID_INTERFACE_ITEMS")) {
|
||||
BlockState state = PaperLib.getBlockState(facedBlock, false).getState();
|
||||
|
||||
if (state instanceof Dispenser) {
|
||||
Dispenser d = (Dispenser) state;
|
||||
|
||||
if (state instanceof Dispenser dispenser) {
|
||||
for (int slot : getOutputSlots()) {
|
||||
ItemStack stack = menu.getItemInSlot(slot);
|
||||
|
||||
if (stack != null) {
|
||||
Optional<ItemStack> optional = d.getInventory().addItem(stack).values().stream().findFirst();
|
||||
Optional<ItemStack> optional = dispenser.getInventory().addItem(stack).values().stream().findFirst();
|
||||
|
||||
if (optional.isPresent()) {
|
||||
menu.replaceExistingItem(slot, optional.get());
|
||||
@ -798,14 +789,12 @@ public class ProgrammableAndroid extends SlimefunItem implements InventoryBlock,
|
||||
if (facedBlock.getType() == Material.DISPENSER && BlockStorage.check(facedBlock, "ANDROID_INTERFACE_FUEL")) {
|
||||
BlockState state = PaperLib.getBlockState(facedBlock, false).getState();
|
||||
|
||||
if (state instanceof Dispenser) {
|
||||
Dispenser d = (Dispenser) state;
|
||||
|
||||
if (state instanceof Dispenser dispenser) {
|
||||
for (int slot = 0; slot < 9; slot++) {
|
||||
ItemStack item = d.getInventory().getItem(slot);
|
||||
ItemStack item = dispenser.getInventory().getItem(slot);
|
||||
|
||||
if (item != null) {
|
||||
insertFuel(menu, d.getInventory(), slot, menu.getItemInSlot(43), item);
|
||||
insertFuel(menu, dispenser.getInventory(), slot, menu.getItemInSlot(43), item);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -897,8 +886,7 @@ public class ProgrammableAndroid extends SlimefunItem implements InventoryBlock,
|
||||
}
|
||||
|
||||
BlockData blockData = Material.PLAYER_HEAD.createBlockData(data -> {
|
||||
if (data instanceof Rotatable) {
|
||||
Rotatable rotatable = ((Rotatable) data);
|
||||
if (data instanceof Rotatable rotatable) {
|
||||
rotatable.setRotation(face.getOppositeFace());
|
||||
}
|
||||
});
|
||||
|
@ -51,7 +51,7 @@ public class StomperBoots extends SlimefunItem {
|
||||
player.setVelocity(new Vector(0, 0.7, 0));
|
||||
|
||||
for (Entity entity : player.getNearbyEntities(4, 4, 4)) {
|
||||
if (entity instanceof LivingEntity && canPush(player, (LivingEntity) entity)) {
|
||||
if (entity instanceof LivingEntity livingEntity && canPush(player, livingEntity)) {
|
||||
Vector velocity = getShockwave(player.getLocation(), entity.getLocation());
|
||||
entity.setVelocity(velocity);
|
||||
|
||||
@ -61,7 +61,7 @@ public class StomperBoots extends SlimefunItem {
|
||||
Bukkit.getPluginManager().callEvent(event);
|
||||
|
||||
if (!event.isCancelled()) {
|
||||
((LivingEntity) entity).damage(event.getDamage());
|
||||
livingEntity.damage(event.getDamage());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -175,8 +175,8 @@ public abstract class AbstractAutoCrafter extends SlimefunItem implements Energy
|
||||
if (isValidInventory(targetBlock)) {
|
||||
BlockState state = PaperLib.getBlockState(targetBlock, false).getState();
|
||||
|
||||
if (state instanceof InventoryHolder) {
|
||||
Inventory inv = ((InventoryHolder) state).getInventory();
|
||||
if (state instanceof InventoryHolder inventoryHolder) {
|
||||
Inventory inv = inventoryHolder.getInventory();
|
||||
|
||||
if (craft(inv, recipe)) {
|
||||
// We are done crafting!
|
||||
@ -202,14 +202,13 @@ public abstract class AbstractAutoCrafter extends SlimefunItem implements Energy
|
||||
protected boolean isValidInventory(@Nonnull Block block) {
|
||||
Material type = block.getType();
|
||||
|
||||
switch (type) {
|
||||
case CHEST:
|
||||
case TRAPPED_CHEST:
|
||||
case BARREL:
|
||||
return true;
|
||||
default:
|
||||
return SlimefunTag.SHULKER_BOXES.isTagged(type);
|
||||
}
|
||||
// TODO: Add designated SlimefunTag
|
||||
return switch (type) {
|
||||
case CHEST,
|
||||
TRAPPED_CHEST,
|
||||
BARREL -> true;
|
||||
default -> SlimefunTag.SHULKER_BOXES.isTagged(type);
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
@ -251,16 +250,16 @@ public abstract class AbstractAutoCrafter extends SlimefunItem implements Energy
|
||||
BlockStateSnapshotResult result = PaperLib.getBlockState(b, false);
|
||||
BlockState state = result.getState();
|
||||
|
||||
if (state instanceof Skull) {
|
||||
if (state instanceof Skull skull) {
|
||||
if (recipe == null) {
|
||||
// Clear the value from persistent data storage
|
||||
PersistentDataAPI.remove((Skull) state, recipeStorageKey);
|
||||
PersistentDataAPI.remove(skull, recipeStorageKey);
|
||||
|
||||
// Also remove the "enabled" state since this should be per-recipe.
|
||||
PersistentDataAPI.remove((Skull) state, recipeEnabledKey);
|
||||
PersistentDataAPI.remove(skull, recipeEnabledKey);
|
||||
} else {
|
||||
// Store the value to persistent data storage
|
||||
PersistentDataAPI.setString((Skull) state, recipeStorageKey, recipe.toString());
|
||||
PersistentDataAPI.setString(skull, recipeStorageKey, recipe.toString());
|
||||
}
|
||||
|
||||
// Fixes #2899 - Update the BlockState if necessary
|
||||
@ -337,12 +336,12 @@ public abstract class AbstractAutoCrafter extends SlimefunItem implements Energy
|
||||
BlockState state = PaperLib.getBlockState(b, false).getState();
|
||||
|
||||
// Make sure the block is still a Skull
|
||||
if (state instanceof Skull) {
|
||||
if (state instanceof Skull skull) {
|
||||
if (enabled) {
|
||||
PersistentDataAPI.remove((Skull) state, recipeEnabledKey);
|
||||
PersistentDataAPI.remove(skull, recipeEnabledKey);
|
||||
Slimefun.getLocalization().sendMessage(p, "messages.auto-crafting.re-enabled");
|
||||
} else {
|
||||
PersistentDataAPI.setByte((Skull) state, recipeEnabledKey, (byte) 1);
|
||||
PersistentDataAPI.setByte(skull, recipeEnabledKey, (byte) 1);
|
||||
Slimefun.getLocalization().sendMessage(p, "messages.auto-crafting.temporarily-disabled");
|
||||
}
|
||||
}
|
||||
|
@ -136,10 +136,10 @@ public abstract class AbstractRecipe {
|
||||
*/
|
||||
@Nullable
|
||||
public static AbstractRecipe of(@Nullable Recipe recipe) {
|
||||
if (recipe instanceof ShapedRecipe) {
|
||||
return new VanillaRecipe((ShapedRecipe) recipe);
|
||||
} else if (recipe instanceof ShapelessRecipe) {
|
||||
return new VanillaRecipe((ShapelessRecipe) recipe);
|
||||
if (recipe instanceof ShapedRecipe shapedRecipe) {
|
||||
return new VanillaRecipe(shapedRecipe);
|
||||
} else if (recipe instanceof ShapelessRecipe shapelessRecipe) {
|
||||
return new VanillaRecipe(shapelessRecipe);
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
|
@ -60,9 +60,9 @@ public class SlimefunAutoCrafter extends AbstractAutoCrafter {
|
||||
|
||||
BlockState state = PaperLib.getBlockState(b, false).getState();
|
||||
|
||||
if (state instanceof Skull) {
|
||||
if (state instanceof Skull skull) {
|
||||
// Read the stored value from persistent data storage
|
||||
PersistentDataContainer container = ((Skull) state).getPersistentDataContainer();
|
||||
PersistentDataContainer container = skull.getPersistentDataContainer();
|
||||
String value = container.get(recipeStorageKey, PersistentDataType.STRING);
|
||||
SlimefunItem item = SlimefunItem.getById(value);
|
||||
|
||||
|
@ -61,9 +61,9 @@ public class VanillaAutoCrafter extends AbstractAutoCrafter {
|
||||
public @Nullable AbstractRecipe getSelectedRecipe(@Nonnull Block b) {
|
||||
BlockState state = PaperLib.getBlockState(b, false).getState();
|
||||
|
||||
if (state instanceof Skull) {
|
||||
if (state instanceof Skull skull) {
|
||||
// Read the stored value from persistent data storage
|
||||
PersistentDataContainer container = ((Skull) state).getPersistentDataContainer();
|
||||
PersistentDataContainer container = skull.getPersistentDataContainer();
|
||||
String value = container.get(recipeStorageKey, PersistentDataType.STRING);
|
||||
|
||||
if (value != null) {
|
||||
|
@ -81,19 +81,19 @@ class VanillaRecipe extends AbstractRecipe {
|
||||
RecipeChoice[] choices = Slimefun.getMinecraftRecipeService().getRecipeShape(recipe);
|
||||
ItemStack[] items = new ItemStack[9];
|
||||
|
||||
if (choices.length == 1 && choices[0] instanceof MaterialChoice) {
|
||||
items[4] = new ItemStack(((MaterialChoice) choices[0]).getChoices().get(0));
|
||||
if (choices.length == 1 && choices[0] instanceof MaterialChoice materialChoice) {
|
||||
items[4] = new ItemStack(materialChoice.getChoices().get(0));
|
||||
|
||||
if (((MaterialChoice) choices[0]).getChoices().size() > 1) {
|
||||
task.add(slots[4], (MaterialChoice) choices[0]);
|
||||
if (materialChoice.getChoices().size() > 1) {
|
||||
task.add(slots[4], materialChoice);
|
||||
}
|
||||
} else {
|
||||
for (int i = 0; i < choices.length; i++) {
|
||||
if (choices[i] instanceof MaterialChoice) {
|
||||
items[i] = new ItemStack(((MaterialChoice) choices[i]).getChoices().get(0));
|
||||
if (choices[i] instanceof MaterialChoice materialChoice) {
|
||||
items[i] = new ItemStack(materialChoice.getChoices().get(0));
|
||||
|
||||
if (((MaterialChoice) choices[i]).getChoices().size() > 1) {
|
||||
task.add(slots[i], (MaterialChoice) choices[i]);
|
||||
if (materialChoice.getChoices().size() > 1) {
|
||||
task.add(slots[i], materialChoice);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -107,8 +107,8 @@ class VanillaRecipe extends AbstractRecipe {
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
if (recipe instanceof Keyed) {
|
||||
return ((Keyed) recipe).getKey().toString();
|
||||
if (recipe instanceof Keyed keyed) {
|
||||
return keyed.getKey().toString();
|
||||
} else {
|
||||
return "invalid-recipe";
|
||||
}
|
||||
|
@ -83,12 +83,11 @@ public abstract class AbstractMonsterSpawner extends SlimefunItem {
|
||||
ItemMeta meta = item.getItemMeta();
|
||||
|
||||
// Fixes #2583 - Proper NBT handling of Spawners
|
||||
if (meta instanceof BlockStateMeta) {
|
||||
BlockStateMeta stateMeta = (BlockStateMeta) meta;
|
||||
if (meta instanceof BlockStateMeta stateMeta) {
|
||||
BlockState state = stateMeta.getBlockState();
|
||||
|
||||
if (state instanceof CreatureSpawner) {
|
||||
((CreatureSpawner) state).setSpawnedType(type);
|
||||
if (state instanceof CreatureSpawner spawner) {
|
||||
spawner.setSpawnedType(type);
|
||||
}
|
||||
|
||||
stateMeta.setBlockState(state);
|
||||
|
@ -222,8 +222,7 @@ public class BlockPlacer extends SlimefunItem {
|
||||
if (meta.hasDisplayName()) {
|
||||
BlockStateSnapshotResult blockState = PaperLib.getBlockState(facedBlock, false);
|
||||
|
||||
if ((blockState.getState() instanceof Nameable)) {
|
||||
Nameable nameable = ((Nameable) blockState.getState());
|
||||
if (blockState.getState() instanceof Nameable nameable) {
|
||||
nameable.setCustomName(meta.getDisplayName());
|
||||
|
||||
if (blockState.isSnapshot()) {
|
||||
|
@ -203,10 +203,9 @@ public class Crucible extends SimpleSlimefunItem<BlockUseHandler> implements Rec
|
||||
// Fixes #2903 - Cancel physics update to resolve weird overlapping
|
||||
block.setType(water ? Material.WATER : Material.LAVA, false);
|
||||
} else {
|
||||
if (water && block.getBlockData() instanceof Waterlogged) {
|
||||
Waterlogged wl = (Waterlogged) block.getBlockData();
|
||||
wl.setWaterlogged(true);
|
||||
block.setBlockData(wl, false);
|
||||
if (water && block.getBlockData() instanceof Waterlogged waterlogged) {
|
||||
waterlogged.setWaterlogged(true);
|
||||
block.setBlockData(waterlogged, false);
|
||||
block.getWorld().playSound(block.getLocation(), Sound.ENTITY_PLAYER_SPLASH, 1F, 1F);
|
||||
return;
|
||||
}
|
||||
|
@ -87,8 +87,8 @@ public class EnhancedFurnace extends SimpleSlimefunItem<BlockTicker> {
|
||||
BlockState state = result.getState();
|
||||
|
||||
// Check if the BlockState is a Furnace and cooking something
|
||||
if (state instanceof Furnace && ((Furnace) state).getCookTime() > 0) {
|
||||
setProgress((Furnace) state);
|
||||
if (state instanceof Furnace furnace && furnace.getCookTime() > 0) {
|
||||
setProgress(furnace);
|
||||
|
||||
// Only update if necessary
|
||||
if (result.isSnapshot()) {
|
||||
|
@ -140,11 +140,11 @@ public class HologramProjector extends SlimefunItem implements HologramOwner {
|
||||
Location l = new Location(projector.getWorld(), projector.getX() + 0.5, projector.getY() + offset, projector.getZ() + 0.5);
|
||||
|
||||
for (Entity n : l.getChunk().getEntities()) {
|
||||
if (n instanceof ArmorStand && l.distanceSquared(n.getLocation()) < 0.4) {
|
||||
if (n instanceof ArmorStand armorStand && l.distanceSquared(n.getLocation()) < 0.4) {
|
||||
String customName = n.getCustomName();
|
||||
|
||||
if (customName != null && customName.equals(nametag)) {
|
||||
return (ArmorStand) n;
|
||||
return armorStand;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -116,8 +116,8 @@ public class IgnitionChamber extends SlimefunItem {
|
||||
if (block.getType() == Material.DROPPER && BlockStorage.check(block) instanceof IgnitionChamber) {
|
||||
BlockState state = PaperLib.getBlockState(b.getRelative(face), false).getState();
|
||||
|
||||
if (state instanceof Dropper) {
|
||||
return ((Dropper) state).getInventory();
|
||||
if (state instanceof Dropper dropper) {
|
||||
return dropper.getInventory();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -83,8 +83,8 @@ public class OutputChest extends SlimefunItem {
|
||||
// Found the output chest! Now, let's check if we can fit the product in it.
|
||||
BlockState state = PaperLib.getBlockState(potentialOutput, false).getState();
|
||||
|
||||
if (state instanceof Chest) {
|
||||
Inventory inv = ((Chest) state).getInventory();
|
||||
if (state instanceof Chest chest) {
|
||||
Inventory inv = chest.getInventory();
|
||||
|
||||
// Check if the Item fits into that inventory.
|
||||
if (InvUtils.fits(inv, item)) {
|
||||
|
@ -43,10 +43,7 @@ public class Multimeter extends SimpleSlimefunItem<ItemUseHandler> {
|
||||
if (e.getClickedBlock().isPresent() && block.isPresent()) {
|
||||
SlimefunItem item = block.get();
|
||||
|
||||
if (item instanceof EnergyNetComponent) {
|
||||
EnergyNetComponent component = (EnergyNetComponent) item;
|
||||
|
||||
if (component.isChargeable()) {
|
||||
if (item instanceof EnergyNetComponent component && component.isChargeable()) {
|
||||
e.cancel();
|
||||
|
||||
Location l = e.getClickedBlock().get().getLocation();
|
||||
@ -59,7 +56,6 @@ public class Multimeter extends SimpleSlimefunItem<ItemUseHandler> {
|
||||
p.sendMessage("");
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
@ -67,8 +67,8 @@ public class SolarHelmet extends SlimefunItem {
|
||||
private void recharge(@Nullable ItemStack item) {
|
||||
SlimefunItem sfItem = SlimefunItem.getByItem(item);
|
||||
|
||||
if (sfItem instanceof Rechargeable) {
|
||||
((Rechargeable) sfItem).addItemCharge(item, charge.getValue().floatValue());
|
||||
if (sfItem instanceof Rechargeable rechargeable) {
|
||||
rechargeable.addItemCharge(item, charge.getValue().floatValue());
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -53,10 +53,10 @@ public class ChargingBench extends AContainer {
|
||||
private boolean charge(Block b, BlockMenu inv, int slot, ItemStack item) {
|
||||
SlimefunItem sfItem = SlimefunItem.getByItem(item);
|
||||
|
||||
if (sfItem instanceof Rechargeable) {
|
||||
if (sfItem instanceof Rechargeable rechargeable) {
|
||||
float charge = getEnergyConsumption() / 2F;
|
||||
|
||||
if (((Rechargeable) sfItem).addItemCharge(item, charge)) {
|
||||
if (rechargeable.addItemCharge(item, charge)) {
|
||||
removeCharge(b.getLocation(), getEnergyConsumption());
|
||||
} else if (inv.fits(item, getOutputSlots())) {
|
||||
inv.pushItem(item, getOutputSlots());
|
||||
|
@ -37,8 +37,8 @@ public class ElectricFurnace extends AContainer implements NotHopperable {
|
||||
for (FurnaceRecipe recipe : snapshot.getRecipes(FurnaceRecipe.class)) {
|
||||
RecipeChoice choice = recipe.getInputChoice();
|
||||
|
||||
if (choice instanceof MaterialChoice) {
|
||||
for (Material input : ((MaterialChoice) choice).getChoices()) {
|
||||
if (choice instanceof MaterialChoice materialChoice) {
|
||||
for (Material input : materialChoice.getChoices()) {
|
||||
registerRecipe(4, new ItemStack[] { new ItemStack(input) }, new ItemStack[] { recipe.getResult() });
|
||||
}
|
||||
}
|
||||
|
@ -227,16 +227,14 @@ public class FluidPump extends SimpleSlimefunItem<BlockTicker> implements Invent
|
||||
}
|
||||
|
||||
private @Nonnull ItemStack getFilledBucket(@Nonnull Block fluid) {
|
||||
switch (fluid.getType()) {
|
||||
case LAVA:
|
||||
return new ItemStack(Material.LAVA_BUCKET);
|
||||
case WATER:
|
||||
case BUBBLE_COLUMN:
|
||||
return new ItemStack(Material.WATER_BUCKET);
|
||||
default:
|
||||
return switch (fluid.getType()) {
|
||||
case LAVA -> new ItemStack(Material.LAVA_BUCKET);
|
||||
case WATER,
|
||||
BUBBLE_COLUMN -> new ItemStack(Material.WATER_BUCKET);
|
||||
default ->
|
||||
// Fallback for any new liquids
|
||||
return new ItemStack(Material.BUCKET);
|
||||
}
|
||||
new ItemStack(Material.BUCKET);
|
||||
};
|
||||
}
|
||||
|
||||
/**
|
||||
@ -251,9 +249,8 @@ public class FluidPump extends SimpleSlimefunItem<BlockTicker> implements Invent
|
||||
if (block.isLiquid()) {
|
||||
BlockData data = block.getBlockData();
|
||||
|
||||
if (data instanceof Levelled) {
|
||||
if (data instanceof Levelled levelled) {
|
||||
// Check if this is a full block.
|
||||
Levelled levelled = (Levelled) data;
|
||||
return levelled.getLevel() == 0;
|
||||
}
|
||||
}
|
||||
|
@ -62,7 +62,7 @@ public class AnimalGrowthAccelerator extends AbstractGrowthAccelerator {
|
||||
}
|
||||
|
||||
private boolean isReadyToGrow(Entity n) {
|
||||
return n instanceof Ageable && n.isValid() && !((Ageable) n).isAdult();
|
||||
return n instanceof Ageable ageable && n.isValid() && !ageable.isAdult();
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -128,9 +128,7 @@ public class AutoBreeder extends SlimefunItem implements InventoryBlock, EnergyN
|
||||
}
|
||||
|
||||
private boolean canBreed(@Nonnull Entity n) {
|
||||
if (n.isValid() && n instanceof Animals) {
|
||||
Animals animal = (Animals) n;
|
||||
|
||||
if (n.isValid() && n instanceof Animals animal) {
|
||||
return animal.isAdult() && animal.canBreed() && !animal.isLoveMode();
|
||||
}
|
||||
|
||||
|
@ -75,8 +75,8 @@ public class ProduceCollector extends AContainer implements RecipeDisplayItem {
|
||||
|
||||
// Mushroom Stew from Mooshrooms
|
||||
addProduce(new AnimalProduce(new ItemStack(Material.BOWL), new ItemStack(Material.MUSHROOM_STEW), n -> {
|
||||
if (n instanceof MushroomCow) {
|
||||
return ((MushroomCow) n).isAdult();
|
||||
if (n instanceof MushroomCow mushroomCow) {
|
||||
return mushroomCow.isAdult();
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
@ -158,8 +158,8 @@ public class ProduceCollector extends AContainer implements RecipeDisplayItem {
|
||||
|
||||
@ParametersAreNonnullByDefault
|
||||
private boolean isValidAnimal(Entity n, Predicate<LivingEntity> predicate) {
|
||||
if (n instanceof LivingEntity) {
|
||||
return predicate.test((LivingEntity) n);
|
||||
if (n instanceof LivingEntity livingEntity) {
|
||||
return predicate.test(livingEntity);
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
|
@ -44,8 +44,8 @@ public abstract class NetherStarReactor extends Reactor {
|
||||
public void extraTick(@Nonnull Location l) {
|
||||
Slimefun.runSync(() -> {
|
||||
for (Entity entity : l.getWorld().getNearbyEntities(l, 5, 5, 5, n -> n instanceof LivingEntity && n.isValid())) {
|
||||
if (entity instanceof LivingEntity) {
|
||||
((LivingEntity) entity).addPotionEffect(new PotionEffect(PotionEffectType.WITHER, 60, 1));
|
||||
if (entity instanceof LivingEntity livingEntity) {
|
||||
livingEntity.addPotionEffect(new PotionEffect(PotionEffectType.WITHER, 60, 1));
|
||||
}
|
||||
}
|
||||
});
|
||||
|
@ -49,8 +49,8 @@ public class Juice extends SimpleSlimefunItem<ItemConsumptionHandler> {
|
||||
|
||||
ItemMeta meta = item.getItemMeta();
|
||||
|
||||
if (meta instanceof PotionMeta) {
|
||||
effects = ((PotionMeta) meta).getCustomEffects();
|
||||
if (meta instanceof PotionMeta potionMeta) {
|
||||
effects = potionMeta.getCustomEffects();
|
||||
} else {
|
||||
effects = new ArrayList<>();
|
||||
}
|
||||
|
@ -107,8 +107,7 @@ public class InfusedHopper extends SimpleSlimefunItem<BlockTicker> {
|
||||
}
|
||||
|
||||
private boolean isValidItem(@Nonnull Location l, @Nonnull Entity entity) {
|
||||
if (entity instanceof Item && entity.isValid()) {
|
||||
Item item = (Item) entity;
|
||||
if (entity instanceof Item item && entity.isValid()) {
|
||||
// Check if the item cannot be picked up or has the "no pickup" metadata
|
||||
return item.getPickupDelay() <= 0 && !SlimefunUtils.hasNoPickupFlag(item) && item.getLocation().distanceSquared(l) > 0.25;
|
||||
}
|
||||
|
@ -61,12 +61,12 @@ public class MagicalZombiePills extends SimpleSlimefunItem<EntityInteractHandler
|
||||
|
||||
Player p = e.getPlayer();
|
||||
|
||||
if (entity instanceof ZombieVillager) {
|
||||
if (entity instanceof ZombieVillager zombieVillager) {
|
||||
useItem(p, item);
|
||||
healZombieVillager((ZombieVillager) entity, p);
|
||||
} else if (Slimefun.getMinecraftVersion().isAtLeast(MinecraftVersion.MINECRAFT_1_16) && entity instanceof PigZombie) {
|
||||
healZombieVillager(zombieVillager, p);
|
||||
} else if (Slimefun.getMinecraftVersion().isAtLeast(MinecraftVersion.MINECRAFT_1_16) && entity instanceof PigZombie pigZombie) {
|
||||
useItem(p, item);
|
||||
healZombifiedPiglin((PigZombie) entity);
|
||||
healZombifiedPiglin(pigZombie);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
@ -183,9 +183,7 @@ public class EnchantmentRune extends SimpleSlimefunItem<ItemDropHandler> {
|
||||
}
|
||||
|
||||
private boolean findCompatibleItem(@Nonnull Entity n) {
|
||||
if (n instanceof Item) {
|
||||
Item item = (Item) n;
|
||||
|
||||
if (n instanceof Item item) {
|
||||
return !isItem(item.getItemStack());
|
||||
}
|
||||
|
||||
|
@ -43,10 +43,8 @@ public class VillagerRune extends SimpleSlimefunItem<EntityInteractHandler> {
|
||||
return;
|
||||
}
|
||||
|
||||
if (e.getRightClicked() instanceof Villager) {
|
||||
Villager v = (Villager) e.getRightClicked();
|
||||
|
||||
if (v.getProfession() == Profession.NONE || v.getProfession() == Profession.NITWIT) {
|
||||
if (e.getRightClicked() instanceof Villager villager) {
|
||||
if (villager.getProfession() == Profession.NONE || villager.getProfession() == Profession.NITWIT) {
|
||||
return;
|
||||
}
|
||||
|
||||
@ -55,16 +53,16 @@ public class VillagerRune extends SimpleSlimefunItem<EntityInteractHandler> {
|
||||
}
|
||||
|
||||
// Reset Villager
|
||||
v.setVillagerExperience(0);
|
||||
v.setVillagerLevel(1);
|
||||
v.setProfession(Profession.NONE);
|
||||
villager.setVillagerExperience(0);
|
||||
villager.setVillagerLevel(1);
|
||||
villager.setProfession(Profession.NONE);
|
||||
e.setCancelled(true);
|
||||
|
||||
double offset = ThreadLocalRandom.current().nextDouble(0.5);
|
||||
|
||||
v.getWorld().playSound(v.getLocation(), Sound.ENTITY_VILLAGER_CELEBRATE, 1, 1.4F);
|
||||
v.getWorld().spawnParticle(Particle.CRIMSON_SPORE, v.getLocation(), 10, 0, offset / 2, 0, 0);
|
||||
v.getWorld().spawnParticle(Particle.ENCHANTMENT_TABLE, v.getLocation(), 5, 0.04, 1, 0.04);
|
||||
villager.getWorld().playSound(villager.getLocation(), Sound.ENTITY_VILLAGER_CELEBRATE, 1, 1.4F);
|
||||
villager.getWorld().spawnParticle(Particle.CRIMSON_SPORE, villager.getLocation(), 10, 0, offset / 2, 0, 0);
|
||||
villager.getWorld().spawnParticle(Particle.ENCHANTMENT_TABLE, villager.getLocation(), 5, 0.04, 1, 0.04);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
@ -162,12 +162,10 @@ public class Talisman extends SlimefunItem {
|
||||
|
||||
@ParametersAreNonnullByDefault
|
||||
public static boolean trigger(Event e, SlimefunItem item, boolean sendMessage) {
|
||||
if (!(item instanceof Talisman)) {
|
||||
if (!(item instanceof Talisman talisman)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
Talisman talisman = (Talisman) item;
|
||||
|
||||
if (ThreadLocalRandom.current().nextInt(100) > talisman.getChance()) {
|
||||
return false;
|
||||
}
|
||||
@ -239,8 +237,8 @@ public class Talisman extends SlimefunItem {
|
||||
|
||||
@ParametersAreNonnullByDefault
|
||||
private static void cancelEvent(Event e, Talisman talisman) {
|
||||
if (e instanceof Cancellable && talisman.isEventCancelled()) {
|
||||
((Cancellable) e).setCancelled(true);
|
||||
if (e instanceof Cancellable cancellable && talisman.isEventCancelled()) {
|
||||
cancellable.setCancelled(true);
|
||||
}
|
||||
}
|
||||
|
||||
@ -301,18 +299,18 @@ public class Talisman extends SlimefunItem {
|
||||
|
||||
@Nullable
|
||||
private static Player getPlayerByEventType(@Nonnull Event e) {
|
||||
if (e instanceof EntityDeathEvent) {
|
||||
return ((EntityDeathEvent) e).getEntity().getKiller();
|
||||
} else if (e instanceof BlockBreakEvent) {
|
||||
return ((BlockBreakEvent) e).getPlayer();
|
||||
} else if (e instanceof BlockDropItemEvent) {
|
||||
return ((BlockDropItemEvent) e).getPlayer();
|
||||
} else if (e instanceof PlayerEvent) {
|
||||
return ((PlayerEvent) e).getPlayer();
|
||||
} else if (e instanceof EntityEvent) {
|
||||
return (Player) ((EntityEvent) e).getEntity();
|
||||
} else if (e instanceof EnchantItemEvent) {
|
||||
return ((EnchantItemEvent) e).getEnchanter();
|
||||
if (e instanceof EntityDeathEvent entityDeathEvent) {
|
||||
return entityDeathEvent.getEntity().getKiller();
|
||||
} else if (e instanceof BlockBreakEvent blockBreakEvent) {
|
||||
return blockBreakEvent.getPlayer();
|
||||
} else if (e instanceof BlockDropItemEvent blockDropItemEvent) {
|
||||
return blockDropItemEvent.getPlayer();
|
||||
} else if (e instanceof PlayerEvent playerEvent) {
|
||||
return playerEvent.getPlayer();
|
||||
} else if (e instanceof EntityEvent entityEvent) {
|
||||
return (Player) entityEvent.getEntity();
|
||||
} else if (e instanceof EnchantItemEvent enchantItemEvent) {
|
||||
return enchantItemEvent.getEnchanter();
|
||||
}
|
||||
|
||||
return null;
|
||||
|
@ -70,10 +70,8 @@ public class StrangeNetherGoo extends SimpleSlimefunItem<ItemUseHandler> impleme
|
||||
|
||||
private EntityInteractHandler onRightClickEntity() {
|
||||
return (e, item, hand) -> {
|
||||
if (e.getRightClicked() instanceof Sheep) {
|
||||
Sheep s = (Sheep) e.getRightClicked();
|
||||
|
||||
if (s.getCustomName() != null) {
|
||||
if (e.getRightClicked() instanceof Sheep sheep) {
|
||||
if (sheep.getCustomName() != null) {
|
||||
e.setCancelled(true);
|
||||
return;
|
||||
}
|
||||
@ -83,9 +81,9 @@ public class StrangeNetherGoo extends SimpleSlimefunItem<ItemUseHandler> impleme
|
||||
}
|
||||
|
||||
// Give Sheep color, name and effect
|
||||
s.addPotionEffect(new PotionEffect(PotionEffectType.POISON, 60, 2));
|
||||
s.setColor(DyeColor.PURPLE);
|
||||
s.setCustomName(ChatColor.DARK_PURPLE + "Tainted Sheep");
|
||||
sheep.addPotionEffect(new PotionEffect(PotionEffectType.POISON, 60, 2));
|
||||
sheep.setColor(DyeColor.PURPLE);
|
||||
sheep.setCustomName(ChatColor.DARK_PURPLE + "Tainted Sheep");
|
||||
e.setCancelled(true);
|
||||
|
||||
}
|
||||
|
@ -38,12 +38,11 @@ abstract class AbstractSmeltery extends MultiBlockMachine {
|
||||
|
||||
@Override
|
||||
public void onInteract(Player p, Block b) {
|
||||
Block dispBlock = b.getRelative(BlockFace.DOWN);
|
||||
BlockState state = PaperLib.getBlockState(dispBlock, false).getState();
|
||||
Block possibleDispenser = b.getRelative(BlockFace.DOWN);
|
||||
BlockState state = PaperLib.getBlockState(possibleDispenser, false).getState();
|
||||
|
||||
if (state instanceof Dispenser) {
|
||||
Dispenser disp = (Dispenser) state;
|
||||
Inventory inv = disp.getInventory();
|
||||
if (state instanceof Dispenser dispenser) {
|
||||
Inventory inv = dispenser.getInventory();
|
||||
List<ItemStack[]> inputs = RecipeType.getRecipeInputList(this);
|
||||
|
||||
for (int i = 0; i < inputs.size(); i++) {
|
||||
@ -51,7 +50,7 @@ abstract class AbstractSmeltery extends MultiBlockMachine {
|
||||
ItemStack output = RecipeType.getRecipeOutputList(this, inputs.get(i)).clone();
|
||||
|
||||
if (SlimefunUtils.canPlayerUseItem(p, output, true)) {
|
||||
Inventory outputInv = findOutputInventory(output, dispBlock, inv);
|
||||
Inventory outputInv = findOutputInventory(output, possibleDispenser, inv);
|
||||
|
||||
if (outputInv != null) {
|
||||
craft(p, b, inv, inputs.get(i), output, outputInv);
|
||||
|
@ -31,12 +31,11 @@ public class ArmorForge extends AbstractCraftingTable {
|
||||
|
||||
@Override
|
||||
public void onInteract(Player p, Block b) {
|
||||
Block dispenser = b.getRelative(BlockFace.DOWN);
|
||||
BlockState state = PaperLib.getBlockState(dispenser, false).getState();
|
||||
Block possibleDispenser = b.getRelative(BlockFace.DOWN);
|
||||
BlockState state = PaperLib.getBlockState(possibleDispenser, false).getState();
|
||||
|
||||
if (state instanceof Dispenser) {
|
||||
Dispenser disp = (Dispenser) state;
|
||||
Inventory inv = disp.getInventory();
|
||||
if (state instanceof Dispenser dispenser) {
|
||||
Inventory inv = dispenser.getInventory();
|
||||
List<ItemStack[]> inputs = RecipeType.getRecipeInputList(this);
|
||||
|
||||
for (int i = 0; i < inputs.size(); i++) {
|
||||
@ -44,7 +43,7 @@ public class ArmorForge extends AbstractCraftingTable {
|
||||
ItemStack output = RecipeType.getRecipeOutputList(this, inputs.get(i)).clone();
|
||||
|
||||
if (SlimefunUtils.canPlayerUseItem(p, output, true)) {
|
||||
craft(p, output, inv, dispenser);
|
||||
craft(p, output, inv, possibleDispenser);
|
||||
}
|
||||
|
||||
return;
|
||||
|
@ -57,9 +57,8 @@ public class Compressor extends MultiBlockMachine {
|
||||
Block dispBlock = b.getRelative(BlockFace.DOWN);
|
||||
BlockState state = PaperLib.getBlockState(dispBlock, false).getState();
|
||||
|
||||
if (state instanceof Dispenser) {
|
||||
Dispenser disp = (Dispenser) state;
|
||||
Inventory inv = disp.getInventory();
|
||||
if (state instanceof Dispenser dispenser) {
|
||||
Inventory inv = dispenser.getInventory();
|
||||
|
||||
for (ItemStack item : inv.getContents()) {
|
||||
for (ItemStack recipeInput : RecipeType.getRecipeInputs(this)) {
|
||||
|
@ -33,12 +33,11 @@ public class EnhancedCraftingTable extends AbstractCraftingTable {
|
||||
|
||||
@Override
|
||||
public void onInteract(Player p, Block b) {
|
||||
Block dispenser = b.getRelative(BlockFace.DOWN);
|
||||
BlockState state = PaperLib.getBlockState(dispenser, false).getState();
|
||||
Block possibleDispenser = b.getRelative(BlockFace.DOWN);
|
||||
BlockState state = PaperLib.getBlockState(possibleDispenser, false).getState();
|
||||
|
||||
if (state instanceof Dispenser) {
|
||||
Dispenser disp = (Dispenser) state;
|
||||
Inventory inv = disp.getInventory();
|
||||
if (state instanceof Dispenser dispenser) {
|
||||
Inventory inv = dispenser.getInventory();
|
||||
List<ItemStack[]> inputs = RecipeType.getRecipeInputList(this);
|
||||
|
||||
for (int i = 0; i < inputs.size(); i++) {
|
||||
@ -46,7 +45,7 @@ public class EnhancedCraftingTable extends AbstractCraftingTable {
|
||||
ItemStack output = RecipeType.getRecipeOutputList(this, inputs.get(i)).clone();
|
||||
|
||||
if (SlimefunUtils.canPlayerUseItem(p, output, true)) {
|
||||
craft(inv, dispenser, p, b, output);
|
||||
craft(inv, possibleDispenser, p, b, output);
|
||||
}
|
||||
|
||||
return;
|
||||
@ -68,8 +67,8 @@ public class EnhancedCraftingTable extends AbstractCraftingTable {
|
||||
if (outputInv != null) {
|
||||
SlimefunItem sfItem = SlimefunItem.getByItem(output);
|
||||
|
||||
if (sfItem instanceof SlimefunBackpack) {
|
||||
upgradeBackpack(p, inv, (SlimefunBackpack) sfItem, output);
|
||||
if (sfItem instanceof SlimefunBackpack backpack) {
|
||||
upgradeBackpack(p, inv, backpack, output);
|
||||
}
|
||||
|
||||
for (int j = 0; j < 9; j++) {
|
||||
|
@ -106,18 +106,17 @@ public class GrindStone extends MultiBlockMachine {
|
||||
|
||||
@Override
|
||||
public void onInteract(Player p, Block b) {
|
||||
Block dispBlock = b.getRelative(BlockFace.DOWN);
|
||||
BlockState state = PaperLib.getBlockState(dispBlock, false).getState();
|
||||
Block possibleDispenser = b.getRelative(BlockFace.DOWN);
|
||||
BlockState state = PaperLib.getBlockState(possibleDispenser, false).getState();
|
||||
|
||||
if (state instanceof Dispenser) {
|
||||
Dispenser disp = (Dispenser) state;
|
||||
Inventory inv = disp.getInventory();
|
||||
if (state instanceof Dispenser dispenser) {
|
||||
Inventory inv = dispenser.getInventory();
|
||||
|
||||
for (ItemStack current : inv.getContents()) {
|
||||
for (ItemStack convert : RecipeType.getRecipeInputs(this)) {
|
||||
if (convert != null && SlimefunUtils.isItemSimilar(current, convert, true)) {
|
||||
ItemStack output = RecipeType.getRecipeOutput(this, convert);
|
||||
Inventory outputInv = findOutputInventory(output, dispBlock, inv);
|
||||
Inventory outputInv = findOutputInventory(output, possibleDispenser, inv);
|
||||
|
||||
if (outputInv != null) {
|
||||
ItemStack removing = current.clone();
|
||||
|
@ -50,18 +50,17 @@ public class Juicer extends MultiBlockMachine {
|
||||
|
||||
@Override
|
||||
public void onInteract(Player p, Block b) {
|
||||
Block dispBlock = b.getRelative(BlockFace.DOWN);
|
||||
BlockState state = PaperLib.getBlockState(dispBlock, false).getState();
|
||||
Block possibleDispenser = b.getRelative(BlockFace.DOWN);
|
||||
BlockState state = PaperLib.getBlockState(possibleDispenser, false).getState();
|
||||
|
||||
if (state instanceof Dispenser) {
|
||||
Dispenser disp = (Dispenser) state;
|
||||
Inventory inv = disp.getInventory();
|
||||
if (state instanceof Dispenser dispenser) {
|
||||
Inventory inv = dispenser.getInventory();
|
||||
|
||||
for (ItemStack current : inv.getContents()) {
|
||||
for (ItemStack convert : RecipeType.getRecipeInputs(this)) {
|
||||
if (convert != null && SlimefunUtils.isItemSimilar(current, convert, true)) {
|
||||
ItemStack adding = RecipeType.getRecipeOutput(this, convert);
|
||||
Inventory outputInv = findOutputInventory(adding, dispBlock, inv);
|
||||
Inventory outputInv = findOutputInventory(adding, possibleDispenser, inv);
|
||||
|
||||
if (outputInv != null) {
|
||||
ItemStack removing = current.clone();
|
||||
|
@ -34,18 +34,17 @@ public class MagicWorkbench extends AbstractCraftingTable {
|
||||
|
||||
@Override
|
||||
public void onInteract(Player p, Block b) {
|
||||
Block dispenser = locateDispenser(b);
|
||||
Block possibleDispener = locateDispenser(b);
|
||||
|
||||
if (dispenser == null) {
|
||||
if (possibleDispener == null) {
|
||||
// How even...
|
||||
return;
|
||||
}
|
||||
|
||||
BlockState state = PaperLib.getBlockState(dispenser, false).getState();
|
||||
BlockState state = PaperLib.getBlockState(possibleDispener, false).getState();
|
||||
|
||||
if (state instanceof Dispenser) {
|
||||
Dispenser disp = (Dispenser) state;
|
||||
Inventory inv = disp.getInventory();
|
||||
if (state instanceof Dispenser dispenser) {
|
||||
Inventory inv = dispenser.getInventory();
|
||||
List<ItemStack[]> inputs = RecipeType.getRecipeInputList(this);
|
||||
|
||||
for (int i = 0; i < inputs.size(); i++) {
|
||||
@ -53,7 +52,7 @@ public class MagicWorkbench extends AbstractCraftingTable {
|
||||
ItemStack output = RecipeType.getRecipeOutputList(this, inputs.get(i)).clone();
|
||||
|
||||
if (SlimefunUtils.canPlayerUseItem(p, output, true)) {
|
||||
craft(inv, dispenser, p, b, output);
|
||||
craft(inv, possibleDispener, p, b, output);
|
||||
}
|
||||
|
||||
return;
|
||||
@ -76,8 +75,8 @@ public class MagicWorkbench extends AbstractCraftingTable {
|
||||
if (outputInv != null) {
|
||||
SlimefunItem sfItem = SlimefunItem.getByItem(output);
|
||||
|
||||
if (sfItem instanceof SlimefunBackpack) {
|
||||
upgradeBackpack(p, inv, (SlimefunBackpack) sfItem, output);
|
||||
if (sfItem instanceof SlimefunBackpack backpack) {
|
||||
upgradeBackpack(p, inv, backpack, output);
|
||||
}
|
||||
|
||||
for (int j = 0; j < 9; j++) {
|
||||
|
@ -173,18 +173,17 @@ public class OreCrusher extends MultiBlockMachine {
|
||||
|
||||
@Override
|
||||
public void onInteract(Player p, Block b) {
|
||||
Block dispBlock = b.getRelative(BlockFace.DOWN);
|
||||
BlockState state = PaperLib.getBlockState(dispBlock, false).getState();
|
||||
Block possibleDispenser = b.getRelative(BlockFace.DOWN);
|
||||
BlockState state = PaperLib.getBlockState(possibleDispenser, false).getState();
|
||||
|
||||
if (state instanceof Dispenser) {
|
||||
Dispenser disp = (Dispenser) state;
|
||||
Inventory inv = disp.getInventory();
|
||||
if (state instanceof Dispenser dispenser) {
|
||||
Inventory inv = dispenser.getInventory();
|
||||
|
||||
for (ItemStack current : inv.getContents()) {
|
||||
for (ItemStack convert : RecipeType.getRecipeInputs(this)) {
|
||||
if (convert != null && SlimefunUtils.isItemSimilar(current, convert, true)) {
|
||||
ItemStack adding = RecipeType.getRecipeOutput(this, convert);
|
||||
Inventory outputInv = findOutputInventory(adding, dispBlock, inv);
|
||||
Inventory outputInv = findOutputInventory(adding, possibleDispenser, inv);
|
||||
|
||||
if (SlimefunUtils.canPlayerUseItem(p, adding, true)) {
|
||||
if (outputInv != null) {
|
||||
|
@ -39,25 +39,24 @@ public class PressureChamber extends MultiBlockMachine {
|
||||
|
||||
@Override
|
||||
public void onInteract(Player p, Block b) {
|
||||
Block dispBlock = b.getRelative(BlockFace.UP).getRelative(BlockFace.UP);
|
||||
BlockState state = PaperLib.getBlockState(dispBlock, false).getState();
|
||||
Block possibleDispenser = b.getRelative(BlockFace.UP).getRelative(BlockFace.UP);
|
||||
BlockState state = PaperLib.getBlockState(possibleDispenser, false).getState();
|
||||
|
||||
if (state instanceof Dispenser) {
|
||||
Dispenser disp = (Dispenser) state;
|
||||
Inventory inv = disp.getInventory();
|
||||
if (state instanceof Dispenser dispenser) {
|
||||
Inventory inv = dispenser.getInventory();
|
||||
|
||||
for (ItemStack current : inv.getContents()) {
|
||||
for (ItemStack convert : RecipeType.getRecipeInputs(this)) {
|
||||
if (convert != null && SlimefunUtils.isItemSimilar(current, convert, true)) {
|
||||
ItemStack output = RecipeType.getRecipeOutput(this, convert);
|
||||
Inventory outputInv = findOutputInventory(output, dispBlock, inv);
|
||||
Inventory outputInv = findOutputInventory(output, possibleDispenser, inv);
|
||||
|
||||
if (outputInv != null) {
|
||||
ItemStack removing = current.clone();
|
||||
removing.setAmount(convert.getAmount());
|
||||
inv.removeItem(removing);
|
||||
|
||||
craft(p, b, output, inv, dispBlock);
|
||||
craft(p, b, output, inv, possibleDispenser);
|
||||
} else {
|
||||
Slimefun.getLocalization().sendMessage(p, "machines.full-inventory", true);
|
||||
}
|
||||
|
@ -143,7 +143,6 @@ class MiningTask implements Runnable {
|
||||
if (fuelLevel <= 0) {
|
||||
// This Miner has not enough fuel.
|
||||
stop(MinerStoppingReason.NO_FUEL);
|
||||
return;
|
||||
}
|
||||
});
|
||||
|
||||
@ -268,8 +267,8 @@ class MiningTask implements Runnable {
|
||||
if (chest.getType() == Material.CHEST) {
|
||||
BlockState state = PaperLib.getBlockState(chest, false).getState();
|
||||
|
||||
if (state instanceof Chest) {
|
||||
Inventory inv = ((Chest) state).getBlockInventory();
|
||||
if (state instanceof Chest chestState) {
|
||||
Inventory inv = chestState.getBlockInventory();
|
||||
|
||||
if (InvUtils.fits(inv, item)) {
|
||||
inv.addItem(item);
|
||||
@ -299,8 +298,8 @@ class MiningTask implements Runnable {
|
||||
if (chest.getType() == Material.CHEST) {
|
||||
BlockState state = PaperLib.getBlockState(chest, false).getState();
|
||||
|
||||
if (state instanceof Chest) {
|
||||
Inventory inv = ((Chest) state).getBlockInventory();
|
||||
if (state instanceof Chest chestState) {
|
||||
Inventory inv = chestState.getBlockInventory();
|
||||
this.fuelLevel = grabFuelFrom(inv);
|
||||
}
|
||||
}
|
||||
|
@ -19,26 +19,17 @@ class OreDictionary14 implements OreDictionary {
|
||||
@Override
|
||||
@ParametersAreNonnullByDefault
|
||||
public @Nonnull ItemStack getDrops(Material material, Random random) {
|
||||
switch (material) {
|
||||
case COAL_ORE:
|
||||
return new ItemStack(Material.COAL);
|
||||
case DIAMOND_ORE:
|
||||
return new ItemStack(Material.DIAMOND);
|
||||
case EMERALD_ORE:
|
||||
return new ItemStack(Material.EMERALD);
|
||||
case REDSTONE_ORE:
|
||||
return new ItemStack(Material.REDSTONE, 4 + random.nextInt(2));
|
||||
case LAPIS_ORE:
|
||||
return new ItemStack(Material.LAPIS_LAZULI, 4 + random.nextInt(4));
|
||||
case NETHER_QUARTZ_ORE:
|
||||
return new ItemStack(Material.QUARTZ);
|
||||
case IRON_ORE:
|
||||
return new ItemStack(Material.IRON_ORE);
|
||||
case GOLD_ORE:
|
||||
return new ItemStack(Material.GOLD_ORE);
|
||||
default:
|
||||
return new ItemStack(material);
|
||||
}
|
||||
return switch (material) {
|
||||
case COAL_ORE -> new ItemStack(Material.COAL);
|
||||
case DIAMOND_ORE -> new ItemStack(Material.DIAMOND);
|
||||
case EMERALD_ORE -> new ItemStack(Material.EMERALD);
|
||||
case REDSTONE_ORE -> new ItemStack(Material.REDSTONE, 4 + random.nextInt(2));
|
||||
case LAPIS_ORE -> new ItemStack(Material.LAPIS_LAZULI, 4 + random.nextInt(4));
|
||||
case NETHER_QUARTZ_ORE -> new ItemStack(Material.QUARTZ);
|
||||
case IRON_ORE -> new ItemStack(Material.IRON_ORE);
|
||||
case GOLD_ORE -> new ItemStack(Material.GOLD_ORE);
|
||||
default -> new ItemStack(material);
|
||||
};
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -19,15 +19,12 @@ class OreDictionary16 extends OreDictionary14 {
|
||||
@Override
|
||||
@ParametersAreNonnullByDefault
|
||||
public @Nonnull ItemStack getDrops(Material material, Random random) {
|
||||
switch (material) {
|
||||
case NETHER_GOLD_ORE:
|
||||
return switch (material) {
|
||||
// In 1.16, breaking nether gold ores should get gold nuggets
|
||||
return new ItemStack(Material.GOLD_NUGGET, 2 + random.nextInt(4));
|
||||
case ANCIENT_DEBRIS:
|
||||
return new ItemStack(Material.ANCIENT_DEBRIS);
|
||||
default:
|
||||
return super.getDrops(material, random);
|
||||
}
|
||||
case NETHER_GOLD_ORE -> new ItemStack(Material.GOLD_NUGGET, 2 + random.nextInt(4));
|
||||
case ANCIENT_DEBRIS -> new ItemStack(Material.ANCIENT_DEBRIS);
|
||||
default -> super.getDrops(material, random);
|
||||
};
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -19,34 +19,25 @@ class OreDictionary17 extends OreDictionary16 {
|
||||
@ParametersAreNonnullByDefault
|
||||
public ItemStack getDrops(Material material, Random random) {
|
||||
// In 1.17, breaking metal ores should get raw metals. Also support deepslate ores.
|
||||
switch (material) {
|
||||
case COAL_ORE:
|
||||
case DEEPSLATE_COAL_ORE:
|
||||
return new ItemStack(Material.COAL);
|
||||
case DIAMOND_ORE:
|
||||
case DEEPSLATE_DIAMOND_ORE:
|
||||
return new ItemStack(Material.DIAMOND);
|
||||
case EMERALD_ORE:
|
||||
case DEEPSLATE_EMERALD_ORE:
|
||||
return new ItemStack(Material.EMERALD);
|
||||
case REDSTONE_ORE:
|
||||
case DEEPSLATE_REDSTONE_ORE:
|
||||
return new ItemStack(Material.REDSTONE, 4 + random.nextInt(2));
|
||||
case LAPIS_ORE:
|
||||
case DEEPSLATE_LAPIS_ORE:
|
||||
return new ItemStack(Material.LAPIS_LAZULI, 4 + random.nextInt(4));
|
||||
case COPPER_ORE:
|
||||
case DEEPSLATE_COPPER_ORE:
|
||||
return new ItemStack(Material.RAW_COPPER);
|
||||
case IRON_ORE:
|
||||
case DEEPSLATE_IRON_ORE:
|
||||
return new ItemStack(Material.RAW_IRON);
|
||||
case GOLD_ORE:
|
||||
case DEEPSLATE_GOLD_ORE:
|
||||
return new ItemStack(Material.RAW_GOLD);
|
||||
default:
|
||||
return super.getDrops(material, random);
|
||||
}
|
||||
return switch (material) {
|
||||
case COAL_ORE,
|
||||
DEEPSLATE_COAL_ORE -> new ItemStack(Material.COAL);
|
||||
case DIAMOND_ORE,
|
||||
DEEPSLATE_DIAMOND_ORE -> new ItemStack(Material.DIAMOND);
|
||||
case EMERALD_ORE,
|
||||
DEEPSLATE_EMERALD_ORE -> new ItemStack(Material.EMERALD);
|
||||
case REDSTONE_ORE,
|
||||
DEEPSLATE_REDSTONE_ORE -> new ItemStack(Material.REDSTONE, 4 + random.nextInt(2));
|
||||
case LAPIS_ORE,
|
||||
DEEPSLATE_LAPIS_ORE -> new ItemStack(Material.LAPIS_LAZULI, 4 + random.nextInt(4));
|
||||
case COPPER_ORE,
|
||||
DEEPSLATE_COPPER_ORE -> new ItemStack(Material.RAW_COPPER);
|
||||
case IRON_ORE,
|
||||
DEEPSLATE_IRON_ORE -> new ItemStack(Material.RAW_IRON);
|
||||
case GOLD_ORE,
|
||||
DEEPSLATE_GOLD_ORE -> new ItemStack(Material.RAW_GOLD);
|
||||
default -> super.getDrops(material, random);
|
||||
};
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -61,9 +61,9 @@ public class PickaxeOfContainment extends SimpleSlimefunItem<ToolUseHandler> {
|
||||
private @Nonnull ItemStack breakSpawner(@Nonnull Block b) {
|
||||
AbstractMonsterSpawner spawner;
|
||||
|
||||
/**
|
||||
* If the spawner's BlockStorage has BlockInfo, then it's not a vanilla spawner
|
||||
* and should not give a broken spawner but a repaired one instead.
|
||||
/*
|
||||
If the spawner's BlockStorage has BlockInfo, then it's not a vanilla spawner
|
||||
and should not give a broken spawner but a repaired one instead.
|
||||
*/
|
||||
if (BlockStorage.hasBlockInfo(b)) {
|
||||
spawner = (AbstractMonsterSpawner) SlimefunItems.REPAIRED_SPAWNER.getItem();
|
||||
@ -73,8 +73,8 @@ public class PickaxeOfContainment extends SimpleSlimefunItem<ToolUseHandler> {
|
||||
|
||||
BlockState state = PaperLib.getBlockState(b, false).getState();
|
||||
|
||||
if (state instanceof CreatureSpawner) {
|
||||
EntityType entityType = ((CreatureSpawner) state).getSpawnedType();
|
||||
if (state instanceof CreatureSpawner creatureSpawner) {
|
||||
EntityType entityType = creatureSpawner.getSpawnedType();
|
||||
return spawner.getItemForEntityType(entityType);
|
||||
}
|
||||
|
||||
|
@ -36,16 +36,14 @@ public class IcyBow extends SlimefunBow {
|
||||
@Override
|
||||
public BowShootHandler onShoot() {
|
||||
return (e, n) -> {
|
||||
if (n instanceof Player) {
|
||||
Player p = (Player) n;
|
||||
|
||||
if (n instanceof Player player) {
|
||||
// Fixes #3060 - Don't apply effects if the arrow was successfully blocked.
|
||||
if (p.isBlocking() && e.getFinalDamage() <= 0) {
|
||||
if (player.isBlocking() && e.getFinalDamage() <= 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (Slimefun.getMinecraftVersion().isAtLeast(MinecraftVersion.MINECRAFT_1_17)) {
|
||||
p.setFreezeTicks(60);
|
||||
player.setFreezeTicks(60);
|
||||
}
|
||||
}
|
||||
n.getWorld().playEffect(n.getLocation(), Effect.STEP_SOUND, Material.ICE);
|
||||
|
@ -57,7 +57,7 @@ public class AutoCrafterListener implements Listener {
|
||||
|
||||
SlimefunItem block = slimefunBlock.get();
|
||||
|
||||
if (block instanceof AbstractAutoCrafter) {
|
||||
if (block instanceof AbstractAutoCrafter crafter) {
|
||||
Optional<SlimefunItem> slimefunItem = e.getSlimefunItem();
|
||||
|
||||
if (!e.getPlayer().isSneaking() && slimefunItem.isPresent() && slimefunItem.get() instanceof Multimeter) {
|
||||
@ -80,8 +80,6 @@ public class AutoCrafterListener implements Listener {
|
||||
}
|
||||
|
||||
// Fixes 2896 - Forward the interaction before items get handled.
|
||||
AbstractAutoCrafter crafter = (AbstractAutoCrafter) block;
|
||||
|
||||
try {
|
||||
crafter.onRightClick(clickedBlock.get(), e.getPlayer());
|
||||
} catch (Exception | LinkageError x) {
|
||||
@ -94,7 +92,7 @@ public class AutoCrafterListener implements Listener {
|
||||
@ParametersAreNonnullByDefault
|
||||
private boolean hasUnlockedRecipe(Player p, ItemStack item) {
|
||||
for (Recipe recipe : Slimefun.getMinecraftRecipeService().getRecipesFor(item)) {
|
||||
if (recipe instanceof Keyed && !p.hasDiscoveredRecipe(((Keyed) recipe).getKey())) {
|
||||
if (recipe instanceof Keyed keyed && !p.hasDiscoveredRecipe(keyed.getKey())) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
@ -94,12 +94,12 @@ public class BackpackListener implements Listener {
|
||||
if (item != null) {
|
||||
SlimefunItem backpack = SlimefunItem.getByItem(item);
|
||||
|
||||
if (backpack instanceof SlimefunBackpack) {
|
||||
if (backpack instanceof SlimefunBackpack slimefunBackpack) {
|
||||
if (e.getClick() == ClickType.NUMBER_KEY) {
|
||||
if (e.getClickedInventory().getType() != InventoryType.PLAYER) {
|
||||
ItemStack hotbarItem = e.getWhoClicked().getInventory().getItem(e.getHotbarButton());
|
||||
|
||||
if (!isAllowed((SlimefunBackpack) backpack, hotbarItem)) {
|
||||
if (!isAllowed(slimefunBackpack, hotbarItem)) {
|
||||
e.setCancelled(true);
|
||||
}
|
||||
}
|
||||
@ -107,10 +107,10 @@ public class BackpackListener implements Listener {
|
||||
// Fixes #3265
|
||||
ItemStack offHandItem = e.getWhoClicked().getInventory().getItemInOffHand();
|
||||
|
||||
if (!isAllowed((SlimefunBackpack) backpack, offHandItem)) {
|
||||
if (!isAllowed(slimefunBackpack, offHandItem)) {
|
||||
e.setCancelled(true);
|
||||
}
|
||||
} else if (!isAllowed((SlimefunBackpack) backpack, e.getCurrentItem())) {
|
||||
} else if (!isAllowed(slimefunBackpack, e.getCurrentItem())) {
|
||||
e.setCancelled(true);
|
||||
}
|
||||
}
|
||||
|
@ -49,8 +49,8 @@ public class ButcherAndroidListener implements Listener {
|
||||
|
||||
// Collect any nearby dropped items
|
||||
for (Entity n : e.getEntity().getNearbyEntities(0.5D, 0.5D, 0.5D)) {
|
||||
if (n instanceof Item && n.isValid() && !SlimefunUtils.hasNoPickupFlag((Item) n)) {
|
||||
items.add(((Item) n).getItemStack());
|
||||
if (n instanceof Item item && n.isValid() && !SlimefunUtils.hasNoPickupFlag(item)) {
|
||||
items.add(item.getItemStack());
|
||||
n.remove();
|
||||
}
|
||||
}
|
||||
|
@ -1,6 +1,7 @@
|
||||
package io.github.thebusybiscuit.slimefun4.implementation.listeners;
|
||||
|
||||
import javax.annotation.Nonnull;
|
||||
import javax.annotation.ParametersAreNonnullByDefault;
|
||||
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.Sound;
|
||||
@ -40,7 +41,8 @@ public class CoolerListener implements Listener {
|
||||
private final Slimefun plugin;
|
||||
private final Cooler cooler;
|
||||
|
||||
public CoolerListener(@Nonnull Slimefun plugin, @Nonnull Cooler cooler) {
|
||||
@ParametersAreNonnullByDefault
|
||||
public CoolerListener(Slimefun plugin, Cooler cooler) {
|
||||
plugin.getServer().getPluginManager().registerEvents(this, plugin);
|
||||
|
||||
this.plugin = plugin;
|
||||
@ -49,19 +51,15 @@ public class CoolerListener implements Listener {
|
||||
|
||||
@EventHandler
|
||||
public void onHungerLoss(FoodLevelChangeEvent e) {
|
||||
if (e.getEntity() instanceof Player) {
|
||||
Player p = (Player) e.getEntity();
|
||||
|
||||
if (e.getFoodLevel() < p.getFoodLevel()) {
|
||||
checkAndConsume(p);
|
||||
}
|
||||
if (e.getEntity() instanceof Player player && e.getFoodLevel() < player.getFoodLevel()) {
|
||||
checkAndConsume(player);
|
||||
}
|
||||
}
|
||||
|
||||
@EventHandler
|
||||
public void onHungerDamage(EntityDamageEvent e) {
|
||||
if (e.getEntity() instanceof Player && e.getCause() == DamageCause.STARVATION) {
|
||||
checkAndConsume((Player) e.getEntity());
|
||||
if (e.getEntity() instanceof Player player && e.getCause() == DamageCause.STARVATION) {
|
||||
checkAndConsume(player);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -168,8 +168,7 @@ public class DebugFishListener implements Listener {
|
||||
p.sendMessage(ChatColors.color(" &dChunk Timings: &e" + Slimefun.getProfiler().getTime(b.getChunk())));
|
||||
}
|
||||
|
||||
if (item instanceof EnergyNetComponent) {
|
||||
EnergyNetComponent component = (EnergyNetComponent) item;
|
||||
if (item instanceof EnergyNetComponent component) {
|
||||
p.sendMessage(ChatColors.color("&dEnergyNet Component"));
|
||||
p.sendMessage(ChatColors.color(" &dType: &e" + component.getEnergyComponentType()));
|
||||
|
||||
|
@ -46,8 +46,7 @@ public class DispenserListener implements Listener {
|
||||
machine.callItemHandler(BlockDispenseHandler.class, handler -> {
|
||||
BlockState state = PaperLib.getBlockState(b, false).getState();
|
||||
|
||||
if (state instanceof Dispenser) {
|
||||
Dispenser dispenser = (Dispenser) state;
|
||||
if (state instanceof Dispenser dispenser) {
|
||||
BlockFace face = ((Directional) b.getBlockData()).getFacing();
|
||||
Block block = b.getRelative(face);
|
||||
handler.onBlockDispense(e, dispenser, block, machine);
|
||||
|
@ -60,8 +60,8 @@ public class ElytraImpactListener implements Listener {
|
||||
e.setDamage(0);
|
||||
p.playSound(p.getLocation(), Sound.BLOCK_STONE_HIT, 20, 1);
|
||||
|
||||
if (item instanceof DamageableItem) {
|
||||
((DamageableItem) item).damageItem(p, p.getInventory().getHelmet());
|
||||
if (item instanceof DamageableItem damageableItem) {
|
||||
damageableItem.damageItem(p, p.getInventory().getHelmet());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -47,9 +47,9 @@ public class EnhancedFurnaceListener implements Listener {
|
||||
|
||||
SlimefunItem furnace = BlockStorage.check(e.getBlock());
|
||||
|
||||
if (furnace instanceof EnhancedFurnace && ((EnhancedFurnace) furnace).getFuelEfficiency() > 0) {
|
||||
if (furnace instanceof EnhancedFurnace enhancedFurnace && enhancedFurnace.getFuelEfficiency() > 0) {
|
||||
int burnTime = e.getBurnTime();
|
||||
int newBurnTime = ((EnhancedFurnace) furnace).getFuelEfficiency() * burnTime;
|
||||
int newBurnTime = enhancedFurnace.getFuelEfficiency() * burnTime;
|
||||
|
||||
e.setBurnTime(Math.min(newBurnTime, Short.MAX_VALUE - 1));
|
||||
}
|
||||
@ -64,14 +64,14 @@ public class EnhancedFurnaceListener implements Listener {
|
||||
|
||||
SlimefunItem sfItem = BlockStorage.check(e.getBlock());
|
||||
|
||||
if (sfItem instanceof EnhancedFurnace) {
|
||||
if (sfItem instanceof EnhancedFurnace enhancedFurnace) {
|
||||
BlockState state = PaperLib.getBlockState(e.getBlock(), false).getState();
|
||||
|
||||
if (state instanceof Furnace) {
|
||||
FurnaceInventory inventory = ((Furnace) state).getInventory();
|
||||
if (state instanceof Furnace furnace) {
|
||||
FurnaceInventory inventory = furnace.getInventory();
|
||||
|
||||
boolean multiplier = SlimefunTag.ENHANCED_FURNACE_LUCK_MATERIALS.isTagged(inventory.getSmelting().getType());
|
||||
int amount = multiplier ? ((EnhancedFurnace) sfItem).getRandomOutputAmount() : 1;
|
||||
int amount = multiplier ? enhancedFurnace.getRandomOutputAmount() : 1;
|
||||
Optional<ItemStack> result = Slimefun.getMinecraftRecipeService().getFurnaceOutput(inventory.getSmelting());
|
||||
|
||||
if (result.isPresent()) {
|
||||
|
@ -70,8 +70,8 @@ public class GadgetsListener implements Listener {
|
||||
return;
|
||||
}
|
||||
|
||||
if (chestplate instanceof Jetpack) {
|
||||
double thrust = ((Jetpack) chestplate).getThrust();
|
||||
if (chestplate instanceof Jetpack jetpack) {
|
||||
double thrust = jetpack.getThrust();
|
||||
|
||||
if (thrust > 0.2) {
|
||||
new JetpackTask(p, (Jetpack) chestplate).scheduleRepeating(0, 3);
|
||||
@ -82,8 +82,8 @@ public class GadgetsListener implements Listener {
|
||||
}
|
||||
|
||||
private void handleBoots(@Nonnull Player p, @Nullable SlimefunItem boots) {
|
||||
if (boots instanceof JetBoots && boots.canUse(p, true)) {
|
||||
double speed = ((JetBoots) boots).getSpeed();
|
||||
if (boots instanceof JetBoots jetBoots && boots.canUse(p, true)) {
|
||||
double speed = jetBoots.getSpeed();
|
||||
|
||||
if (speed > 0.2) {
|
||||
new JetBootsTask(p, (JetBoots) boots).scheduleRepeating(0, 2);
|
||||
|
@ -61,8 +61,8 @@ public class GrapplingHookListener implements Listener {
|
||||
return;
|
||||
}
|
||||
|
||||
if (e.getDamager() instanceof Arrow) {
|
||||
handleGrapplingHook((Arrow) e.getDamager());
|
||||
if (e.getDamager() instanceof Arrow arrow) {
|
||||
handleGrapplingHook(arrow);
|
||||
}
|
||||
}
|
||||
|
||||
@ -73,8 +73,8 @@ public class GrapplingHookListener implements Listener {
|
||||
}
|
||||
|
||||
Slimefun.runSync(() -> {
|
||||
if (e.getEntity() instanceof Arrow) {
|
||||
handleGrapplingHook((Arrow) e.getEntity());
|
||||
if (e.getEntity() instanceof Arrow arrow) {
|
||||
handleGrapplingHook(arrow);
|
||||
}
|
||||
}, 2L);
|
||||
}
|
||||
@ -86,8 +86,8 @@ public class GrapplingHookListener implements Listener {
|
||||
}
|
||||
|
||||
// This is called when the arrow shoots off a painting or an item frame
|
||||
if (e.getRemover() instanceof Arrow) {
|
||||
handleGrapplingHook((Arrow) e.getRemover());
|
||||
if (e.getRemover() instanceof Arrow arrow) {
|
||||
handleGrapplingHook(arrow);
|
||||
}
|
||||
}
|
||||
|
||||
@ -130,8 +130,8 @@ public class GrapplingHookListener implements Listener {
|
||||
return;
|
||||
}
|
||||
|
||||
if (e.getEntity() instanceof Arrow) {
|
||||
handleGrapplingHook((Arrow) e.getEntity());
|
||||
if (e.getEntity() instanceof Arrow arrow) {
|
||||
handleGrapplingHook(arrow);
|
||||
}
|
||||
}
|
||||
|
||||
@ -153,9 +153,8 @@ public class GrapplingHookListener implements Listener {
|
||||
}
|
||||
|
||||
private void handleGrapplingHook(@Nullable Arrow arrow) {
|
||||
if (arrow != null && arrow.isValid() && arrow.getShooter() instanceof Player) {
|
||||
Player p = (Player) arrow.getShooter();
|
||||
GrapplingHookEntity hook = activeHooks.get(p.getUniqueId());
|
||||
if (arrow != null && arrow.isValid() && arrow.getShooter() instanceof Player player) {
|
||||
GrapplingHookEntity hook = activeHooks.get(player.getUniqueId());
|
||||
|
||||
if (hook != null) {
|
||||
Location target = arrow.getLocation();
|
||||
@ -163,14 +162,14 @@ public class GrapplingHookListener implements Listener {
|
||||
|
||||
Vector velocity = new Vector(0.0, 0.2, 0.0);
|
||||
|
||||
if (p.getLocation().distance(target) < 3.0) {
|
||||
if (target.getY() <= p.getLocation().getY()) {
|
||||
velocity = target.toVector().subtract(p.getLocation().toVector());
|
||||
if (player.getLocation().distance(target) < 3.0) {
|
||||
if (target.getY() <= player.getLocation().getY()) {
|
||||
velocity = target.toVector().subtract(player.getLocation().toVector());
|
||||
}
|
||||
} else {
|
||||
Location l = p.getLocation();
|
||||
Location l = player.getLocation();
|
||||
l.setY(l.getY() + 0.5);
|
||||
p.teleport(l);
|
||||
player.teleport(l);
|
||||
|
||||
double g = -0.08;
|
||||
double d = target.distance(l);
|
||||
@ -179,16 +178,16 @@ public class GrapplingHookListener implements Listener {
|
||||
double vY = (1.0 + 0.04 * t) * (target.getY() - l.getY()) / t - 0.5D * g * t;
|
||||
double vZ = (1.0 + 0.08 * t) * (target.getZ() - l.getZ()) / t;
|
||||
|
||||
velocity = p.getVelocity();
|
||||
velocity = player.getVelocity();
|
||||
velocity.setX(vX);
|
||||
velocity.setY(vY);
|
||||
velocity.setZ(vZ);
|
||||
}
|
||||
|
||||
p.setVelocity(velocity);
|
||||
player.setVelocity(velocity);
|
||||
|
||||
hook.remove();
|
||||
Slimefun.runSync(() -> activeHooks.remove(p.getUniqueId()), 20L);
|
||||
Slimefun.runSync(() -> activeHooks.remove(player.getUniqueId()), 20L);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -68,9 +68,9 @@ public class SlimefunBootsListener implements Listener {
|
||||
return;
|
||||
}
|
||||
|
||||
if (boots instanceof StomperBoots) {
|
||||
if (boots instanceof StomperBoots stomperBoots) {
|
||||
e.setCancelled(true);
|
||||
((StomperBoots) boots).stomp(e);
|
||||
stomperBoots.stomp(e);
|
||||
} else if (boots instanceof LongFallBoots) {
|
||||
e.setCancelled(true);
|
||||
|
||||
|
@ -55,8 +55,8 @@ public class SlimefunBowListener implements Listener {
|
||||
if (e.getEntity() instanceof Player && e.getProjectile() instanceof Arrow) {
|
||||
SlimefunItem bow = SlimefunItem.getByItem(e.getBow());
|
||||
|
||||
if (bow instanceof SlimefunBow) {
|
||||
projectiles.put(e.getProjectile().getUniqueId(), (SlimefunBow) bow);
|
||||
if (bow instanceof SlimefunBow slimefunBow) {
|
||||
projectiles.put(e.getProjectile().getUniqueId(), slimefunBow);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user