so://phie

blob: e081e49d4919442e1f538d8f1e1cede71f703c1f (8869 bytes)[doc][blame][raw]

  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}