poppy

A feature-rich Minecraft plugin which enhances gaming experience
git clone git://soophie.de/poppy

Added AutoBreakerModule, AutoPlacerModule, HopperSorterModule and fixed bug

commit: 06e6bbe78513f4b31c4f6c9f02b9c95741e049df
parent: 9f8579ccd74178430ea77ffba3ace8dc7ae1b756
author: chunksize <reisingerluca@gmail.com>
time: 2023-02-17 14:03

8 file(s) changed, 755 insertion(s), 73 deletion(s)[browse files]

M src/poppy/Config.java
M src/poppy/Main.java
M src/poppy/Utils.java
A src/poppy/modules/AutoBreakerModule.java
A src/poppy/modules/AutoPlacerModule.java
M src/poppy/modules/CommonModule.java
A src/poppy/modules/HopperSorterModule.java
M src/poppy/modules/SpawnerModule.java

src/poppy/Config.java [new file] [old file]

12
13public class Config
14{
15    private File file;
16    private FileConfiguration configuration;
15	private File file;
16	private FileConfiguration configuration;
17
18    public Config(final String path)
19    {
20        this.file = new File(path);
21        this.configuration = YamlConfiguration.loadConfiguration(this.file);
22    }
18	public Config(final String path)
19	{
20		this.file = new File(path);
21		this.configuration = YamlConfiguration.loadConfiguration(this.file);
22	}
23
24    public void setHome(final Player player) throws IOException
25    {
26        final String path = "home." + player.getDisplayName();
27        final Location location = Utils.calcBlockCenter(player.getLocation());
28    
29        this.configuration.set(path, location);
30        this.configuration.save(this.file);
31    }
24	public void setHome(final Player player) throws IOException
25	{
26		final String path = "home." + player.getDisplayName();
27		final Location location = Utils.calcBlockCenter(player.getLocation());
28	
29		this.configuration.set(path, location);
30		this.configuration.save(this.file);
31	}
32
33    public Location getHome(final Player player)
34    {
35        final String path = "home." + player.getDisplayName();
36    
37        return this.configuration.getLocation(path);
38    }
33	public Location getHome(final Player player)
34	{
35		final String path = "home." + player.getDisplayName();
36	
37		return this.configuration.getLocation(path);
38	}
39
40    public boolean setWarp(final String name, final Location location) throws IOException
41    {
42        final String path = "warp." + name;
40	public boolean setWarp(final String name, final Location location) throws IOException
41	{
42		final String path = "warp." + name;
43
44        if(this.configuration.getLocation(path) != null)
45        {
46            return false;
47        }
48    
49        this.configuration.set(path, Utils.calcBlockCenter(location));
50        this.configuration.save(this.file);
44		if(this.configuration.getLocation(path) != null)
45		{
46			return false;
47		}
48	
49		this.configuration.set(path, Utils.calcBlockCenter(location));
50		this.configuration.save(this.file);
51
52        return true;
53    }
52		return true;
53	}
54
55    public Location getWarp(final String name)
56    {
57        final String path = "warp." + name;
58    
59        return this.configuration.getLocation(path);
60    }
55	public Location getWarp(final String name)
56	{
57		final String path = "warp." + name;
58	
59		return this.configuration.getLocation(path);
60	}
61
62    public List<String> getInfoPages()
63    {
64        final String path = "info";
65        List<String> pages = null;
62	public List<String> getInfoPages()
63	{
64		final String path = "info";
65		List<String> pages = null;
66
67        try
68        {
69            this.configuration.load(this.file);
70            pages = this.configuration.getStringList(path);
71        }
72        catch(Exception ex)
73        {
74            // ignore
75        }
67		try
68		{
69			this.configuration.load(this.file);
70			pages = this.configuration.getStringList(path);
71		}
72		catch(Exception ex)
73		{
74			// ignore
75		}
76
77        if(pages == null)
78        {
79            pages = new ArrayList<>();
80        }
77		if(pages == null)
78		{
79			pages = new ArrayList<>();
80		}
81
82        return pages;
83    }
82		return pages;
83	}
84}

src/poppy/Main.java [new file] [old file]

15import org.bukkit.plugin.PluginManager;

16import org.bukkit.plugin.java.JavaPlugin;

18import poppy.modules.AutoBreakerModule;

19import poppy.modules.AutoPlacerModule;

20import poppy.modules.AutoWorkbenchModule;

