mirror/Slimefun4
mirror/Slimefun4
1
Fork 0
mirror of https://github.com/StarWishsama/Slimefun4.git synced 2024-09-19 19:25:48 +00:00
Code Releases Activity

Reduced technical debt and clutter

Browse Source
This commit is contained in:
TheBusyBiscuit 2020-08-02 11:22:00 +02:00
parent 0f924e485b
commit e52d062ef5
24 changed files with 575 additions and 352 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
CHANGELOG.md
View File

@ -23,6 +23,9 @@
## Release Candidate 16 (TBD)
#### Additions
* Added BlockPlacerPlaceEvent
#### Changes
* Performance improvement for Programmable Android rotations

89
src/main/java/io/github/thebusybiscuit/slimefun4/api/events/BlockPlacerPlaceEvent.java Normal file
View File

@ -0,0 +1,89 @@
package io.github.thebusybiscuit.slimefun4.api.events;
import org.apache.commons.lang.Validate;
import org.bukkit.block.Block;
import org.bukkit.event.Cancellable;
import org.bukkit.event.Event;
import org.bukkit.event.HandlerList;
import org.bukkit.event.block.BlockEvent;
import org.bukkit.inventory.ItemStack;
import io.github.thebusybiscuit.slimefun4.implementation.items.blocks.BlockPlacer;
/**
* This {@link Event} is fired whenever a {@link BlockPlacer} wants to place a {@link Block}.
*
* @author TheBusyBiscuit
*
*/
public class BlockPlacerPlaceEvent extends BlockEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private final Block blockPlacer;
private ItemStack placedItem;
private boolean cancelled = false;
/**
* This creates a new {@link BlockPlacerPlaceEvent}.
*
* @param blockPlacer
* The {@link BlockPlacer}
* @param block
* The placed {@link Block}
*/
public BlockPlacerPlaceEvent(Block blockPlacer, ItemStack placedItem, Block block) {
super(block);
this.placedItem = placedItem;
this.blockPlacer = blockPlacer;
}
public static HandlerList getHandlerList() {
return handlers;
}
public HandlerList getHandlers() {
return handlers;
}
/**
* This method returns the {@link BlockPlacer}
*
* @return The {@link BlockPlacer}
*/
public Block getBlockPlacer() {
return blockPlacer;
}
/**
* This returns the placed {@link ItemStack}.
*
* @return The placed {@link ItemStack}
*/
public ItemStack getItemStack() {
return placedItem;
}
/**
* This sets the placed {@link ItemStack}.
*
* @param item
* The {@link ItemStack} to be placed
*/
public void setItemStack(ItemStack item) {
Validate.notNull(item, "The ItemStack must not be null!");
this.placedItem = item;
}
@Override
public boolean isCancelled() {
return cancelled;
}
@Override
public void setCancelled(boolean cancel) {
cancelled = cancel;
}
}

14
src/main/java/io/github/thebusybiscuit/slimefun4/core/attributes/Placeable.java
View File

@ -37,18 +37,4 @@ public interface Placeable {
return false;
}
default void onPlace(Player p, Block b) {
// Override this as necessary
}
default boolean onBreak(Player p, Block b) {
// Override this as necessary
return true;
}
default boolean onExplode(Block b) {
// Override this as necessary
return true;
}
}

54
src/main/java/io/github/thebusybiscuit/slimefun4/core/handlers/BlockPlaceHandler.java
View File

