Page MenuHomedesp's stash
Files F575822

ADListener.java
No OneTemporary
Actions

ADListener.java
View Options

package me.despawningbone.antidrop;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import org.bukkit.ChatColor;
import org.bukkit.GameMode;
import org.bukkit.Material;
import org.bukkit.configuration.InvalidConfigurationException;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.PlayerDeathEvent;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.inventory.InventoryCloseEvent;
import org.bukkit.event.player.PlayerDropItemEvent;
import org.bukkit.event.player.PlayerRespawnEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.ItemStack;
import me.despawningbone.antidrop.utils.Timer;
public class ADListener implements Listener {
private ADMain plugin;
public ADListener(ADMain instance) {
plugin = instance;
}
public static HashMap<UUID, List<Integer>> slotsBuffer = new HashMap<UUID, List<Integer>>();
public static List<UUID> cooldown = new ArrayList<UUID>();
private HashMap<UUID, List<Entry<Integer, ItemStack>>> toBeKeeped = new HashMap<UUID, List<Entry<Integer, ItemStack>>>(); //will reset if player didnt respawn in time
public void sendCooldownMessage(Player player, String msg) {
if(!cooldown.contains(player.getUniqueId())) {
player.sendMessage(msg);
cooldown.add(player.getUniqueId());
Timer.cooldown(player);
}
}
@EventHandler
public void onPlayerDropItem(PlayerDropItemEvent event) {
Player player = event.getPlayer();
if(player.getGameMode() != GameMode.CREATIVE) {
if((ConfigHandler.usePerms && player.hasPermission("adp.filter")) || !ConfigHandler.usePerms) {
boolean cancel = filterCheckStart(player, event.getItemDrop().getItemStack()); //filter check
if(cancel) {
event.setCancelled(true);
sendCooldownMessage(player, ADMain.prefix + ChatColor.BLUE + "Item is in the filter list! You will not be able to drop items the filtered list until you remove it with /antidrop remove.");
return;
}
}
if((ConfigHandler.usePerms && player.hasPermission("adp.lockslot")) || !ConfigHandler.usePerms) {
//SlotLock check
if(runSlotCheck(player, player.getInventory().getHeldItemSlot())) {
event.setCancelled(true);
sendCooldownMessage(player, ADMain.prefix + ChatColor.BLUE + "Slot is locked! If you want to unlock it, do /antidrop lockslot and click on the slot you want to unlock.");
return;
}
}
}
}
//checks run in async?
private boolean filterCheckStart(Player player, ItemStack item) {
final List<Boolean> ret = new ArrayList<Boolean>(Arrays.asList(false));
ExecutorService executor = Executors.newFixedThreadPool(1);
executor.execute(new Runnable() {
@Override
public void run() {
if(GUIHandler.filterParam.containsKey(player.getUniqueId())) {
for(int i = 0; i < GUIHandler.filterParam.get(player.getUniqueId()).size(); i++) {
List<Entry<String, Object>> filter = GUIHandler.filterParam.get(player.getUniqueId()).get(i);
boolean success = runFilterCheck(filter, item);
if(success) {
ret.set(0, true);
}
}
}
}
});
executor.shutdown();
try {
executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
}
catch (InterruptedException e) {
e.printStackTrace();
}
return ret.get(0);
}
private boolean runFilterCheck(List<Entry<String, Object>> filter, ItemStack item) {
for(int i = 0; i < filter.size(); i++) {
String checkType = filter.get(i).getKey();
Object value = filter.get(i).getValue();
if(checkType.equals("Exact")) {
YamlConfiguration check = new YamlConfiguration();
YamlConfiguration toCheck = new YamlConfiguration();
try {
check.loadFromString((String) value);
} catch (InvalidConfigurationException e) {
e.printStackTrace(); return false;
}
ItemStack itoCheck = item.clone(); itoCheck.setAmount(1);
toCheck.set("i", itoCheck);
if(!toCheck.saveToString().equals(check.saveToString())){ return false; }
} else {
if(checkType.equals("Name")) {
if(!(item.getItemMeta().hasDisplayName() && item.getItemMeta().getDisplayName().equals(value))) return false;
}
if(checkType.equals("Lore")) {
if(!(item.getItemMeta().hasLore() && item.getItemMeta().getLore().equals(value))) return false;
}
if(checkType.equals("Type")) {
if(!item.getType().equals(value)) return false;
}
if(checkType.equals("Damage")) {
if(item.getDurability() != (short) value) return false;
}
}
}
return true;
}
private boolean runSlotCheck(Player player, int slot) {
//SlotLock check
if(GUIHandler.slotParam.containsKey(player.getUniqueId())) {
if(GUIHandler.slotParam.containsKey(player.getUniqueId()) && !GUIHandler.slotParam.get(player.getUniqueId()).isEmpty()) {
List<Integer> slotlist = GUIHandler.slotParam.get(player.getUniqueId());
for(int i = 0; i < slotlist.size(); i++) {
if(slotlist.get(i) == slot) {
return true;
}
}
}
}
return false;
}
//TODO check if works, update spigot
@EventHandler
public void onPlayerDeath(PlayerDeathEvent event) {
System.out.println(event.getKeepInventory());
if(ConfigHandler.deathKeepEnable && !event.getKeepInventory()) {
Player player = event.getEntity();
if((ConfigHandler.usePerms && player.hasPermission("adp.death.keepfilter")) || (!ConfigHandler.usePerms && player.isOp())) {
System.out.println("deathfil1");
if(GUIHandler.filterParam.containsKey(player.getUniqueId()) && !GUIHandler.filterParam.get(player.getUniqueId()).isEmpty()) {
System.out.println("deathfil2");
List<ItemStack> items = event.getDrops();
ExecutorService executor = Executors.newFixedThreadPool(1);
executor.execute(new Runnable() {
@Override
public void run() {
System.out.println("deathfil3");
//HashMap<Index, times>
HashMap<String, Object> invVal = new HashMap<String, Object>();
List<String> name = new ArrayList<String>();
List<List<String>> lore = new ArrayList<List<String>>();
List<Short> damage = new ArrayList<Short>();
List<Material> type = new ArrayList<Material>();
for(int i = 0; i < items.size(); i++) {
System.out.println("deathfilloop1");
ItemStack item = items.get(i);
name.add((item.hasItemMeta() && item.getItemMeta().hasDisplayName()) ? item.getItemMeta().getDisplayName() : null);
lore.add((item.hasItemMeta() && item.getItemMeta().hasLore()) ? item.getItemMeta().getLore() : null);
damage.add(item.getDurability());
type.add(item.getType());
}
invVal.put("Name", name); invVal.put("Lore", lore); invVal.put("Damage", damage); invVal.put("Type", type);
List<List<Entry<String, Object>>> filters = GUIHandler.filterParam.get(player.getUniqueId());
for(int i = 0; i < filters.size(); i++) {
System.out.println("deathfilloop2:1");
HashMap<Integer, Integer> times = new HashMap<Integer, Integer>();
List<Entry<String, Object>> filter = filters.get(i);
for(int i2 = 0; i2 < filter.size(); i2++) {
System.out.println("deathfilloop2:2");
Entry<String, Object> check = filter.get(i2);
String checkType = check.getKey();
if(checkType.equals("Exact")) {
System.out.println("deathfiltodo");
} else {
System.out.println("deathfilcheck");
@SuppressWarnings("unchecked")
List<Object> list = new ArrayList<Object>((List<Object>) invVal.get(checkType)); //ClassCastException?
Object val = check.getValue();
if(list.contains(val)) {
int index = list.indexOf(val);
for(int i3 = 0; index >= 0; i3++) {
times.put(index + i3, times.containsKey(index) ? times.get(index) + 1 : 1);
System.out.println("Index: " + (index + i3));
list.remove(index);
index = list.indexOf(val);
}
}
}
}
if(times.values().contains(filter.size())) {
System.out.println("deathfil4");
List<Integer> cloneval = new ArrayList<Integer>(times.values());
List<Integer> clonekey = new ArrayList<Integer>(times.keySet());
int mapIndex = cloneval.indexOf(filter.size());
for(int i2 = 0; mapIndex >= 0; i2++) {
System.out.println("MapIndex:" + mapIndex + i2);
System.out.println("Index: " + clonekey.get(mapIndex + i2));
ItemStack item = items.get(clonekey.get(mapIndex + i2)); //check if it is key actually corresponds to value
System.out.println(item);
int slot = player.getInventory().first(item);
Entry<Integer, ItemStack> entry = new AbstractMap.SimpleEntry<Integer, ItemStack>(slot, item);
player.getInventory().clear(slot); //check if it will still appear as a drop or not
items.remove(item);
if(toBeKeeped.containsKey(player.getUniqueId())) {
toBeKeeped.get(player.getUniqueId()).add(entry);
} else {
toBeKeeped.put(player.getUniqueId(), new ArrayList<Entry<Integer, ItemStack>>(Arrays.asList(entry)));
}
cloneval.remove(mapIndex);
mapIndex = cloneval.indexOf(filter.size());
}
}
}
}
});
executor.shutdown();
try {
executor.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
}
catch (InterruptedException e) {
e.printStackTrace();
}
}
}
if((ConfigHandler.usePerms && player.hasPermission("adp.death.keepslot")) || (!ConfigHandler.usePerms && player.isOp())) {
if(GUIHandler.slotParam.containsKey(player.getUniqueId()) && !GUIHandler.slotParam.get(player.getUniqueId()).isEmpty()) {
List<ItemStack> items = event.getDrops();
List<Integer> slots = GUIHandler.slotParam.get(player.getUniqueId());
for(int i = 0; i < slots.size(); i++) {
ItemStack item = player.getInventory().getItem(slots.get(i));
items.remove(item);
Entry<Integer, ItemStack> entry = new AbstractMap.SimpleEntry<Integer, ItemStack>(slots.get(i), item);
if(toBeKeeped.containsKey(player.getUniqueId())) {
toBeKeeped.get(player.getUniqueId()).add(entry);
} else {
toBeKeeped.put(player.getUniqueId(), new ArrayList<Entry<Integer, ItemStack>>(Arrays.asList(entry)));
}
}
}
}
}
}
@EventHandler
public void onPlayerRespawn(PlayerRespawnEvent event) {
Player player = event.getPlayer();
if(toBeKeeped.containsKey(player.getUniqueId()) && !toBeKeeped.get(player.getUniqueId()).isEmpty()) {
List<Entry<Integer, ItemStack>> playerKeep = toBeKeeped.get(player.getUniqueId());
for(int i = 0; i < playerKeep.size(); i++) {
Entry<Integer, ItemStack> entry = playerKeep.get(i);
player.getInventory().setItem(entry.getKey(), entry.getValue());
}
}
}
@EventHandler
public void onInventoryClose(InventoryCloseEvent event) {
Inventory inv = event.getInventory();
Player player = (Player) event.getPlayer();
String sslotLock = ChatColor.GREEN + "Antidrop lock slot";
if(inv.getName().equals(sslotLock)) { //SlotLock GUI
if(GUIHandler.slotParam.containsKey(player.getUniqueId()) && !GUIHandler.slotParam.get(player.getUniqueId()).isEmpty()) {
if(ConfigHandler.eco && ConfigHandler.slotFee > 0) {
if(!((ConfigHandler.usePerms && event.getPlayer().hasPermission("adp.bypass.payment")) || (!ConfigHandler.usePerms && event.getPlayer().isOp()))) {
List<Integer> slots = GUIHandler.slotParam.get(player.getUniqueId());
double money = 0;
if(slotsBuffer.containsKey(player.getUniqueId())) {
money = ConfigHandler.slotFee * (slots.size() - slotsBuffer.get(player.getUniqueId()).size());
} else {
money = ConfigHandler.slotFee * slots.size();
}
if(ADMain.getMoney(player) >= money) {
if(money > 0) {
ADMain.econ.withdrawPlayer(player, money);
player.sendMessage(ADMain.prefix + ChatColor.YELLOW + "$" + money + ChatColor.GREEN + " has been taken from your account.");
}
} else {
if(slotsBuffer.containsKey(player.getUniqueId())) {
GUIHandler.slotParam.put(player.getUniqueId(), slotsBuffer.get(player.getUniqueId()));
} else {
GUIHandler.slotParam.remove(player.getUniqueId());
}
player.sendMessage(ADMain.prefix + ChatColor.RED + "You do not have enough money to perform the slot locks.");
}
}
if(slotsBuffer.containsKey(player.getUniqueId())) {
slotsBuffer.remove(player.getUniqueId());
}
}
plugin.serialize(GUIHandler.slotParam, "SlotData.bin");
}
}
}
@EventHandler
public void onInventoryClick(InventoryClickEvent event) {
if(event.getWhoClicked().getGameMode() != GameMode.CREATIVE) {
if(event.getClickedInventory() != null) {
if(event.getClickedInventory().equals(((Player) event.getWhoClicked()).getInventory())) {
Player player = (Player) event.getWhoClicked();
if((ConfigHandler.usePerms && player.hasPermission("adp.filter")) || !ConfigHandler.usePerms) {
//Filter check
if(ConfigHandler.clickCheck.contains(event.getClick())) { //number key?
boolean cancel = filterCheckStart(player, event.getCurrentItem());
if(cancel) {
event.setCancelled(true);
sendCooldownMessage(player, ADMain.prefix + ChatColor.BLUE + "Item is in the filter list! You will not be able to remove the items in the filtered list from inventory until you remove it with /antidrop remove.");
return;
}
}
}
if((ConfigHandler.usePerms && player.hasPermission("adp.lockslot")) || !ConfigHandler.usePerms) {
//SlotLock check
if(runSlotCheck(player, event.getSlot())) {
event.setCancelled(true);
sendCooldownMessage(player, ADMain.prefix + ChatColor.BLUE + "Slot is locked! If you want to unlock it, do /antidrop lockslot and click on the slot you want to unlock.");
return;
}
}
}
Inventory inv = event.getInventory();
String sslotLock = ChatColor.GREEN + "Antidrop lock slot";
if(inv.getName().equals(sslotLock)) { //SlotLock GUI
if(event.getClickedInventory().getName().equals(sslotLock)) {
Player player = (Player) event.getWhoClicked();
if(event.getCurrentItem() != null && event.getCurrentItem().getType() != Material.AIR) {
int slot = event.getSlot();
if(slot > 35) { slot -= 36; } else slot += 9;
if(event.getCurrentItem().equals(GUIHandler.locked)) {
event.getInventory().setItem(event.getSlot(), player.getInventory().getItem(slot));
GUIHandler.slotParam.get(player.getUniqueId()).remove((Object) slot);
} else {
boolean bypassmax = (ConfigHandler.usePerms && player.hasPermission("adp.bypass.slotmax")) || (!ConfigHandler.usePerms && player.isOp());
if(GUIHandler.slotParam.containsKey(player.getUniqueId()) && !GUIHandler.slotParam.get(player.getUniqueId()).isEmpty()) {
if(bypassmax || !(GUIHandler.slotParam.get(player.getUniqueId()).size() >= ConfigHandler.slotMax)) {
event.getInventory().setItem(event.getSlot(), GUIHandler.locked);
if(!GUIHandler.slotParam.get(player.getUniqueId()).contains(slot)) {
GUIHandler.slotParam.get(player.getUniqueId()).add(slot);
}
} else {
player.sendMessage(ADMain.prefix + ChatColor.RED + "You have reached the slot limit of " + ConfigHandler.slotMax + ".");
}
} else {
event.getInventory().setItem(event.getSlot(), GUIHandler.locked);
GUIHandler.slotParam.put(player.getUniqueId(), new ArrayList<Integer>(Arrays.asList(slot)));
}
}
}
}
event.setCancelled(true);
}
String sfilter = ChatColor.BLUE + "AntiDrop Filter";
if(inv.getName().equals(sfilter)) { //Filter GUI
if(event.getClickedInventory().getName().equals(sfilter)) {
if(event.getCurrentItem() != null) {
ItemStack currentItem = event.getCurrentItem();
for(Map.Entry<String, ItemStack> entry : GUIHandler.checks.entrySet()) {
if(currentItem.equals(entry.getValue())) {
inv.setItem(event.getSlot(), GUIHandler.checkOffs.get(entry.getKey()));
} else if(currentItem.equals(GUIHandler.checkOffs.get(entry.getKey()))) {
inv.setItem(event.getSlot(), entry.getValue());
}
}
if(event.getCurrentItem().equals(GUIHandler.submit)) {
Player player = (Player)event.getWhoClicked();
ItemStack main = inv.getItem(13);
List<Entry<String, Object>> filter = new ArrayList<Entry<String, Object>>();
if(inv.contains(GUIHandler.checks.get("Exact"))) {
YamlConfiguration config = new YamlConfiguration();
ItemStack itemFilt = main.clone(); itemFilt.setAmount(1);
config.set("i", itemFilt);
Entry<String, Object> entry = new AbstractMap.SimpleEntry<String, Object>("Exact", config.saveToString());
filter.add(entry);
} else {
if(inv.contains(GUIHandler.checks.get("Name"))) {
if(main.getItemMeta().hasDisplayName()) {
Entry<String, Object> entry = new AbstractMap.SimpleEntry<String, Object>("Name", main.getItemMeta().getDisplayName());
filter.add(entry);
} else {
player.sendMessage(ADMain.prefix + ChatColor.RED + "Chosen item has no name. Skipping name check...");
}
}
if(inv.contains(GUIHandler.checks.get("Lore"))) {
if(main.getItemMeta().hasLore()) {
Entry<String, Object> entry = new AbstractMap.SimpleEntry<String, Object>("Lore", main.getItemMeta().getLore());
filter.add(entry);
} else {
player.sendMessage(ADMain.prefix + ChatColor.RED + "Chosen item has no lore. Skipping lore check...");
}
}
if(inv.contains(GUIHandler.checks.get("Type"))) {
Entry<String, Object> entry = new AbstractMap.SimpleEntry<String, Object>("Type", main.getType());
filter.add(entry);
}
if(inv.contains(GUIHandler.checks.get("Damage"))) {
Entry<String, Object> entry = new AbstractMap.SimpleEntry<String, Object>("Damage", main.getDurability());
filter.add(entry);
}
}
if(!filter.isEmpty()) {
player.closeInventory();
boolean useEco = false;
if(ConfigHandler.eco && ConfigHandler.filterFee > 0) {
if(!((ConfigHandler.usePerms && player.hasPermission("adp.bypass.payment")) || (!ConfigHandler.usePerms && player.isOp()))) {
if(ADMain.getMoney(player) >= ConfigHandler.filterFee) {
useEco = true;
} else {
player.sendMessage(ADMain.prefix + ChatColor.RED + "You have insufficient funds.");
event.setCancelled(true);
return;
}
}
}
boolean success = false;
if(GUIHandler.filterParam.containsKey(player.getUniqueId()) && !GUIHandler.filterParam.get(player.getUniqueId()).isEmpty()) {
if(GUIHandler.filterParam.get(player.getUniqueId()).contains(filter)) {
player.sendMessage(ADMain.prefix + ChatColor.RED + "This filter already exists.");
} else {
GUIHandler.filterParam.get(player.getUniqueId()).add(filter);
success = true;
}
} else {
List<List<Entry<String, Object>>> filterList = new ArrayList<List<Entry<String, Object>>>(Arrays.asList(filter));
GUIHandler.filterParam.put(player.getUniqueId(), filterList);
success = true;
}
if(success) {
plugin.serialize(GUIHandler.filterParam, "FilterData.bin");
if(useEco) {
ADMain.econ.withdrawPlayer(player, ConfigHandler.filterFee);
player.sendMessage(ADMain.prefix + ChatColor.YELLOW + "$" + ConfigHandler.filterFee + ChatColor.GREEN + " has been taken from your account.");
}
player.sendMessage(ADMain.prefix + ChatColor.GREEN + "Successfully added the filter!");
}
} else {
player.sendMessage(ADMain.prefix + "Please choose at least one check first!");
}
}
}
}
event.setCancelled(true);
}
}
}
}
}

File Metadata

Mime Type
text/x-java
Expires
Wed, Mar 4, 1:56 PM (1 d, 16 h)
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
78/3e/52756895c7a6aa32c8046238cc9c

Event Timeline

Back to Main Site