21import poppy.modules.CauldronModule;

22import poppy.modules.ChairModule;

23import poppy.modules.DoubleDoorModule;

24import poppy.modules.HopperSorterModule;

25import poppy.modules.CommonModule;

26import poppy.modules.LeavesDecayModule;

27import poppy.modules.SpawnerModule;

40	private LeavesDecayModule leavesDecayModule;
41	private CauldronModule cauldronModule;
42	private SpawnerModule spawnerModule;
43	private HopperSorterModule hopperSorterModule;
44	private AutoPlacerModule autoPlacerModule;
45	private AutoBreakerModule autoBreakerModule;
46
47	@Override
48	public void onEnable()

72
73		spawnerModule = new SpawnerModule();
74		pluginManager.registerEvents(spawnerModule, this);
75
76		hopperSorterModule = new HopperSorterModule();
77		pluginManager.registerEvents(hopperSorterModule, this);
78
79		autoPlacerModule = new AutoPlacerModule(this);
80		pluginManager.registerEvents(autoPlacerModule, this);
81
82		autoBreakerModule = new AutoBreakerModule(this);
83		pluginManager.registerEvents(autoBreakerModule, this);
84	}
85
86	@Override

src/poppy/Utils.java [new file] [old file]

247	{
248		return from.getWorld().getName().equals(to.getWorld().getName());
249	}
250
251	public static boolean randomlyReduceDurability(final int level)
252	{
253		final float chance = 100.0f / (level + 1);
254		return Math.random() * 100 <= chance;
255	}
256}

src/poppy/modules/AutoBreakerModule.java [new file]

