so://phie

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