@ -1,18 +1,62 @@
package io.github.thebusybiscuit.slimefun4.core.handlers;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.inventory.ItemStack;
import io.github.thebusybiscuit.slimefun4.api.events.BlockPlacerPlaceEvent;
import io.github.thebusybiscuit.slimefun4.implementation.items.blocks.BlockPlacer;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
import me.mrCookieSlime.Slimefun.Objects.handlers.ItemHandler;
@FunctionalInterface
public interface BlockPlaceHandler extends ItemHandler {
/**
* This {@link ItemHandler} is called whenever a {@link Block} was placed.
* This only listens to any {@link Block} of the same {@link SlimefunItem} this is assigned
* to.
*
* @author TheBusyBiscuit
*
*/
public abstract class BlockPlaceHandler implements ItemHandler {
boolean onBlockPlace(Player p, BlockPlaceEvent e, ItemStack item);
private final boolean allowBlockPlacers;
public BlockPlaceHandler(boolean allowBlockPlacers) {
this.allowBlockPlacers = allowBlockPlacers;
}
/**
* This method is called whenever a {@link Player} placed this {@link Block}.
*
* @param e
* The corresponding {@link BlockPlaceEvent}
*/
public abstract void onPlayerPlace(BlockPlaceEvent e);
/**
* This method is called whenever a {@link BlockPlacer} places this {@link Block}.
* You cannot cancel the {@link BlockPlacerPlaceEvent} from within this method!
* Override the method {@link #isBlockPlacerAllowed()} instead if you want to disallow the
* {@link BlockPlacer} from placing this {@link Block}.
*
* @param e
* The corresponding {@link BlockPlacerPlaceEvent}
*/
public void onBlockPlacerPlace(BlockPlacerPlaceEvent e) {
// This can be overridden, if necessary
}
/**
* This returns whether the {@link BlockPlacer} is allowed to place a {@link Block} of this type.
*
* @return Whether a {@link BlockPlacer} is allowed to place this
*/
public boolean isBlockPlacerAllowed() {
return allowBlockPlacers;
}
@Override
default Class<? extends ItemHandler> getIdentifier() {
public Class<? extends ItemHandler> getIdentifier() {
return BlockPlaceHandler.class;
}
}

11
src/main/java/io/github/thebusybiscuit/slimefun4/core/services/github/Contributor.java
View File

@ -133,8 +133,15 @@ public class Contributor {
*/
public String getTexture() {
if (!headTexture.isComputed() || !headTexture.isPresent()) {
String cached = SlimefunPlugin.getGitHubService().getCachedTexture(githubUsername);
return cached != null ? cached : HeadTexture.UNKNOWN.getTexture();
GitHubService github = SlimefunPlugin.getGitHubService();
if (github != null) {
String cached = github.getCachedTexture(githubUsername);
return cached != null ? cached : HeadTexture.UNKNOWN.getTexture();
}
else {
return HeadTexture.UNKNOWN.getTexture();
}
}
else {
return headTexture.get();

75
src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/androids/ProgrammableAndroid.java
View File

@ -20,6 +20,7 @@ import org.bukkit.block.data.BlockData;
import org.bukkit.block.data.Rotatable;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
@ -31,6 +32,7 @@ import io.github.thebusybiscuit.cscorelib2.inventory.ItemUtils;
import io.github.thebusybiscuit.cscorelib2.item.CustomItem;
import io.github.thebusybiscuit.cscorelib2.skull.SkullBlock;
import io.github.thebusybiscuit.slimefun4.core.attributes.RecipeDisplayItem;
import io.github.thebusybiscuit.slimefun4.core.handlers.BlockPlaceHandler;
import io.github.thebusybiscuit.slimefun4.implementation.SlimefunItems;
import io.github.thebusybiscuit.slimefun4.implementation.SlimefunPlugin;
import io.github.thebusybiscuit.slimefun4.utils.ChestMenuUtils;
@ -44,12 +46,12 @@ import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.ChestMenu.AdvancedMenu
import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.ClickAction;
import me.mrCookieSlime.Slimefun.Lists.RecipeType;
import me.mrCookieSlime.Slimefun.Objects.Category;
import me.mrCookieSlime.Slimefun.Objects.SlimefunBlockHandler;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.UnregisterReason;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.abstractItems.MachineFuel;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.interfaces.InventoryBlock;
import me.mrCookieSlime.Slimefun.Objects.handlers.BlockTicker;
import me.mrCookieSlime.Slimefun.Objects.handlers.ItemHandler;
import me.mrCookieSlime.Slimefun.api.BlockStorage;
import me.mrCookieSlime.Slimefun.api.Slimefun;
import me.mrCookieSlime.Slimefun.api.SlimefunItemStack;
@ -123,48 +125,57 @@ public abstract class ProgrammableAndroid extends SlimefunItem implements Invent
}
};
registerBlockHandler(getID(), new SlimefunBlockHandler() {
registerBlockHandler(getID(), (p, b, stack, reason) -> {
boolean allow = reason == UnregisterReason.PLAYER_BREAK && (BlockStorage.getLocationInfo(b.getLocation(), "owner").equals(p.getUniqueId().toString()) || p.hasPermission("slimefun.android.bypass"));
if (allow) {
BlockMenu inv = BlockStorage.getInventory(b);
if (inv != null) {
if (inv.getItemInSlot(43) != null) {
b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(43));
inv.replaceExistingItem(43, null);
}
for (int slot : getOutputSlots()) {
if (inv.getItemInSlot(slot) != null) {
b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot));
inv.replaceExistingItem(slot, null);
}
}
}
}
return allow;
});
addItemHandler(onPlace());
}
private ItemHandler onPlace() {
return new BlockPlaceHandler(false) {
@Override
public void onPlace(Player p, Block b, SlimefunItem item) {
public void onPlayerPlace(BlockPlaceEvent e) {
Player p = e.getPlayer();
Block b = e.getBlock();
BlockStorage.addBlockInfo(b, "owner", p.getUniqueId().toString());
BlockStorage.addBlockInfo(b, "script", DEFAULT_SCRIPT);
BlockStorage.addBlockInfo(b, "index", "0");
BlockStorage.addBlockInfo(b, "fuel", "0");
BlockStorage.addBlockInfo(b, "rotation", p.getFacing().getOppositeFace().toString());
BlockStorage.addBlockInfo(b, "paused", "true");
b.setType(Material.PLAYER_HEAD);
Rotatable blockData = (Rotatable) b.getBlockData();
blockData.setRotation(p.getFacing());
BlockData blockData = Material.PLAYER_HEAD.createBlockData(data -> {
if (data instanceof Rotatable) {
((Rotatable) data).setRotation(p.getFacing());
}
});
b.setBlockData(blockData);
}
@Override
public boolean onBreak(Player p, Block b, SlimefunItem item, UnregisterReason reason) {
boolean allow = reason == UnregisterReason.PLAYER_BREAK && (BlockStorage.getLocationInfo(b.getLocation(), "owner").equals(p.getUniqueId().toString()) || p.hasPermission("slimefun.android.bypass"));
if (allow) {
BlockMenu inv = BlockStorage.getInventory(b);
if (inv != null) {
if (inv.getItemInSlot(43) != null) {
b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(43));
inv.replaceExistingItem(43, null);
}
for (int slot : getOutputSlots()) {
if (inv.getItemInSlot(slot) != null) {
b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot));
inv.replaceExistingItem(slot, null);
}
}
}
}
return allow;
}
});
};
}
/**

99
src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/blocks/BlockPlacer.java
View File

@ -1,26 +1,25 @@
package io.github.thebusybiscuit.slimefun4.implementation.items.blocks;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import org.bukkit.Bukkit;
import org.bukkit.Effect;
import org.bukkit.Material;
import org.bukkit.Nameable;
import org.bukkit.block.Block;
import org.bukkit.block.BlockState;
import org.bukkit.block.CreatureSpawner;
import org.bukkit.block.Dispenser;
import org.bukkit.entity.EntityType;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import io.github.thebusybiscuit.cscorelib2.item.CustomItem;
import io.github.thebusybiscuit.cscorelib2.materials.MaterialCollections;
import io.github.thebusybiscuit.slimefun4.api.events.BlockPlacerPlaceEvent;
import io.github.thebusybiscuit.slimefun4.api.items.ItemSetting;
import io.github.thebusybiscuit.slimefun4.core.attributes.NotPlaceable;
import io.github.thebusybiscuit.slimefun4.core.handlers.BlockDispenseHandler;
import io.github.thebusybiscuit.slimefun4.implementation.SlimefunPlugin;
import io.github.thebusybiscuit.slimefun4.core.handlers.BlockPlaceHandler;
import io.github.thebusybiscuit.slimefun4.implementation.items.SimpleSlimefunItem;
import me.mrCookieSlime.Slimefun.Lists.RecipeType;
import me.mrCookieSlime.Slimefun.Objects.Category;
@ -50,12 +49,12 @@ public class BlockPlacer extends SimpleSlimefunItem<BlockDispenseHandler> {
e.setCancelled(true);
if ((facedBlock.getType() == null || facedBlock.getType() == Material.AIR) && e.getItem().getType().isBlock() && !isBlacklisted(e.getItem().getType())) {
if (facedBlock.isEmpty() && e.getItem().getType().isBlock() && !isBlacklisted(e.getItem().getType())) {
SlimefunItem item = SlimefunItem.getByItem(e.getItem());
if (item != null) {
// Check if this Item can even be placed down
if (!(item instanceof NotPlaceable) && !SlimefunPlugin.getRegistry().getBlockHandlers().containsKey(item.getID())) {
if (!(item instanceof NotPlaceable)) {
placeSlimefunBlock(item, e.getItem(), facedBlock, dispenser);
}
}
@ -81,54 +80,78 @@ public class BlockPlacer extends SimpleSlimefunItem<BlockDispenseHandler> {
}
private void placeSlimefunBlock(SlimefunItem sfItem, ItemStack item, Block block, Dispenser dispenser) {
block.setType(item.getType());
BlockStorage.store(block, sfItem.getID());
block.getWorld().playEffect(block.getLocation(), Effect.STEP_SOUND, item.getType());
BlockPlacerPlaceEvent e = new BlockPlacerPlaceEvent(dispenser.getBlock(), item, block);
Bukkit.getPluginManager().callEvent(e);
if (item.getType() == Material.SPAWNER && sfItem instanceof RepairedSpawner) {
Optional<EntityType> entity = ((RepairedSpawner) sfItem).getEntityType(item);
if (!e.isCancelled()) {
boolean hasItemHandler = sfItem.callItemHandler(BlockPlaceHandler.class, handler -> {
if (handler.isBlockPlacerAllowed()) {
block.setType(item.getType());
block.getWorld().playEffect(block.getLocation(), Effect.STEP_SOUND, item.getType());
if (entity.isPresent()) {
CreatureSpawner spawner = (CreatureSpawner) block.getState();
spawner.setSpawnedType(entity.get());
spawner.update(true, false);
BlockStorage.store(block, sfItem.getID());
handler.onBlockPlacerPlace(e);
if (dispenser.getInventory().containsAtLeast(item, 2)) {
dispenser.getInventory().removeItem(new CustomItem(item, 1));
}
else {
Slimefun.runSync(() -> dispenser.getInventory().removeItem(item), 2L);
}
}
});
if (hasItemHandler && e.isCancelled()) {
sfItem.warn("A BlockPlacerPlaceEvent cannot be cancelled from a BlockPlaceHandler!");
}
}
if (dispenser.getInventory().containsAtLeast(item, 2)) {
dispenser.getInventory().removeItem(new CustomItem(item, 1));
}
else {
Slimefun.runSync(() -> dispenser.getInventory().removeItem(item), 2L);
if (!hasItemHandler) {
block.setType(item.getType());
block.getWorld().playEffect(block.getLocation(), Effect.STEP_SOUND, item.getType());
BlockStorage.store(block, sfItem.getID());
if (dispenser.getInventory().containsAtLeast(item, 2)) {
dispenser.getInventory().removeItem(new CustomItem(item, 1));
}
else {
Slimefun.runSync(() -> dispenser.getInventory().removeItem(item), 2L);
}
}
}
}
private void placeBlock(ItemStack item, Block facedBlock, Dispenser dispenser) {
facedBlock.setType(item.getType());
BlockPlacerPlaceEvent e = new BlockPlacerPlaceEvent(dispenser.getBlock(), item, facedBlock);
Bukkit.getPluginManager().callEvent(e);
if (item.hasItemMeta()) {
ItemMeta meta = item.getItemMeta();
if (!e.isCancelled()) {
facedBlock.setType(item.getType());
if (meta.hasDisplayName()) {
BlockState blockState = facedBlock.getState();
if (item.hasItemMeta()) {
ItemMeta meta = item.getItemMeta();
if ((blockState instanceof Nameable)) {
((Nameable) blockState).setCustomName(meta.getDisplayName());
if (meta.hasDisplayName()) {
BlockState blockState = facedBlock.getState();
if ((blockState instanceof Nameable)) {
((Nameable) blockState).setCustomName(meta.getDisplayName());
}
// Update block state after changing name
blockState.update();
}
// Update block state after changing name
blockState.update();
}
}
facedBlock.getWorld().playEffect(facedBlock.getLocation(), Effect.STEP_SOUND, item.getType());
facedBlock.getWorld().playEffect(facedBlock.getLocation(), Effect.STEP_SOUND, item.getType());
if (dispenser.getInventory().containsAtLeast(item, 2)) {
dispenser.getInventory().removeItem(new CustomItem(item, 1));
}
else {
Slimefun.runSync(() -> dispenser.getInventory().removeItem(item), 2L);
if (dispenser.getInventory().containsAtLeast(item, 2)) {
dispenser.getInventory().removeItem(new CustomItem(item, 1));
}
else {
Slimefun.runSync(() -> dispenser.getInventory().removeItem(item), 2L);
}
}
}
}

39
src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/blocks/HologramProjector.java
View File

@ -6,51 +6,57 @@ import org.bukkit.block.Block;
import org.bukkit.entity.ArmorStand;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.inventory.ItemStack;
import io.github.thebusybiscuit.cscorelib2.chat.ChatColors;
import io.github.thebusybiscuit.cscorelib2.item.CustomItem;
import io.github.thebusybiscuit.cscorelib2.math.DoubleHandler;
import io.github.thebusybiscuit.slimefun4.core.handlers.BlockBreakHandler;
import io.github.thebusybiscuit.slimefun4.core.handlers.BlockPlaceHandler;
import io.github.thebusybiscuit.slimefun4.core.handlers.BlockUseHandler;
import io.github.thebusybiscuit.slimefun4.implementation.SlimefunPlugin;
import io.github.thebusybiscuit.slimefun4.implementation.items.SimpleSlimefunItem;
import io.github.thebusybiscuit.slimefun4.utils.ChatUtils;
import io.github.thebusybiscuit.slimefun4.utils.holograms.SimpleHologram;
import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.ChestMenu;
import me.mrCookieSlime.Slimefun.Lists.RecipeType;
import me.mrCookieSlime.Slimefun.Objects.Category;
import me.mrCookieSlime.Slimefun.Objects.SlimefunBlockHandler;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.UnregisterReason;
import me.mrCookieSlime.Slimefun.api.BlockStorage;
import me.mrCookieSlime.Slimefun.api.SlimefunItemStack;
public class HologramProjector extends SimpleSlimefunItem<BlockUseHandler> {
public class HologramProjector extends SlimefunItem {
public HologramProjector(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe, ItemStack recipeOutput) {
super(category, item, recipeType, recipe, recipeOutput);
SlimefunItem.registerBlockHandler(getID(), new SlimefunBlockHandler() {
addItemHandler(onPlace(), onRightClick(), onBreak());
}
private BlockPlaceHandler onPlace() {
return new BlockPlaceHandler(false) {
@Override
public void onPlace(Player p, Block b, SlimefunItem item) {
public void onPlayerPlace(BlockPlaceEvent e) {
Block b = e.getBlockPlaced();
BlockStorage.addBlockInfo(b, "text", "Edit me via the Projector");
BlockStorage.addBlockInfo(b, "offset", "0.5");
BlockStorage.addBlockInfo(b, "owner", p.getUniqueId().toString());
BlockStorage.addBlockInfo(b, "owner", e.getPlayer().getUniqueId().toString());
getArmorStand(b, true);
}
@Override
public boolean onBreak(Player p, Block b, SlimefunItem item, UnregisterReason reason) {
remove(b);
return true;
}
});
};
}
@Override
public BlockUseHandler getItemHandler() {
private BlockBreakHandler onBreak() {
return (e, item, fortune, drops) -> {
remove(e.getBlock());
return true;
};
}
public BlockUseHandler onRightClick() {
return e -> {
e.cancel();
@ -77,10 +83,11 @@ public class HologramProjector extends SimpleSlimefunItem<BlockUseHandler> {
BlockStorage.addBlockInfo(projector, "text", hologram.getCustomName());
openEditor(pl, projector);
});
return false;
});
menu.addItem(1, new CustomItem(new ItemStack(Material.CLOCK), "&7Offset: &e" + DoubleHandler.fixDouble(Double.valueOf(BlockStorage.getLocationInfo(projector.getLocation(), "offset")) + 1.0D), "", "&rLeft Click: &7+0.1", "&rRight Click: &7-0.1"));
menu.addItem(1, new CustomItem(Material.CLOCK, "&7Offset: &e" + DoubleHandler.fixDouble(Double.valueOf(BlockStorage.getLocationInfo(projector.getLocation(), "offset")) + 1.0D), "", "&rLeft Click: &7+0.1", "&rRight Click: &7-0.1"));
menu.addMenuClickHandler(1, (pl, slot, item, action) -> {
double offset = DoubleHandler.fixDouble(Double.valueOf(BlockStorage.getLocationInfo(projector.getLocation(), "offset")) + (action.isRightClicked() ? -0.1F : 0.1F));
ArmorStand hologram = getArmorStand(projector, true);

37
src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/blocks/RepairedSpawner.java
View File

@ -4,18 +4,28 @@ import java.util.Locale;
import java.util.Optional;
import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.block.CreatureSpawner;
import org.bukkit.entity.EntityType;
import org.bukkit.event.block.BlockEvent;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.inventory.ItemStack;
import io.github.thebusybiscuit.slimefun4.api.events.BlockPlacerPlaceEvent;
import io.github.thebusybiscuit.slimefun4.core.handlers.BlockPlaceHandler;
import io.github.thebusybiscuit.slimefun4.implementation.SlimefunItems;
import io.github.thebusybiscuit.slimefun4.implementation.items.SimpleSlimefunItem;
import io.github.thebusybiscuit.slimefun4.utils.SlimefunUtils;
import me.mrCookieSlime.Slimefun.Lists.RecipeType;
import me.mrCookieSlime.Slimefun.Objects.Category;
import me.mrCookieSlime.Slimefun.api.SlimefunItemStack;
/**
* A {@link RepairedSpawner} is the repaired variant of a {@link BrokenSpawner}.
*
* @author TheBusyBiscuit
*
* @see BrokenSpawner
*
*/
public class RepairedSpawner extends SimpleSlimefunItem<BlockPlaceHandler> {
public RepairedSpawner(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) {
@ -24,21 +34,26 @@ public class RepairedSpawner extends SimpleSlimefunItem<BlockPlaceHandler> {
@Override
public BlockPlaceHandler getItemHandler() {
return (p, e, item) -> {
// We need to explicitly ignore the lore here
if (SlimefunUtils.isItemSimilar(item, SlimefunItems.REPAIRED_SPAWNER, false, false)) {
return new BlockPlaceHandler(true) {
@Override
public void onPlayerPlace(BlockPlaceEvent e) {
onPlace(e);
}
@Override
public void onBlockPlacerPlace(BlockPlacerPlaceEvent e) {
onPlace(e);
}
private void onPlace(BlockEvent e) {
Optional<EntityType> entity = getEntityType(item);
if (entity.isPresent()) {
if (entity.isPresent() && e.getBlock().getType() == Material.SPAWNER) {
CreatureSpawner spawner = (CreatureSpawner) e.getBlock().getState();
spawner.setSpawnedType(entity.get());
spawner.update(true, false);
}
return true;
}
else {
return false;
}
};
}

47
src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/cargo/AdvancedCargoOutputNode.java
View File

@ -2,21 +2,19 @@ package io.github.thebusybiscuit.slimefun4.implementation.items.cargo;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.Damageable;
import org.bukkit.inventory.meta.ItemMeta;
import io.github.thebusybiscuit.cscorelib2.item.CustomItem;
import io.github.thebusybiscuit.cscorelib2.materials.MaterialCollections;
import io.github.thebusybiscuit.slimefun4.core.handlers.BlockPlaceHandler;
import io.github.thebusybiscuit.slimefun4.implementation.SlimefunPlugin;
import io.github.thebusybiscuit.slimefun4.utils.ChestMenuUtils;
import io.github.thebusybiscuit.slimefun4.utils.SlimefunUtils;
import me.mrCookieSlime.Slimefun.Lists.RecipeType;
import me.mrCookieSlime.Slimefun.Objects.Category;
import me.mrCookieSlime.Slimefun.Objects.SlimefunBlockHandler;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.UnregisterReason;
import me.mrCookieSlime.Slimefun.api.BlockStorage;
import me.mrCookieSlime.Slimefun.api.SlimefunItemStack;
import me.mrCookieSlime.Slimefun.api.inventory.BlockMenu;
@ -30,33 +28,36 @@ public class AdvancedCargoOutputNode extends AbstractCargoNode {
public AdvancedCargoOutputNode(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe, ItemStack recipeOutput) {
super(category, item, recipeType, recipe, recipeOutput);
registerBlockHandler(getID(), new SlimefunBlockHandler() {
addItemHandler(onPlace());
registerBlockHandler(getID(), (p, b, stack, reason) -> {
BlockMenu inv = BlockStorage.getInventory(b);
if (inv != null) {
for (int slot : SLOTS) {
if (inv.getItemInSlot(slot) != null) {
b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot));
inv.replaceExistingItem(slot, null);
}
}
}
return true;
});
}
private BlockPlaceHandler onPlace() {
return new BlockPlaceHandler(false) {
@Override
public void onPlace(Player p, Block b, SlimefunItem item) {
BlockStorage.addBlockInfo(b, "owner", p.getUniqueId().toString());
public void onPlayerPlace(BlockPlaceEvent e) {
Block b = e.getBlock();
BlockStorage.addBlockInfo(b, "owner", e.getPlayer().getUniqueId().toString());
BlockStorage.addBlockInfo(b, "index", "0");
BlockStorage.addBlockInfo(b, FREQUENCY, "0");
BlockStorage.addBlockInfo(b, "filter-type", "whitelist");
BlockStorage.addBlockInfo(b, "filter-lore", String.valueOf(true));
BlockStorage.addBlockInfo(b, "filter-durability", String.valueOf(false));
}
@Override
public boolean onBreak(Player p, Block b, SlimefunItem item, UnregisterReason reason) {
BlockMenu inv = BlockStorage.getInventory(b);
if (inv != null) {
for (int slot : SLOTS) {
if (inv.getItemInSlot(slot) != null) {
b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot));
inv.replaceExistingItem(slot, null);
}
}
}
return true;
}
});
};
}
@Override

47
src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/cargo/CargoInputNode.java
View File

@ -2,21 +2,19 @@ package io.github.thebusybiscuit.slimefun4.implementation.items.cargo;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.Damageable;
import org.bukkit.inventory.meta.ItemMeta;
import io.github.thebusybiscuit.cscorelib2.item.CustomItem;
import io.github.thebusybiscuit.cscorelib2.materials.MaterialCollections;
import io.github.thebusybiscuit.slimefun4.core.handlers.BlockPlaceHandler;
import io.github.thebusybiscuit.slimefun4.implementation.SlimefunPlugin;
import io.github.thebusybiscuit.slimefun4.utils.ChestMenuUtils;
import io.github.thebusybiscuit.slimefun4.utils.SlimefunUtils;
import me.mrCookieSlime.Slimefun.Lists.RecipeType;
import me.mrCookieSlime.Slimefun.Objects.Category;
import me.mrCookieSlime.Slimefun.Objects.SlimefunBlockHandler;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.UnregisterReason;
import me.mrCookieSlime.Slimefun.api.BlockStorage;
import me.mrCookieSlime.Slimefun.api.SlimefunItemStack;
import me.mrCookieSlime.Slimefun.api.inventory.BlockMenu;
@ -30,11 +28,29 @@ public class CargoInputNode extends AbstractCargoNode {
public CargoInputNode(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe, ItemStack recipeOutput) {
super(category, item, recipeType, recipe, recipeOutput);
registerBlockHandler(getID(), new SlimefunBlockHandler() {
addItemHandler(onPlace());
registerBlockHandler(getID(), (p, b, stack, reason) -> {
BlockMenu inv = BlockStorage.getInventory(b);
if (inv != null) {
for (int slot : SLOTS) {
if (inv.getItemInSlot(slot) != null) {
b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot));
inv.replaceExistingItem(slot, null);
}
}
}
return true;
});
}
private BlockPlaceHandler onPlace() {
return new BlockPlaceHandler(false) {
@Override
public void onPlace(Player p, Block b, SlimefunItem item) {
BlockStorage.addBlockInfo(b, "owner", p.getUniqueId().toString());
public void onPlayerPlace(BlockPlaceEvent e) {
Block b = e.getBlock();
BlockStorage.addBlockInfo(b, "owner", e.getPlayer().getUniqueId().toString());
BlockStorage.addBlockInfo(b, "index", "0");
BlockStorage.addBlockInfo(b, FREQUENCY, "0");
BlockStorage.addBlockInfo(b, "filter-type", "whitelist");
@ -42,22 +58,7 @@ public class CargoInputNode extends AbstractCargoNode {
BlockStorage.addBlockInfo(b, "filter-durability", String.valueOf(false));
BlockStorage.addBlockInfo(b, "round-robin", String.valueOf(false));
}
@Override
public boolean onBreak(Player p, Block b, SlimefunItem item, UnregisterReason reason) {
BlockMenu inv = BlockStorage.getInventory(b);
if (inv != null) {
for (int slot : SLOTS) {
if (inv.getItemInSlot(slot) != null) {
b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot));
inv.replaceExistingItem(slot, null);
}
}
}
return true;
}
});
};
}
@Override

24
src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/cargo/CargoOutputNode.java
View File

@ -2,19 +2,17 @@ package io.github.thebusybiscuit.slimefun4.implementation.items.cargo;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.inventory.ItemStack;
import io.github.thebusybiscuit.cscorelib2.item.CustomItem;
import io.github.thebusybiscuit.cscorelib2.materials.MaterialCollections;
import io.github.thebusybiscuit.slimefun4.core.handlers.BlockPlaceHandler;
import io.github.thebusybiscuit.slimefun4.implementation.SlimefunPlugin;
import io.github.thebusybiscuit.slimefun4.utils.ChestMenuUtils;
import io.github.thebusybiscuit.slimefun4.utils.SlimefunUtils;
import me.mrCookieSlime.Slimefun.Lists.RecipeType;
import me.mrCookieSlime.Slimefun.Objects.Category;
import me.mrCookieSlime.Slimefun.Objects.SlimefunBlockHandler;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.UnregisterReason;
import me.mrCookieSlime.Slimefun.api.BlockStorage;
import me.mrCookieSlime.Slimefun.api.SlimefunItemStack;
import me.mrCookieSlime.Slimefun.api.inventory.BlockMenu;
@ -27,19 +25,19 @@ public class CargoOutputNode extends AbstractCargoNode {
public CargoOutputNode(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe, ItemStack recipeOutput) {
super(category, item, recipeType, recipe, recipeOutput);
registerBlockHandler(getID(), new SlimefunBlockHandler() {
addItemHandler(onPlace());
}
private BlockPlaceHandler onPlace() {
return new BlockPlaceHandler(false) {
@Override
public void onPlace(Player p, Block b, SlimefunItem item) {
BlockStorage.addBlockInfo(b, "owner", p.getUniqueId().toString());
public void onPlayerPlace(BlockPlaceEvent e) {
Block b = e.getBlock();
BlockStorage.addBlockInfo(b, "owner", e.getPlayer().getUniqueId().toString());
BlockStorage.addBlockInfo(b, FREQUENCY, "0");
}
@Override
public boolean onBreak(Player p, Block b, SlimefunItem item, UnregisterReason reason) {
return true;
}
});
};
}
@Override

33
src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/electric/EnergyRegulator.java
View File

@ -1,18 +1,17 @@
package io.github.thebusybiscuit.slimefun4.implementation.items.electric;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.inventory.ItemStack;
import io.github.thebusybiscuit.slimefun4.core.attributes.EnergyNetComponent;
import io.github.thebusybiscuit.slimefun4.core.handlers.BlockPlaceHandler;
import io.github.thebusybiscuit.slimefun4.core.networks.energy.EnergyNet;
import io.github.thebusybiscuit.slimefun4.utils.holograms.SimpleHologram;
import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config;
import me.mrCookieSlime.Slimefun.Lists.RecipeType;
import me.mrCookieSlime.Slimefun.Objects.Category;
import me.mrCookieSlime.Slimefun.Objects.SlimefunBlockHandler;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.UnregisterReason;
import me.mrCookieSlime.Slimefun.Objects.handlers.BlockTicker;
import me.mrCookieSlime.Slimefun.api.SlimefunItemStack;
@ -31,24 +30,26 @@ public class EnergyRegulator extends SlimefunItem {
public EnergyRegulator(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) {
super(category, item, recipeType, recipe);
SlimefunItem.registerBlockHandler(getID(), new SlimefunBlockHandler() {
@Override
public void onPlace(Player p, Block b, SlimefunItem item) {
// Spawn the hologram
SimpleHologram.update(b, "&7Connecting...");
}
@Override
public boolean onBreak(Player p, Block b, SlimefunItem item, UnregisterReason reason) {
SimpleHologram.remove(b);
return true;
}
SlimefunItem.registerBlockHandler(getID(), (p, b, stack, reason) -> {
SimpleHologram.remove(b);
return true;
});
}
private BlockPlaceHandler onPlace() {
return new BlockPlaceHandler(false) {
@Override
public void onPlayerPlace(BlockPlaceEvent e) {
SimpleHologram.update(e.getBlock(), "&7Connecting...");
}
};
}
@Override
public void preRegister() {
addItemHandler(onPlace());
addItemHandler(new BlockTicker() {
@Override

48
src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/electric/machines/AbstractEntityAssembler.java
View File

@ -6,12 +6,16 @@ import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;
import org.bukkit.event.block.BlockEvent;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.inventory.ItemStack;
import io.github.thebusybiscuit.cscorelib2.item.CustomItem;
import io.github.thebusybiscuit.cscorelib2.math.DoubleHandler;
import io.github.thebusybiscuit.cscorelib2.protection.ProtectableAction;
import io.github.thebusybiscuit.slimefun4.api.events.BlockPlacerPlaceEvent;
import io.github.thebusybiscuit.slimefun4.core.attributes.EnergyNetComponent;
import io.github.thebusybiscuit.slimefun4.core.handlers.BlockPlaceHandler;
import io.github.thebusybiscuit.slimefun4.core.networks.energy.EnergyNetComponentType;
import io.github.thebusybiscuit.slimefun4.implementation.SlimefunPlugin;
import io.github.thebusybiscuit.slimefun4.implementation.items.SimpleSlimefunItem;
@ -20,7 +24,6 @@ import io.github.thebusybiscuit.slimefun4.utils.SlimefunUtils;
import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config;
import me.mrCookieSlime.Slimefun.Lists.RecipeType;
import me.mrCookieSlime.Slimefun.Objects.Category;
import me.mrCookieSlime.Slimefun.Objects.SlimefunBlockHandler;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.UnregisterReason;
import me.mrCookieSlime.Slimefun.Objects.handlers.BlockTicker;
@ -116,28 +119,39 @@ public abstract class AbstractEntityAssembler<T extends Entity> extends SimpleSl
}
};
registerBlockHandler(getID(), new SlimefunBlockHandler() {
@Override
public void onPlace(Player p, Block b, SlimefunItem item) {
BlockStorage.addBlockInfo(b, KEY_OFFSET, "3.0");
BlockStorage.addBlockInfo(b, KEY_ENABLED, String.valueOf(false));
addItemHandler(onPlace());
registerBlockHandler(getID(), (p, b, stack, reason) -> {
if (reason == UnregisterReason.EXPLODE) {
return false;
}
@Override
public boolean onBreak(Player p, Block b, SlimefunItem item, UnregisterReason reason) {
if (reason == UnregisterReason.EXPLODE) {
return false;
}
BlockMenu inv = BlockStorage.getInventory(b);
dropInventory(b, inv);
BlockMenu inv = BlockStorage.getInventory(b);
dropInventory(b, inv);
return true;
}
return true;
});
}
private BlockPlaceHandler onPlace() {
return new BlockPlaceHandler(true) {
@Override
public void onPlayerPlace(BlockPlaceEvent e) {
onPlace(e);
}
@Override
public void onBlockPlacerPlace(BlockPlacerPlaceEvent e) {
onPlace(e);
}
private void onPlace(BlockEvent e) {
BlockStorage.addBlockInfo(e.getBlock(), KEY_OFFSET, "3.0");
BlockStorage.addBlockInfo(e.getBlock(), KEY_ENABLED, String.valueOf(false));
}
};
}
private void updateBlockInventory(BlockMenu menu, Block b) {
if (!BlockStorage.hasBlockInfo(b) || BlockStorage.getLocationInfo(b.getLocation(), KEY_ENABLED) == null || BlockStorage.getLocationInfo(b.getLocation(), KEY_ENABLED).equals(String.valueOf(false))) {
menu.replaceExistingItem(22, new CustomItem(Material.GUNPOWDER, "&7Enabled: &4\u2718", "", "&e> Click to enable this Machine"));

60
src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/electric/machines/AutomatedCraftingChamber.java
View File

@ -8,12 +8,15 @@ import java.util.List;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.ItemStack;
import io.github.thebusybiscuit.cscorelib2.item.CustomItem;
import io.github.thebusybiscuit.cscorelib2.protection.ProtectableAction;
import io.github.thebusybiscuit.slimefun4.api.events.BlockPlacerPlaceEvent;
import io.github.thebusybiscuit.slimefun4.core.attributes.EnergyNetComponent;
import io.github.thebusybiscuit.slimefun4.core.handlers.BlockPlaceHandler;
import io.github.thebusybiscuit.slimefun4.core.networks.energy.EnergyNetComponentType;
import io.github.thebusybiscuit.slimefun4.implementation.SlimefunPlugin;
import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config;
@ -23,9 +26,7 @@ import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.Item.CustomItemSeriali
import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.Item.CustomItemSerializer.ItemFlag;
import me.mrCookieSlime.Slimefun.Lists.RecipeType;
import me.mrCookieSlime.Slimefun.Objects.Category;
import me.mrCookieSlime.Slimefun.Objects.SlimefunBlockHandler;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.UnregisterReason;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.interfaces.InventoryBlock;
import me.mrCookieSlime.Slimefun.Objects.handlers.BlockTicker;
import me.mrCookieSlime.Slimefun.api.BlockStorage;
@ -113,38 +114,45 @@ public abstract class AutomatedCraftingChamber extends SlimefunItem implements I
}
};
registerBlockHandler(getID(), new SlimefunBlockHandler() {
addItemHandler(onPlace());
registerBlockHandler(getID(), (p, b, stack, reason) -> {
BlockMenu inv = BlockStorage.getInventory(b);
@Override
public void onPlace(Player p, Block b, SlimefunItem item) {
BlockStorage.addBlockInfo(b, "enabled", String.valueOf(false));
}
@Override
public boolean onBreak(Player p, Block b, SlimefunItem item, UnregisterReason reason) {
BlockMenu inv = BlockStorage.getInventory(b);
if (inv != null) {
for (int slot : getInputSlots()) {
if (inv.getItemInSlot(slot) != null) {
b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot));
inv.replaceExistingItem(slot, null);
}
}
for (int slot : getOutputSlots()) {
if (inv.getItemInSlot(slot) != null) {
b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot));
inv.replaceExistingItem(slot, null);
}
if (inv != null) {
for (int slot : getInputSlots()) {
if (inv.getItemInSlot(slot) != null) {
b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot));
inv.replaceExistingItem(slot, null);
}
}
return true;
for (int slot : getOutputSlots()) {
if (inv.getItemInSlot(slot) != null) {
b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot));
inv.replaceExistingItem(slot, null);
}
}
}
return true;
});
}
private BlockPlaceHandler onPlace() {
return new BlockPlaceHandler(true) {
@Override
public void onPlayerPlace(BlockPlaceEvent e) {
BlockStorage.addBlockInfo(e.getBlock(), "enabled", String.valueOf(false));
}
@Override
public void onBlockPlacerPlace(BlockPlacerPlaceEvent e) {
BlockStorage.addBlockInfo(e.getBlock(), "enabled", String.valueOf(false));
}
};
}
private Comparator<Integer> compareSlots(DirtyChestMenu menu) {
return (slot1, slot2) -> menu.getItemInSlot(slot1).getAmount() - menu.getItemInSlot(slot2).getAmount();
}

43
src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/electric/machines/XPCollector.java
View File

@ -6,19 +6,18 @@ import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.Entity;
import org.bukkit.entity.ExperienceOrb;
import org.bukkit.entity.Player;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.inventory.ItemStack;
import io.github.thebusybiscuit.cscorelib2.item.CustomItem;
import io.github.thebusybiscuit.slimefun4.core.attributes.EnergyNetComponent;
import io.github.thebusybiscuit.slimefun4.core.handlers.BlockPlaceHandler;
import io.github.thebusybiscuit.slimefun4.core.networks.energy.EnergyNetComponentType;
import io.github.thebusybiscuit.slimefun4.implementation.SlimefunItems;
import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config;
import me.mrCookieSlime.Slimefun.Lists.RecipeType;
import me.mrCookieSlime.Slimefun.Objects.Category;
import me.mrCookieSlime.Slimefun.Objects.SlimefunBlockHandler;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.UnregisterReason;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.interfaces.InventoryBlock;
import me.mrCookieSlime.Slimefun.Objects.handlers.BlockTicker;
import me.mrCookieSlime.Slimefun.api.BlockStorage;
@ -39,30 +38,32 @@ public class XPCollector extends SlimefunItem implements InventoryBlock, EnergyN
createPreset(this, this::constructMenu);
registerBlockHandler(getID(), new SlimefunBlockHandler() {
addItemHandler(onPlace());
registerBlockHandler(getID(), (p, b, stack, reason) -> {
BlockMenu inv = BlockStorage.getInventory(b);
@Override
public void onPlace(Player p, Block b, SlimefunItem item) {
BlockStorage.addBlockInfo(b, "owner", p.getUniqueId().toString());
}
@Override
public boolean onBreak(Player p, Block b, SlimefunItem item, UnregisterReason reason) {
BlockMenu inv = BlockStorage.getInventory(b);
if (inv != null) {
for (int slot : getOutputSlots()) {
if (inv.getItemInSlot(slot) != null) {
b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot));
inv.replaceExistingItem(slot, null);
}
if (inv != null) {
for (int slot : getOutputSlots()) {
if (inv.getItemInSlot(slot) != null) {
b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot));
inv.replaceExistingItem(slot, null);
}
}
return true;
}
return true;
});
}
private BlockPlaceHandler onPlace() {
return new BlockPlaceHandler(false) {
@Override
public void onPlayerPlace(BlockPlaceEvent e) {
BlockStorage.addBlockInfo(e.getBlock(), "owner", e.getPlayer().getUniqueId().toString());
}
};
}
@Override
public int[] getInputSlots() {
return new int[0];
@ -85,7 +86,7 @@ public class XPCollector extends SlimefunItem implements InventoryBlock, EnergyN
protected void constructMenu(BlockMenuPreset preset) {
for (int slot : border) {
preset.addItem(slot, new CustomItem(new ItemStack(Material.PURPLE_STAINED_GLASS_PANE), " "), (p, s, item, action) -> false);
preset.addItem(slot, new CustomItem(Material.PURPLE_STAINED_GLASS_PANE, " "), (p, s, item, action) -> false);
}
}

62
src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/geo/GEOMiner.java
View File

@ -8,12 +8,14 @@ import org.bukkit.ChatColor;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.ItemStack;
import io.github.thebusybiscuit.cscorelib2.item.CustomItem;
import io.github.thebusybiscuit.slimefun4.api.geo.GEOResource;
import io.github.thebusybiscuit.slimefun4.core.attributes.RecipeDisplayItem;
import io.github.thebusybiscuit.slimefun4.core.handlers.BlockPlaceHandler;
import io.github.thebusybiscuit.slimefun4.implementation.SlimefunPlugin;
import io.github.thebusybiscuit.slimefun4.utils.ChestMenuUtils;
import io.github.thebusybiscuit.slimefun4.utils.holograms.SimpleHologram;
@ -21,9 +23,6 @@ import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.ChestMenu.AdvancedMenu
import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.ClickAction;
import me.mrCookieSlime.Slimefun.Lists.RecipeType;
import me.mrCookieSlime.Slimefun.Objects.Category;
import me.mrCookieSlime.Slimefun.Objects.SlimefunBlockHandler;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.UnregisterReason;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.abstractItems.AContainer;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.abstractItems.MachineRecipe;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.interfaces.InventoryBlock;
@ -43,43 +42,44 @@ public abstract class GEOMiner extends AContainer implements InventoryBlock, Rec
public GEOMiner(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) {
super(category, item, recipeType, recipe);
registerBlockHandler(getID(), new SlimefunBlockHandler() {
addItemHandler(onPlace());
registerBlockHandler(getID(), (p, b, stack, reason) -> {
SimpleHologram.remove(b);
@Override
public void onPlace(Player p, Block b, SlimefunItem item) {
// Spawn the hologram
SimpleHologram.update(b, "&7Idling...");
}
BlockMenu inv = BlockStorage.getInventory(b);
@Override
public boolean onBreak(Player p, Block b, SlimefunItem item, UnregisterReason reason) {
SimpleHologram.remove(b);
BlockMenu inv = BlockStorage.getInventory(b);
if (inv != null) {
for (int slot : getInputSlots()) {
if (inv.getItemInSlot(slot) != null) {
b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot));
inv.replaceExistingItem(slot, null);
}
}
for (int slot : getOutputSlots()) {
if (inv.getItemInSlot(slot) != null) {
b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot));
inv.replaceExistingItem(slot, null);
}
if (inv != null) {
for (int slot : getInputSlots()) {
if (inv.getItemInSlot(slot) != null) {
b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot));
inv.replaceExistingItem(slot, null);
}
}
progress.remove(b);
processing.remove(b);
return true;
for (int slot : getOutputSlots()) {
if (inv.getItemInSlot(slot) != null) {
b.getWorld().dropItemNaturally(b.getLocation(), inv.getItemInSlot(slot));
inv.replaceExistingItem(slot, null);
}
}
}
progress.remove(b);
processing.remove(b);
return true;
});
}
private BlockPlaceHandler onPlace() {
return new BlockPlaceHandler(false) {
@Override
public void onPlayerPlace(BlockPlaceEvent e) {
SimpleHologram.update(e.getBlock(), "&7Idling...");
}
};
}
@Override
public String getInventoryTitle() {
return "&6GEO-Miner";

24
src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/gps/ElevatorPlate.java
View File

@ -12,6 +12,7 @@ import org.bukkit.Material;
import org.bukkit.NamespacedKey;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.inventory.ItemStack;
import io.github.thebusybiscuit.cscorelib2.chat.ChatColors;
@ -20,6 +21,7 @@ import io.github.thebusybiscuit.cscorelib2.chat.json.ClickEvent;
import io.github.thebusybiscuit.cscorelib2.chat.json.CustomBookInterface;
import io.github.thebusybiscuit.cscorelib2.chat.json.HoverEvent;
import io.github.thebusybiscuit.cscorelib2.item.CustomItem;
import io.github.thebusybiscuit.slimefun4.core.handlers.BlockPlaceHandler;
import io.github.thebusybiscuit.slimefun4.core.handlers.BlockUseHandler;
import io.github.thebusybiscuit.slimefun4.implementation.SlimefunPlugin;
import io.github.thebusybiscuit.slimefun4.implementation.items.SimpleSlimefunItem;
@ -28,9 +30,6 @@ import io.papermc.lib.PaperLib;
import me.mrCookieSlime.CSCoreLibPlugin.general.Inventory.ChestMenu;
import me.mrCookieSlime.Slimefun.Lists.RecipeType;
import me.mrCookieSlime.Slimefun.Objects.Category;
import me.mrCookieSlime.Slimefun.Objects.SlimefunBlockHandler;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.UnregisterReason;
import me.mrCookieSlime.Slimefun.api.BlockStorage;
import me.mrCookieSlime.Slimefun.api.Slimefun;
import me.mrCookieSlime.Slimefun.api.SlimefunItemStack;
@ -43,19 +42,19 @@ public class ElevatorPlate extends SimpleSlimefunItem<BlockUseHandler> {
public ElevatorPlate(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe, ItemStack recipeOutput) {
super(category, item, recipeType, recipe, recipeOutput);
SlimefunItem.registerBlockHandler(getID(), new SlimefunBlockHandler() {
addItemHandler(onPlace());
}
private BlockPlaceHandler onPlace() {
return new BlockPlaceHandler(false) {
@Override
public void onPlace(Player p, Block b, SlimefunItem item) {
public void onPlayerPlace(BlockPlaceEvent e) {
Block b = e.getBlock();
BlockStorage.addBlockInfo(b, DATA_KEY, "&rFloor #0");
BlockStorage.addBlockInfo(b, "owner", p.getUniqueId().toString());
BlockStorage.addBlockInfo(b, "owner", e.getPlayer().getUniqueId().toString());
}
@Override
public boolean onBreak(Player p, Block b, SlimefunItem item, UnregisterReason reason) {
return true;
}
});
};
}
public Set<UUID> getUsers() {
@ -136,6 +135,7 @@ public class ElevatorPlate extends SimpleSlimefunItem<BlockUseHandler> {
}
Location destination = new Location(player.getWorld(), block.getX() + 0.5, block.getY() + 0.4, block.getZ() + 0.5, yaw, player.getEyeLocation().getPitch());
PaperLib.teleportAsync(player, destination).thenAccept(teleported -> {
if (teleported.booleanValue()) {
player.sendTitle(ChatColor.WHITE + ChatColors.color(floor), null, 20, 60, 20);

33
src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/gps/GPSTransmitter.java
View File

@ -3,19 +3,18 @@ package io.github.thebusybiscuit.slimefun4.implementation.items.gps;
import java.util.UUID;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.inventory.ItemStack;
import io.github.thebusybiscuit.slimefun4.core.attributes.EnergyNetComponent;
import io.github.thebusybiscuit.slimefun4.core.handlers.BlockPlaceHandler;
import io.github.thebusybiscuit.slimefun4.core.networks.energy.EnergyNetComponentType;
import io.github.thebusybiscuit.slimefun4.implementation.SlimefunPlugin;
import io.github.thebusybiscuit.slimefun4.implementation.items.SimpleSlimefunItem;
import me.mrCookieSlime.CSCoreLibPlugin.Configuration.Config;
import me.mrCookieSlime.Slimefun.Lists.RecipeType;
import me.mrCookieSlime.Slimefun.Objects.Category;
import me.mrCookieSlime.Slimefun.Objects.SlimefunBlockHandler;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.UnregisterReason;
import me.mrCookieSlime.Slimefun.Objects.handlers.BlockTicker;
import me.mrCookieSlime.Slimefun.api.BlockStorage;
import me.mrCookieSlime.Slimefun.api.SlimefunItemStack;
@ -26,22 +25,24 @@ public abstract class GPSTransmitter extends SimpleSlimefunItem<BlockTicker> imp
public GPSTransmitter(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) {
super(category, item, recipeType, recipe);
SlimefunItem.registerBlockHandler(getID(), new SlimefunBlockHandler() {
@Override
public void onPlace(Player p, Block b, SlimefunItem item) {
BlockStorage.addBlockInfo(b, "owner", p.getUniqueId().toString());
}
@Override
public boolean onBreak(Player p, Block b, SlimefunItem item, UnregisterReason reason) {
UUID owner = UUID.fromString(BlockStorage.getLocationInfo(b.getLocation(), "owner"));
SlimefunPlugin.getGPSNetwork().updateTransmitter(b.getLocation(), owner, false);
return true;
}
addItemHandler(onPlace());
registerBlockHandler(getID(), (p, b, stack, reason) -> {
UUID owner = UUID.fromString(BlockStorage.getLocationInfo(b.getLocation(), "owner"));
SlimefunPlugin.getGPSNetwork().updateTransmitter(b.getLocation(), owner, false);
return true;
});
}
private BlockPlaceHandler onPlace() {
return new BlockPlaceHandler(false) {
@Override
public void onPlayerPlace(BlockPlaceEvent e) {
BlockStorage.addBlockInfo(e.getBlock(), "owner", e.getPlayer().getUniqueId().toString());
}
};
}
public abstract int getMultiplier(int y);
public abstract int getEnergyConsumption();

23
src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/gps/PersonalActivationPlate.java
View File

@ -1,14 +1,12 @@
package io.github.thebusybiscuit.slimefun4.implementation.items.gps;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.inventory.ItemStack;
import io.github.thebusybiscuit.slimefun4.core.handlers.BlockPlaceHandler;
import me.mrCookieSlime.Slimefun.Lists.RecipeType;
import me.mrCookieSlime.Slimefun.Objects.Category;
import me.mrCookieSlime.Slimefun.Objects.SlimefunBlockHandler;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.UnregisterReason;
import me.mrCookieSlime.Slimefun.api.BlockStorage;
import me.mrCookieSlime.Slimefun.api.SlimefunItemStack;
@ -17,17 +15,16 @@ public class PersonalActivationPlate extends SlimefunItem {
public PersonalActivationPlate(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) {
super(category, item, recipeType, recipe);
SlimefunItem.registerBlockHandler(getID(), new SlimefunBlockHandler() {
addItemHandler(onPlace());
}
private BlockPlaceHandler onPlace() {
return new BlockPlaceHandler(false) {
@Override
public void onPlace(Player p, Block b, SlimefunItem item) {
BlockStorage.addBlockInfo(b, "owner", p.getUniqueId().toString());
public void onPlayerPlace(BlockPlaceEvent e) {
BlockStorage.addBlockInfo(e.getBlock(), "owner", e.getPlayer().getUniqueId().toString());
}
@Override
public boolean onBreak(Player p, Block b, SlimefunItem item, UnregisterReason reason) {
return true;
}
});
};
}
}

22
src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/gps/Teleporter.java
View File

@ -1,16 +1,15 @@
package io.github.thebusybiscuit.slimefun4.implementation.items.gps;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.inventory.ItemStack;
import io.github.thebusybiscuit.slimefun4.api.gps.GPSNetwork;
import io.github.thebusybiscuit.slimefun4.api.gps.TeleportationManager;
import io.github.thebusybiscuit.slimefun4.core.handlers.BlockPlaceHandler;
import me.mrCookieSlime.Slimefun.Lists.RecipeType;
import me.mrCookieSlime.Slimefun.Objects.Category;
import me.mrCookieSlime.Slimefun.Objects.SlimefunBlockHandler;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.UnregisterReason;
import me.mrCookieSlime.Slimefun.api.BlockStorage;
import me.mrCookieSlime.Slimefun.api.SlimefunItemStack;
@ -29,18 +28,17 @@ public class Teleporter extends SlimefunItem {
public Teleporter(Category category, SlimefunItemStack item, RecipeType recipeType, ItemStack[] recipe) {
super(category, item, recipeType, recipe);
SlimefunItem.registerBlockHandler(getID(), new SlimefunBlockHandler() {
addItemHandler(onPlace());
}
private BlockPlaceHandler onPlace() {
return new BlockPlaceHandler(false) {
@Override
public void onPlace(Player p, Block b, SlimefunItem item) {
BlockStorage.addBlockInfo(b, "owner", p.getUniqueId().toString());
public void onPlayerPlace(BlockPlaceEvent e) {
BlockStorage.addBlockInfo(e.getBlock(), "owner", e.getPlayer().getUniqueId().toString());
}
@Override
public boolean onBreak(Player p, Block b, SlimefunItem item, UnregisterReason reason) {
return true;
}
});
};
}
}

25
src/main/java/io/github/thebusybiscuit/slimefun4/implementation/items/seasonal/ChristmasPresent.java
View File

@ -3,6 +3,8 @@ package io.github.thebusybiscuit.slimefun4.implementation.items.seasonal;
import java.util.concurrent.ThreadLocalRandom;
import org.bukkit.GameMode;
import org.bukkit.block.Block;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.inventory.ItemStack;
import io.github.thebusybiscuit.cscorelib2.inventory.ItemUtils;
@ -12,8 +14,18 @@ import io.github.thebusybiscuit.slimefun4.implementation.items.SimpleSlimefunIte
import io.github.thebusybiscuit.slimefun4.utils.FireworkUtils;
import me.mrCookieSlime.Slimefun.Lists.RecipeType;
import me.mrCookieSlime.Slimefun.Objects.Category;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
import me.mrCookieSlime.Slimefun.api.SlimefunItemStack;
/**
* The {@link ChristmasPresent} is a seasonal {@link SlimefunItem} that drops a random
* gift when being placed down.
*
* @author TheBusyBiscuit
*
* @see EasterEgg
*
*/
public class ChristmasPresent extends SimpleSlimefunItem<BlockPlaceHandler> implements NotPlaceable {
private final ItemStack[] gifts;
@ -26,22 +38,23 @@ public class ChristmasPresent extends SimpleSlimefunItem<BlockPlaceHandler> impl
@Override
public BlockPlaceHandler getItemHandler() {
return (p, e, item) -> {
if (isItem(item)) {
return new BlockPlaceHandler(false) {
@Override
public void onPlayerPlace(BlockPlaceEvent e) {
e.setCancelled(true);
if (e.getPlayer().getGameMode() != GameMode.CREATIVE) {
ItemUtils.consumeItem(item, false);
}
FireworkUtils.launchRandom(p, 3);
FireworkUtils.launchRandom(e.getPlayer(), 3);
Block b = e.getBlock();
ItemStack gift = gifts[ThreadLocalRandom.current().nextInt(gifts.length)].clone();
e.getBlockPlaced().getWorld().dropItemNaturally(e.getBlockPlaced().getLocation(), gift);
return true;
b.getWorld().dropItemNaturally(b.getLocation(), gift);
}
return false;
};
}

6
src/main/java/io/github/thebusybiscuit/slimefun4/implementation/listeners/BlockListener.java
View File

@ -70,12 +70,12 @@ public class BlockListener implements Listener {
BlockStorage.addBlockInfo(e.getBlock(), "id", sfItem.getID(), true);
SlimefunBlockHandler blockHandler = SlimefunPlugin.getRegistry().getBlockHandlers().get(sfItem.getID());
if (blockHandler != null) {
blockHandler.onPlace(e.getPlayer(), e.getBlock(), sfItem);
}
else {
sfItem.callItemHandler(BlockPlaceHandler.class, handler -> handler.onBlockPlace(e.getPlayer(), e, item));
}
sfItem.callItemHandler(BlockPlaceHandler.class, handler -> handler.onPlayerPlace(e));
}
}
}

9
src/main/java/me/mrCookieSlime/Slimefun/Objects/SlimefunBlockHandler.java
View File

@ -4,6 +4,7 @@ import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.Event;
import io.github.thebusybiscuit.slimefun4.core.handlers.BlockPlaceHandler;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.SlimefunItem;
import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.UnregisterReason;
@ -15,7 +16,8 @@ import me.mrCookieSlime.Slimefun.Objects.SlimefunItem.UnregisterReason;
* {@code SlimefunItem.registerBlockHandler(String, SlimefunBlockHandler); }
*
* @author TheBusyBiscuit
*
*
*
*/
@FunctionalInterface
public interface SlimefunBlockHandler {
@ -24,6 +26,8 @@ public interface SlimefunBlockHandler {
* This method gets called when the {@link Block} is placed.
* Use this method to initialize block data.
*
* @deprecated Use a {@link BlockPlaceHandler} instead
*
* @param p
* The {@link Player} who placed it
* @param b
@ -31,8 +35,9 @@ public interface SlimefunBlockHandler {
* @param item
* The {@link SlimefunItem} that will be stored inside the {@link Block}
*/
@Deprecated
default void onPlace(Player p, Block b, SlimefunItem item) {
// This method can optionally be implemented by classes implementing it.
// This has been deprecated
}
/**