1package poppy.modules;
2
3import java.util.HashSet;
4
5import org.bukkit.Bukkit;
6import org.bukkit.Material;
7import org.bukkit.Tag;
8import org.bukkit.block.Block;
9import org.bukkit.block.BlockFace;
10import org.bukkit.block.BlockState;
11import org.bukkit.block.Chest;
12import org.bukkit.block.Dispenser;
13import org.bukkit.block.data.Directional;
14import org.bukkit.enchantments.Enchantment;
15import org.bukkit.event.EventHandler;
16import org.bukkit.event.Listener;
17import org.bukkit.event.block.BlockDispenseEvent;
18import org.bukkit.inventory.Inventory;
19import org.bukkit.inventory.ItemStack;
20import org.bukkit.inventory.meta.Damageable;
21import org.bukkit.inventory.meta.ItemMeta;
22import org.bukkit.plugin.Plugin;
23
24import poppy.Utils;
25
26public class AutoBreakerModule implements Listener
27{
28	private Plugin plugin;
29
30	public AutoBreakerModule(Plugin plugin)
31	{
32		this.plugin = plugin;
33	}
34
35	@EventHandler
36	public void onBlockDispenseEvent(BlockDispenseEvent event)
37	{
38		final Block block = event.getBlock();
39		final BlockState blockState = block.getState();
40		final ItemStack item = event.getItem();
41
42		if(blockState instanceof Dispenser)
43		{
44			final Dispenser dispenser = (Dispenser) blockState;
45
46			if(dispenser.getCustomName().toLowerCase().equals("breaker"))
47			{
48				event.setCancelled(true);
49
50				if(block.getBlockData() instanceof Directional)
51				{
52					final Directional direction = (Directional) dispenser.getBlockData();
53					final Block faceBlock = dispenser.getBlock().getRelative(direction.getFacing());
54
55					final HashSet<ItemStack> drops = new HashSet<ItemStack>(faceBlock.getDrops(item));
56
57					if(item.getType().toString().endsWith("_PICKAXE"))
58					{
59						if(Tag.MINEABLE_PICKAXE.isTagged(faceBlock.getType()))
60						{
61							if(!addItemToChest(direction, dispenser, drops))
62							{
63								setDamage(item, dispenser);
64								faceBlock.breakNaturally(item);
65							}
66							else
67							{
68								setDamage(item, dispenser);
69								faceBlock.setType(Material.AIR);
70							}
71						}
72					}
73
74					if(item.getType().toString().endsWith("_AXE"))
75					{
76						if(Tag.MINEABLE_AXE.isTagged(faceBlock.getType()))
77						{
78							if(!addItemToChest(direction, dispenser, drops))
79							{
80								setDamage(item, dispenser);
81								faceBlock.breakNaturally(item);
82							}
83							else
84							{
85								setDamage(item, dispenser);
86								faceBlock.setType(Material.AIR);
87							}
88						}
89					}
90
91					if(item.getType().toString().endsWith("_SHOVEL"))
92					{
93						if(Tag.MINEABLE_SHOVEL.isTagged(faceBlock.getType()))
94						{
95							if(!addItemToChest(direction, dispenser, drops))
96							{
97								setDamage(item, dispenser);
98								faceBlock.breakNaturally(item);
99							}
100							else
101							{
102								setDamage(item, dispenser);
103								faceBlock.setType(Material.AIR);
104							}
105						}
106					}
107
108					if(item.getType().toString().endsWith("_HOE"))
109					{
110						if(Tag.MINEABLE_HOE.isTagged(faceBlock.getType()))
111						{
112							if(!addItemToChest(direction, dispenser, drops))
113							{
114								setDamage(item, dispenser);
115								faceBlock.breakNaturally(item);
116							}
117							else
118							{
119								setDamage(item, dispenser);
120								faceBlock.setType(Material.AIR);
121							}
122						}
123					}
124
125					if(item.getType().toString().endsWith("_PICKAXE") && !Utils.isAir(faceBlock.getType())
126					&& !Tag.MINEABLE_PICKAXE.isTagged(faceBlock.getType()) 
127					&& !Tag.MINEABLE_HOE.isTagged(faceBlock.getType())
128					&& !Tag.MINEABLE_AXE.isTagged(faceBlock.getType())
129					&& !Tag.MINEABLE_SHOVEL.isTagged(faceBlock.getType()))
130					 {
131						setDamage(item, dispenser);
132						faceBlock.breakNaturally(item);
133					 }
134				}
135			}
136		}
137	}
138
139	public static boolean isInventoryFullList(Inventory inventory, HashSet<ItemStack> items)
140	{
141		final HashSet<ItemStack> itemsCopy = new HashSet<ItemStack>(items);
142
143		for(ItemStack item : itemsCopy)
144		{
145			if(!Utils.isInventoryFull(inventory, item))
146			{
147				itemsCopy.remove(item);
148			}
149		}
150		return itemsCopy.size() != 0;
151	}
152
153	public static boolean addItemToChest(Directional direction, Dispenser dispenser, HashSet<ItemStack> items)
154	{
155		Chest chest = null;
156		boolean succeeded = false;
157
158		for(BlockFace face : faces)
159		{
160			if(!face.equals(direction.getFacing()) && chest == null)
161			{
162				final Block blockAtFacing = dispenser.getBlock().getRelative(face);
163				final BlockState blockStateAtFacing = blockAtFacing.getState();
164
165				if(blockAtFacing.getType().equals(Material.CHEST) && blockStateAtFacing instanceof Chest)
166				{
167					final Chest chestBlock = (Chest) blockStateAtFacing;
168
169					if(!isInventoryFullList(chestBlock.getInventory(), items))
170					{
171						for(ItemStack item : items)
172						{
173							chestBlock.getInventory().addItem(item);
174						}
175						succeeded = true;
176						break;
177					}
178					chest = chestBlock;
179				}
180			}
181		}
182		return succeeded;
183	}
184
185	public void setDamage(ItemStack item, Dispenser dispenser)
186	{
187		Bukkit.getScheduler().runTaskLater(plugin, () -> {
188			if(Utils.randomlyReduceDurability(item.getEnchantmentLevel(Enchantment.DURABILITY)))
189			{
190				final ItemMeta itemMeta = item.getItemMeta();
191				final int slot = dispenser.getInventory().first(item);
192				
193				if(itemMeta instanceof Damageable && slot != -1)
194				{
195					final ItemStack itemstack = dispenser.getInventory().getItem(slot);
196					final Damageable itemDamage = (Damageable) itemstack.getItemMeta();
197					
198					if(itemDamage.getDamage() == 0)
199					{
200						itemDamage.setDamage(1);
201					}
202					else if(itemDamage.getDamage() != 0)
203					{
204						final int addedDamage = itemDamage.getDamage() + 1;
205
206						if(addedDamage < itemstack.getType().getMaxDurability())
207						{
208							itemDamage.setDamage(addedDamage);
209						}
210						else
211						{
212							itemstack.setType(Material.AIR);
213						}
214					}
215					itemstack.setItemMeta(itemDamage);
216					dispenser.getInventory().setItem(slot, itemstack);
217				}
218			}
219		}, 1);
220	}
221	
222	private static final BlockFace[] faces = {
223		BlockFace.DOWN,
224		BlockFace.UP,
225		BlockFace.NORTH,
226		BlockFace.EAST,
227		BlockFace.SOUTH,
228		BlockFace.WEST
229	};
230}

src/poppy/modules/AutoPlacerModule.java [new file]

1package poppy.modules;
2
3import java.util.Set;
4
5import org.bukkit.Bukkit;
6import org.bukkit.Material;
7import org.bukkit.Tag;
8import org.bukkit.block.Block;
9import org.bukkit.block.BlockState;
10import org.bukkit.block.Dispenser;
11import org.bukkit.block.data.Directional;
12import org.bukkit.event.EventHandler;
13import org.bukkit.event.Listener;
14import org.bukkit.event.block.BlockDispenseEvent;
15import org.bukkit.inventory.ItemStack;
16import org.bukkit.inventory.meta.BlockStateMeta;
17import org.bukkit.inventory.meta.ItemMeta;
18import org.bukkit.plugin.Plugin;
19
20import poppy.Utils;
21
22public class AutoPlacerModule implements Listener
23{
24	private Plugin plugin;
25
26	public AutoPlacerModule(Plugin plugin)
27	{
28		this.plugin = plugin;
29	}
30
31	@EventHandler
32	public void onBlockDispenseEvent(BlockDispenseEvent event)
33	{
34		final Block block = event.getBlock();
35		final BlockState blockState = block.getState();
36		final ItemStack item = event.getItem();
37
38		if(blockState instanceof Dispenser)
39		{
40			Dispenser dispenser = (Dispenser) blockState;
41
42			if(dispenser.getCustomName().toLowerCase().equals("placer"))
43			{
44				event.setCancelled(true);
45
46				if(block.getBlockData() instanceof Directional)
47				{
48					final Directional direction = (Directional) dispenser.getBlockData();
49					final Block faceBlock = dispenser.getBlock().getRelative(direction.getFacing());
50
51					if(item.getType().isBlock() && Utils.isAir(faceBlock.getType()) && !isShulkerboxContend(item))
52					{
53						faceBlock.setType(item.getType());
54						removeSnapshotItem(dispenser, item.getType(), 1);
55					}
56				}
57
58				if(isShulkerboxContend(item))
59				{
60					event.setCancelled(false);
61				}
62			}
63		}
64	}
65
66	public boolean isShulkerboxContend(ItemStack itemStack)
67	{
68		final ItemMeta itemMeta = itemStack.getItemMeta();
69		final Set<Material> shulkerboxes = Tag.SHULKER_BOXES.getValues();
70
71		for(Material material : shulkerboxes)
72		{
73			if(itemStack.getType().equals(material) && itemMeta instanceof BlockStateMeta)
74			{
75				return true;
76			}
77		}
78		return false;
79	}
80	
81	public void removeSnapshotItem(Dispenser dispenser, Material material, int amount)
82	{
83		Bukkit.getScheduler().runTaskLater(plugin, () -> {
84			dispenser.getSnapshotInventory().addItem(new ItemStack(material, -amount));
85			dispenser.update();
86		}, 1);
87	}
88}

src/poppy/modules/CommonModule.java [new file] [old file]

164		{
165			Player clickedPlayer = (Player) event.getRightClicked();
166
167			if(clickedPlayer.getInventory().getHelmet().getType().equals(Material.SADDLE))
167			if(clickedPlayer.getInventory().getHelmet().getType().equals(Material.SADDLE) && player.getPassengers().size() < 0)
168			{
169				clickedPlayer.addPassenger(player);
170			}

src/poppy/modules/HopperSorterModule.java [new file]

1package poppy.modules;
2
3import java.util.HashSet;
4import java.util.ListIterator;
5import java.util.Set;
6
7import org.bukkit.Location;
8import org.bukkit.Material;
9import org.bukkit.Tag;
10import org.bukkit.block.Block;
11import org.bukkit.block.ShulkerBox;
12import org.bukkit.entity.Entity;
13import org.bukkit.entity.EntityType;
14import org.bukkit.entity.ItemFrame;
15import org.bukkit.event.EventHandler;
16import org.bukkit.event.Listener;
17import org.bukkit.event.inventory.InventoryMoveItemEvent;
18import org.bukkit.event.inventory.InventoryPickupItemEvent;
19import org.bukkit.event.inventory.InventoryType;
20import org.bukkit.inventory.Inventory;
21import org.bukkit.inventory.ItemStack;
22import org.bukkit.inventory.meta.BlockStateMeta;
23import org.bukkit.inventory.meta.ItemMeta;
24
25import poppy.Utils;
26
27public class HopperSorterModule implements Listener
28{
29	@EventHandler
30	public void onInventoryMoveItem(InventoryMoveItemEvent event)
31	{
32		final Location targetHopperLocation = event.getDestination().getLocation().clone();
33		final Block targetHopper = targetHopperLocation.getBlock();
34
35		if(targetHopper.getType() != Material.HOPPER)
36		{
37			return;
38		}
39
40		ItemFrame[] itemFrames = getBlockItemFrames(targetHopper);
41
42		if(itemFrames.length == 0)
43		{
44			return;
45		}
46
47		event.setCancelled(true);
48
49		final HashSet<ItemStack> allowedItems = new HashSet <ItemStack>();
50		final HashSet<ItemStack> allowedItemExact = new HashSet <ItemStack>();
51
52		saveItemsInLists(itemFrames, allowedItems, allowedItemExact);
53		addInventoryItems(allowedItems, allowedItemExact, event.getSource(), event.getDestination());
54
55		for(ItemStack item : allowedItems)
56		{
57			if(event.getItem().getType().equals(item.getType()))
58			{
59				event.setCancelled(false);
60			}
61		}
62
63		for(ItemStack item : allowedItemExact)
64		{
65			if(event.getItem().equals(item) && event.getItem().getItemMeta().equals(item.getItemMeta()))
66			{
67				event.setCancelled(false);
68			}
69		}
70	}
71
72	@EventHandler
73	public void onInventoryPickupItem(InventoryPickupItemEvent event)
74	{
75		final Location targetHopperLocation = event.getInventory().getLocation().clone();
76		final Block targetHopper = targetHopperLocation.getBlock();
77
78		if(!event.getInventory().getType().equals(InventoryType.HOPPER))
79		{
80			return;
81		}
82
83		ItemFrame[] itemFrames = getBlockItemFrames(targetHopper);
84
85		if(itemFrames.length == 0)
86		{
87			return;
88		}
89
90		event.setCancelled(true);
91
92		final HashSet<ItemStack> allowedItems = new HashSet <ItemStack>();
93		final HashSet<ItemStack> allowedItemExact = new HashSet <ItemStack>();
94
95		saveItemsInLists(itemFrames, allowedItems, allowedItemExact);
96
97		for(ItemStack item : allowedItems)
98		{
99			if(event.getItem().getItemStack().getType().equals(item.getType()))
100			{
101				event.setCancelled(false);
102			}
103		}
104
105		for(ItemStack item : allowedItemExact)
106		{
107			if(event.getItem().getItemStack().getType().equals(item.getType()) && event.getItem().getItemStack().getItemMeta().equals(item.getItemMeta()))
108			{
109				event.setCancelled(false);
110			}
111		}
112	}
113
114	public void addInventoryItems(HashSet<ItemStack> allowedItems, HashSet<ItemStack> allowedItemsExact, Inventory inventory, Inventory destinationInv)
115	{
116		ItemStack dummyItem = null;
117		final ListIterator<ItemStack> iterator = inventory.iterator();
118
119		while(iterator.hasNext())
120		{
121			final ItemStack item = iterator.next();
122
123			for(ItemStack allowedItemExact : allowedItemsExact)
124			{
125				if(Utils.isEmpty(item))
126				{
127					continue;
128				}
129
130				if(item.getType().equals(allowedItemExact.getType()) && item.getItemMeta().equals(allowedItemExact.getItemMeta()) && dummyItem == null)
131				{
132					final HashSet<ItemStack> nullItems = new HashSet <ItemStack>();
133					final int slot = inventory.first(item);
134
135					if(slot > 0)
136					{
137						for (int i = slot -1 ; i >= 0; i--)
138						{
139							Boolean filterdItem = false;
140							final ItemStack nullItem = inventory.getItem(i);
141
142							if(nullItem != null)
143							{
144								for(ItemStack allowedItem1 : allowedItems)
145								{
146									if(allowedItem1.getType().equals(nullItem.getType()))
147									{
148										filterdItem = true;
149									}
150								}
151
152								for(ItemStack allowedItemExact1 : allowedItemsExact)
153								{
154									if(allowedItemExact1.getType().equals(nullItem.getType()) && allowedItemExact1.getItemMeta().equals(nullItem.getItemMeta()))
155									{
156										filterdItem = true;
157									}
158								}
159
160								if(!filterdItem)
161								{
162									nullItems.add(inventory.getItem(i));
163								}
164							}
165						}
166					}
167
168					if(nullItems.size() != 0)
169					{
170						if(!Utils.isInventoryFull(destinationInv, item))
171						{
172							final ItemStack clonedItem = item.clone();
173							clonedItem.setAmount(1);
174
175							destinationInv.addItem(clonedItem);
176							item.setAmount(item.getAmount() - 1);
177							dummyItem = item;
178							break;
179						}
180					}
181				}
182			}
183
184			for(ItemStack allowedItem : allowedItems)
185			{
186				if(Utils.isEmpty(item))
187				{
188					continue;
189				}
190
191				if(item.getType() == allowedItem.getType() && dummyItem == null)
192				{
193					final HashSet<ItemStack> nullItems = new HashSet <ItemStack>();
194					final  int slot = inventory.first(item);
195
196					if(slot > 0)
197					{
198						for (int i = slot - 1 ; i >= 0; i--)
199						{
200							Boolean filterdItem = false;
201							final ItemStack nullItem = inventory.getItem(i);
202
203							if(nullItem != null)
204							{
205								for(ItemStack allowedItem1 : allowedItems)
206								{
207									if(allowedItem1.getType().equals(nullItem.getType()))
208									{
209										filterdItem = true;
210									}
211								}
212
213								for(ItemStack allowedItemExact1 : allowedItemsExact)
214								{
215									if(allowedItemExact1.getType().equals(nullItem.getType()) && allowedItemExact1.getItemMeta().equals(nullItem.getItemMeta()))
216									{
217										filterdItem = true;
218									}
219								}
220
221								if(!filterdItem)
222								{
223									nullItems.add(inventory.getItem(i));
224								}
225							}
226						}
227					}
228
229					if(nullItems.size() != 0)
230					{
231						if(!Utils.isInventoryFull(destinationInv, item))
232						{
233							final ItemStack clonedItem = item.clone();
234							clonedItem.setAmount(1);
235
236							destinationInv.addItem(clonedItem);
237							item.setAmount(item.getAmount() - 1);
238							dummyItem = item;
239							break;
240						}
241					}
242				}
243			}
244		}
245	}
246
247	public void saveItemsInLists(ItemFrame[] itemFrames, HashSet<ItemStack> allowedItems, HashSet<ItemStack> allowedItemExact)
248	{
249		for(ItemFrame itemFrame : itemFrames)
250		{
251			if(itemFrame.getType() == EntityType.GLOW_ITEM_FRAME)
252			{
253				allowedItemExact.add(itemFrame.getItem());
254
255				for(ItemStack items : getShulkerboxContent(itemFrame.getItem()))
256				{
257					allowedItemExact.add(items);
258				}
259			}
260			else if(itemFrame.getType() == EntityType.ITEM_FRAME)
261			{
262				allowedItems.add(itemFrame.getItem());
263
264				for(ItemStack items : getShulkerboxContent(itemFrame.getItem()))
265				{
266					allowedItems.add(items);
267				}
268			}
269		}
270	}
271
272	public static ItemFrame[] getBlockItemFrames(Block block)
273	{
274		final HashSet<ItemFrame> itemframes = new HashSet <ItemFrame>();
275
276		for(Entity entity : getNearbyEntities(block.getLocation().add(.5, .5, .5), 1))
277		{
278			if(entity instanceof ItemFrame)
279			{
280				final ItemFrame itemFrame = (ItemFrame) entity;
281				itemframes.add(itemFrame);
282			}
283		}
284		return itemframes.toArray(new ItemFrame[itemframes.size()]);
285	}
286
287	public static ItemStack[] getShulkerboxContent(ItemStack itemStack)
288	{
289		final HashSet<ItemStack> itemList = new HashSet<ItemStack>();
290
291		if(itemStack.getType().equals(Material.AIR))
292		{
293			return itemList.toArray(new ItemStack[itemList.size()]);
294		}
295
296		final ItemMeta itemMeta = itemStack.getItemMeta();
297		final Set<Material> shulkerboxes = Tag.SHULKER_BOXES.getValues();
298
299		for(Material material : shulkerboxes)
300		{
301			if(itemStack.getType().equals(material) && itemMeta instanceof BlockStateMeta)
302			{
303				final BlockStateMeta blockMeta = (BlockStateMeta) itemMeta;
304				final ShulkerBox shulkerBox = (ShulkerBox) blockMeta.getBlockState();
305
306				for(ItemStack item : shulkerBox.getInventory().getContents().clone())
307				{
308					if(item != null)
309					{
310						item.setAmount(1);
311						itemList.add(item);
312					}
313				}
314			}
315		}
316		return itemList.toArray(new ItemStack[itemList.size()]);
317	}
318
319	public static Entity[] getNearbyEntities(Location l, int radius)
320	{
321		int chunkRadius = radius < 16 ? 1 : (radius - (radius % 16)) / 16;
322		HashSet <Entity> radiusEntities = new HashSet < Entity > ();
323	 
324		for (int chX = 0 - chunkRadius; chX <= chunkRadius; chX++) {
325			for (int chZ = 0 - chunkRadius; chZ <= chunkRadius; chZ++) {
326				int x = (int) l.getX(), y = (int) l.getY(), z = (int) l.getZ();
327				for (Entity e: new Location(l.getWorld(), x + (chX * 16), y, z + (chZ * 16)).getChunk().getEntities()) {
328					if (e.getLocation().distance(l) <= radius && e.getLocation().getBlock() != l.getBlock())
329						radiusEntities.add(e);
330				}
331			}
332		}
333		return radiusEntities.toArray(new Entity[radiusEntities.size()]);
334	}
335}

src/poppy/modules/SpawnerModule.java [new file] [old file]

25		final Block block = event.getBlock();
26		final Player player = event.getPlayer();
27		final ItemStack itemInMainHand = player.getInventory().getItemInMainHand();
28		final Location blockLocation = block.getLocation();
29
29		if(block.getType() == Material.SPAWNER && itemInMainHand.containsEnchantment(Enchantment.SILK_TOUCH))
30		if(itemInMainHand.containsEnchantment(Enchantment.SILK_TOUCH))
31		{
31			final CreatureSpawner creatureSpawner = (CreatureSpawner) block.getState();
32			final ItemStack spawner = new ItemStack(Material.SPAWNER);
33			final ItemMeta spawnerItemMeta = spawner.getItemMeta();
34			final ArrayList<String> spawneritemLore = new ArrayList<String>();
35			final Location blockLocation = block.getLocation();
36			final BlockStateMeta spawnerblockMeta = (BlockStateMeta) spawner.getItemMeta();
32			if(block.getType() == Material.SPAWNER)
33			{
34				final CreatureSpawner creatureSpawner = (CreatureSpawner) block.getState();
35				final ItemStack spawner = new ItemStack(Material.SPAWNER);
36				final ItemMeta spawnerItemMeta = spawner.getItemMeta();
37				final ArrayList<String> spawneritemLore = new ArrayList<String>();
38				final BlockStateMeta spawnerblockMeta = (BlockStateMeta) spawner.getItemMeta();
39
38			spawneritemLore.add(creatureSpawner.getSpawnedType().toString());
39			spawnerItemMeta.setLore(spawneritemLore);
40			spawner.setItemMeta(spawnerItemMeta);
41			spawnerblockMeta.setBlockState(creatureSpawner);
42			blockLocation.getWorld().dropItemNaturally(blockLocation, spawner);
43			block.setType(Material.AIR);
44			event.setExpToDrop(0);
40				spawneritemLore.add(creatureSpawner.getSpawnedType().toString());
41				spawnerItemMeta.setLore(spawneritemLore);
42				spawner.setItemMeta(spawnerItemMeta);
43				spawnerblockMeta.setBlockState(creatureSpawner);
44				blockLocation.getWorld().dropItemNaturally(blockLocation, spawner);
45				block.setType(Material.AIR);
46				event.setExpToDrop(0);
47			}
48
49			if(block.getType() == Material.BUDDING_AMETHYST)
50			{
51				blockLocation.getWorld().dropItemNaturally(blockLocation, new ItemStack(Material.BUDDING_AMETHYST));
52			}
53		}
54	}
55

so://phie

poppy

Added AutoBreakerModule, AutoPlacerModule, HopperSorterModule and fixed bug