hoeruputils/chests/AdvancedChest.java

package dk.thoerup.bukkit.hoeruputils.chests;


import java.util.HashMap;
import java.util.List;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;

import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.OfflinePlayer;
import org.bukkit.Server;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.block.Chest;
import org.bukkit.block.DoubleChest;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.Action;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockBurnEvent;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.entity.EntityExplodeEvent;
import org.bukkit.event.inventory.InventoryCloseEvent;
import org.bukkit.event.inventory.InventoryOpenEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.InventoryHolder;
import org.bukkit.inventory.ItemStack;

import dk.thoerup.bukkit.hoeruputils.HoerupUtilsPlugin;
import dk.thoerup.bukkit.hoeruputils.Util;


public class AdvancedChest  implements Listener, CommandExecutor{

        class ItemCount extends TreeMap<Integer,Integer> {
                private static final long serialVersionUID = 1L;
        };
        
        HashMap<String, ItemCount> contentMap = new HashMap<String, ItemCount>();
        
                
        HashMap<Location,ChestBean> chestMap = new HashMap<Location, ChestBean>();

        
        HoerupUtilsPlugin plugin;
        Server server;
        
        public AdvancedChest(HoerupUtilsPlugin plugin, Runnable r) {
                this.plugin = plugin;
                server = plugin.getServer();
                try {
                        loadChests();
                } catch (Exception e) {
                        e.printStackTrace();
                        //r.run();
                        loadChests();
                }
        }
        

        @Override
        public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
                if (! (sender instanceof Player) ) {
                        sender.sendMessage("this is not a console command!");
                        return true;
                }
                
                Player player = (Player) sender;
                
                if (args.length == 0) {
                        player.sendMessage("Usage:");
                        player.sendMessage("/chest (status|lock|snitch|remove|addplayer|removeplayer|setowner|comment) [player]");
                        return true;
                }
                
                                
                Block b = player.getTargetBlock(null, 30);                      
                
                if (b.getTypeId() != 54) {
                        player.sendMessage("[Chest] Please look at the chest you want to protect");
                        return true;
                }
                
                Location loc = b.getLocation();
                Location loc2 = getNeighborChest(loc);
                
                ChestBean chest = chestMap.get(loc);
                String cmd = args[0].toLowerCase();
                
                if (cmd.equals("status")) {
                        if (chest != null) {                            
                                String mode = "";
                                switch (chest.getChestType()) {
                                case ChestBean.LOCKED:
                                        mode = "locked";
                                        break;
                                case ChestBean.SNITCHING:
                                        mode = "snitching";
                                        break;
                                default:
                                        mode = "unknown ??";
                                }                               
                                
                                player.sendMessage(ChatColor.GREEN + "Chest is  a " + mode + " chest owned by " + chest.getOwner());
                                player.sendMessage(ChatColor.GREEN + "Allowed players: " + chest.getModifyPlayers() );
                                player.sendMessage(ChatColor.GREEN + "Comment: " + chest.getComment() );
                        } else {
                                player.sendMessage(ChatColor.GREEN + "The chest is not protected");
                        }
                        return true;
                }
                
                if (cmd.equals("lock") || cmd.equals("snitch")) {
                        if (chest == null) {
                                chest = createChest(player.getName(), "", loc);         
                                if (loc2 != null) {
                                        chest.setDoublechest(true);
                                }
                                String modeStr = "";
                                if (cmd.equals("lock")) {
                                        chest.setChestType( ChestBean.LOCKED);
                                        modeStr = "locked";
                                } else {
                                        chest.setChestType( ChestBean.SNITCHING);
                                        modeStr = "snitching";
                                }
                                chest.setModifyPlayers("");
                                chest.setComment("");
                                addChest(loc, chest);
                                player.sendMessage("Chest is now " + modeStr);
                        } else {
                                server.getLogger().info( player.getName() + " tried to protect a chest owned by " + chest.getOwner() );
                                player.sendMessage("This chest is already protected");
                        }
                        return true;
                }
                
                if (cmd.equals("remove")) {
                        if (chest == null) {
                                player.sendMessage("This chest is not protected");
                                return true;
                        }
                        if ( chest.getOwner().equals( player.getName() ) || player.isOp() ) {
                                //do nothing
                        } else {
                                player.sendMessage("You can not remove lock from a chest you don't own");
                                server.getLogger().info( player.getName() + " tried to remove protection froma chest owned by " + chest.getOwner() );
                                return true;
                        }

                        player.sendMessage("[LockedChest] Removing protection from chest");
                        removeChest(loc);                               

                        return true;
                }

                if (cmd.equals("setowner")) {
                        if (chest == null) {
                                player.sendMessage("This chest is not protected");
                                return true;
                        }
                        if ( chest.getOwner().equals( player.getName() ) || player.isOp() ) {
                                //do nothing
                        } else {
                                player.sendMessage("You can not set new owner of a chest you dont own");
                                server.getLogger().info( player.getName() + " tried to set owner on a chest owned by " + chest.getOwner() );
                                return true;
                        }
                        if (args.length != 2) {
                                player.sendMessage("You need to specify which player should own this chest");
                                return true;
                        } 
                        OfflinePlayer p2 = server.getOfflinePlayer(args[1]);
                        if ( p2.hasPlayedBefore() == false && p2.isOnline() == false) {
                                player.sendMessage("Unknown user: " + args[1] );
                                return true;
                        }
                        chest.setOwner( p2.getName() );
                        plugin.getDatabase().save( chest );
                        player.sendMessage("ok");
                        return true;
                }
                
                if (cmd.equals("addplayer") || cmd.equals("removeplayer")) {
                        if (chest == null) {
                                player.sendMessage("This chest is not protected");
                                return true;
                        }
                        if (! chest.getOwner().equals( player.getName() ) ) {
                                player.sendMessage("You can not add/remove players from a chest you don't own");
                                server.getLogger().info( player.getName() + " tried to add/remove player on a chest owned by " + chest.getOwner() );
                                return true;
                        }
                        if (args.length != 2) {
                                player.sendMessage("You need to specify which player to add or remove");
                                return true;
                        } 
                        OfflinePlayer p2 = server.getOfflinePlayer(args[1]);
                        if ( p2.hasPlayedBefore() == false && p2.isOnline() == false) {
                                player.sendMessage("Unknown user: " + args[1] );
                                return true;
                        }
                        
                        Set<String> players = Util.stringToSet( chest.getModifyPlayers() );
                        if (cmd.equals("addplayer")) {
                                players.add(p2.getName());
                        } else {
                                players.remove(p2.getName());
                        }
                        
                        chest.setModifyPlayers( Util.setToString(players) );
                        plugin.getDatabase().save( chest );
                        player.sendMessage("ok");
                        return true;
                }
                if (cmd.equals("comment")) {    
                        if (chest == null) {
                                player.sendMessage("This chest is not protected");
                                return true;
                        }
                        if (! chest.getOwner().equals( player.getName() ) ) {                           
                                player.sendMessage("You can not comment a chest you don't own");
                                server.getLogger().info( player.getName() + " tried to comment on a chest owned by " + chest.getOwner() );
                                return true;
                        }

                        StringBuilder sb = new StringBuilder();
                        for (int i=1; i<args.length; i++) {
                                sb.append(args[i]).append(" ");
                        }
                        String comment = sb.toString().trim();

                        chest.setComment( comment );
                        plugin.getDatabase().save( chest );
                        player.sendMessage("Comment set");

                        return true;
                }
                
                /*
                if (chest != null) {
                        if (chest.getOwner().equals(player.getName())) {
                                player.sendMessage("[LockedChest] Removing lock from chest");
                                removeChest(loc);
                        } else {
                                player.sendMessage("[LockedChest] Chest is already protected");
                        }
                        
                        return true;
                }
                
                chest = createChest(player.getName(), "", loc);         
                if (loc2 != null) {
                        chest.setDoublechest(true);
                }
                
                addChest(loc, chest);
                
        
                player.sendMessage("[LockedChest] Chest is now locked");
                */
                
                player.sendMessage("Unknown argument, " + cmd);
                
                return true;
        }
        
        @EventHandler
        public void onBlockBreak(BlockBreakEvent event) {
                Location loc = event.getBlock().getLocation();
                ChestBean chest = chestMap.get(loc);
                if (chest != null) {
                        if (chest.getOwner().equals(event.getPlayer().getName())) {
                                removeChest(loc);
                                event.getPlayer().sendMessage("[AdvancedChest] The destroyed chest was locked or snitching");
                        } else {
                                event.setCancelled(true);
                                event.getPlayer().sendMessage("You can't destroy that chest");
                                server.getLogger().info( "[AdvancedChest] " + event.getPlayer().getName() + " tried breaking a chest owned by " + chest.getOwner() + chest.getCommentString() );
                        }
                }
        }
        public void addChest(Location loc, ChestBean chest) {
                chestMap.put(loc, chest);
                if (chest.isDoublechest()) {
                        Location loc2 = getNeighborChest(loc);
                        chestMap.put(loc2, chest);
                }               
                plugin.getDatabase().save(chest);
                
                reloadChests();
                
        }
        
        void removeChest(Location loc) {
                ChestBean chest = chestMap.remove(loc);
                if (chest != null) {                                                                    
                        if (chest.isDoublechest()){
                                Location loc2 = getNeighborChest(loc);
                                chestMap.remove(loc2);
                        }
                        plugin.getDatabase().delete(chest);
                }
        }
        
        int loadChestsWorker() {
                List<ChestBean> chestlist = plugin.getDatabase().find( ChestBean.class).findList();
                for (ChestBean chest : chestlist) {
                        Location loc = getChestLocation(server, chest);
                        chestMap.put(loc, chest);       
                        
                        if (chest.isDoublechest()) {
                                Location loc2 = getNeighborChest(loc);
                                chestMap.put(loc2, chest);      
                        }
                }

                return chestlist.size();
        }
        
        void reloadChests() {           
                chestMap.clear();
                loadChestsWorker();             
        }
        
        void loadChests() {             
                int count = loadChestsWorker();
                server.getLogger().info("[AdvancedChest] loaded " + count + " chests");
        }
        
        
        public ChestBean createChest(String owner, String description, Location loc) {
                
                ChestBean chest = new ChestBean();
                chest.setOwner(owner);
                chest.setDescription(description);
                setChestLocation(chest, loc);

                return chest;
        }
        
        
        public void setChestLocation(ChestBean chest, Location loc) {
                chest.setWorld( loc.getWorld().getName() );
                chest.setX( loc.getBlockX() );
                chest.setY( loc.getBlockY() );
                chest.setZ( loc.getBlockZ() );          
        }
        
        public Location getChestLocation(Server server, ChestBean chest) {
                World wrld = server.getWorld(chest.getWorld());
                return new Location(wrld,chest.getX(),chest.getY(),chest.getZ());               
        }
        

        /*
        void saveChests() {
                
        }*/
        
        Location getNeighborChest(Location loc) {
                World world = loc.getWorld();
                
                Location target = new Location(world, loc.getX()+1, loc.getY(), loc.getZ() );
                if (world.getBlockAt(target).getType() == Material.CHEST )
                        return target;
                
                target = new Location(world, loc.getX()-1, loc.getY(), loc.getZ() );
                if (world.getBlockAt(target).getType() == Material.CHEST )
                        return target;          

                target = new Location(world, loc.getX(), loc.getY(), loc.getZ() +1);
                if (world.getBlockAt(target).getType() == Material.CHEST )
                        return target;                          

                target = new Location(world, loc.getX(), loc.getY(), loc.getZ() -1);
                if (world.getBlockAt(target).getType() == Material.CHEST )
                        return target;                                          
                
                return null;
        }
        
        
        Location getChestLocation(InventoryHolder holder) {
                Location loc;
                if ( holder instanceof Chest) {
                        loc =  ( (Chest)holder).getLocation();
                } else {
                        loc =  ( (DoubleChest)holder).getLocation();
                }
                
                loc.setX( loc.getBlockX() ); //round to integer, since double chests apparently are placed at pos + 0.5
                loc.setZ( loc.getBlockZ() ); // -- // --
                
                return loc;
        }
        
        @EventHandler
        public void onChestPlaced(BlockPlaceEvent event) {
                Block block = event.getBlock();
                
                if (block.getType() != Material.CHEST) {
                        return;
                }
                
                Location chestloc = getNeighborChest( block.getLocation() );
                if (chestloc != null) {
                        ChestBean chest = chestMap.get(chestloc);
                        
                        if (chest != null) { //the neighbor is a locked chest

                                
                                chest.setDoublechest(true);
                                addChest(chestloc, chest);
                                
                                
                                event.getPlayer().sendMessage( "[AdvancedChest] Chest has been expanded" );
                        }                       
                        
                }
        }


        @EventHandler
        public void onChestExplode(EntityExplodeEvent event) {
                for (Block b : event.blockList() ) {
                        ChestBean chest = chestMap.get( b.getLocation() );
                        if (chest != null) {
                                server.getLogger().info( "[AdvancedChest] Prevented an explosion from destroying chest owned by " + chest.getOwner() +  chest.getCommentString() );
                                event.setCancelled( true );
                                return;
                        }
                }
        }

        @EventHandler
        public void onChestBurn(BlockBurnEvent event) {
                ChestBean chest = chestMap.get( event.getBlock().getLocation() );
                if (chest != null) {
                        server.getLogger().info( "[AdvancedChest] prevented a fire from destrying chest owned by " + chest.getOwner() + chest.getCommentString()  );
                        event.setCancelled( true);
                }
        }
        
        // prevent a user from opening a chest 
        @EventHandler
        public void onChestInteract(PlayerInteractEvent event) {
                if (event.getAction() == Action.RIGHT_CLICK_BLOCK) {
                        Block b = event.getClickedBlock();
                        
                        if (b.getType() == Material.CHEST) {
                                
                                Location loc = b.getLocation();
                                
                                ChestBean chest = chestMap.get( loc );
                                if (chest == null) {                            
                                        return; //chest not surveyed by this plugin
                                }
                                
                                if (chest.getChestType() != ChestBean.LOCKED ) {
                                        return; //this is not a locked chests
                                }
                                
                                Player player = (Player) event.getPlayer();
                                if (player.getName().equals(chest.getOwner() )) {
                                        return; //chest is opened by it's owner
                                }
                                
                                Set<String> players = chest.getModifyPlayersSet() ;
                                if ( players.contains(player.getName()) ) {
                                        return; //this player is on the whitelist so he may open
                                }


                                server.getLogger().info( "[AdvancedChest] " + event.getPlayer().getName() + " tried opening a chest owned by " + chest.getOwner()  + chest.getCommentString() );
                                player.sendMessage( ChatColor.BLUE +  "Sorry but this chest is locked !");
                                event.setCancelled(true);
                        }
                }               
        }

        @EventHandler
        public void onChestOpen(InventoryOpenEvent event) {
                
                if (! (event.getPlayer() instanceof Player)) {
                        return;
                }


                InventoryHolder holder = event.getInventory().getHolder(); 
                if (holder instanceof Chest || holder instanceof DoubleChest) {
                        Location loc = getChestLocation(holder);
                        
                        ChestBean chest = chestMap.get( loc );
                        if (chest == null) {                            
                                return; //chest not surveyed by this plugin
                        }
                        
                        if (chest.getChestType() != ChestBean.SNITCHING) {
                                return; // not a snitching chest
                        }
                        
                                                
                        Player player = (Player) event.getPlayer();
                        if (player.getName().equals(chest.getOwner() )) {
                                return; //chest is owned by it's own player
                        }
                        
                        Set<String> players = chest.getModifyPlayersSet();
                        if ( players.contains(player.getName()) ) {
                                return; //this player is on the whitelist so he may open
                        }
                        
                        
                        server.getLogger().info( "[AdvancedChest] " + event.getPlayer().getName() + " opened a snitching chest owned by " + chest.getOwner()  + chest.getCommentString()  );

                        ItemCount contents = countItems( event.getInventory().getContents() );                  
                        
                        contentMap.put(player.getName(), contents );
                }
        }
        
        @EventHandler
        public void onChestClose(InventoryCloseEvent event) {
                if (! (event.getPlayer() instanceof Player)) {
                        return;
                }
                
                
                InventoryHolder holder = event.getInventory().getHolder();
                if (holder instanceof Chest || holder instanceof DoubleChest) {
                        Location loc = getChestLocation(holder);
                        ChestBean chest = chestMap.get(loc);
                        
                        if (chest == null) { //chest was not a snitching chest
                                return;
                        }
                        
                        if (chest.getChestType() != ChestBean.SNITCHING) {
                                return; // not a snitching chest
                        }
                        
                        
                        OfflinePlayer owner = server.getOfflinePlayer( chest.getOwner() );
                        
                        
                        Player player = (Player) event.getPlayer();
                        
                        ItemCount savedContent = contentMap.get( player.getName() );
                        
                        if (savedContent == null) {
                                return;
                        }
                        
                        contentMap.remove( player.getName() );
                        
                        ItemCount content = countItems( event.getInventory().getContents() );
                                                
                        Set<Integer> combinedKeyset = new TreeSet<Integer>();                   
                        combinedKeyset.addAll( savedContent.keySet() );
                        combinedKeyset.addAll( content.keySet() );
                        
                        for (Integer item : combinedKeyset ) {
                                Integer savedcount = savedContent.get(item);                            
                                Integer count = content.get(item);
                                
                                if (savedcount == null)
                                        savedcount = 0;
                                if (count == null)
                                        count = 0;
                                
                                
                                int diff = Math.abs( savedcount - count);
                                
                                if (diff > 0) {
                                        String material = Material.getMaterial(item).name();
                                        String msg = null;
                                        
                                        if (count > savedcount) {
                                                msg = player.getName() + " added "   + diff + " units of " + material + "(" +item + ") to "   + owner.getName() + "'s chest at " + loc.getWorld().getName() + "," + loc.getBlockX() + "," +loc.getBlockY() + "," + loc.getBlockZ() + chest.getCommentString();
                                        } else { //(count < savedcount)
                                                msg = player.getName() + " removed " + diff + " units of " + material + "(" +item + ") from " + owner.getName() + "'s chest at " + loc.getWorld().getName() + "," + loc.getBlockX() + "," +loc.getBlockY() + "," + loc.getBlockZ() + chest.getCommentString();
                                        }
                                
                                
                                        server.getLogger().info( "[AdvancedChest]" + msg);
                                        plugin.getMessageWrapper().sendMessage("system", owner, msg);
                                }
                                
                        }
                        
                        
                }
        }
        
        ItemCount countItems(ItemStack[] input) {
                ItemCount output = new ItemCount();
                for (int i=0; i<input.length; i++) {
                        ItemStack current = input[i];
                        if (current == null)
                                continue;
                        
                        int type = current.getTypeId();
                        
                        Integer amount = output.get(type);
                        if (amount == null)
                                amount = 0;
                        
                        output.put(type, amount + current.getAmount() );                        
                }
                return output;
        }
        /*
        ItemStack[] cloneItemStacks(ItemStack[] input) {
                ItemStack[] output = new ItemStack[ input.length ];
                for (int i=0; i<input.length; i++) {
                        if (input[i] != null) {
                                output[i] = input[i].clone();
                        } else {
                                output[i] = new ItemStack(0, 0);
                        }
                }
                return output;
        }*/
        
        
}
1	torben	1805	package dk.thoerup.bukkit.hoeruputils.chests;
2
3
4			import java.util.HashMap;
5			import java.util.List;
6	torben	1807	import java.util.Set;
7			import java.util.TreeMap;
8			import java.util.TreeSet;
9	torben	1805
10			import org.bukkit.ChatColor;
11			import org.bukkit.Location;
12			import org.bukkit.Material;
13	torben	1807	import org.bukkit.OfflinePlayer;
14	torben	1805	import org.bukkit.Server;
15			import org.bukkit.World;
16			import org.bukkit.block.Block;
17			import org.bukkit.block.Chest;
18			import org.bukkit.block.DoubleChest;
19			import org.bukkit.command.Command;
20			import org.bukkit.command.CommandExecutor;
21			import org.bukkit.command.CommandSender;
22			import org.bukkit.entity.Player;
23			import org.bukkit.event.EventHandler;
24			import org.bukkit.event.Listener;
25			import org.bukkit.event.block.Action;
26			import org.bukkit.event.block.BlockBreakEvent;
27	torben	1868	import org.bukkit.event.block.BlockBurnEvent;
28	torben	1805	import org.bukkit.event.block.BlockPlaceEvent;
29	torben	1806	import org.bukkit.event.entity.EntityExplodeEvent;
30	torben	1807	import org.bukkit.event.inventory.InventoryCloseEvent;
31			import org.bukkit.event.inventory.InventoryOpenEvent;
32	torben	1805	import org.bukkit.event.player.PlayerInteractEvent;
33			import org.bukkit.inventory.InventoryHolder;
34	torben	1807	import org.bukkit.inventory.ItemStack;
35	torben	1805
36			import dk.thoerup.bukkit.hoeruputils.HoerupUtilsPlugin;
37	torben	1807	import dk.thoerup.bukkit.hoeruputils.Util;
38	torben	1805
39
40	torben	1807
41			public class AdvancedChest implements Listener, CommandExecutor{
42
43			class ItemCount extends TreeMap<Integer,Integer> {
44			private static final long serialVersionUID = 1L;
45			};
46	torben	1805
47	torben	1807	HashMap<String, ItemCount> contentMap = new HashMap<String, ItemCount>();
48
49	torben	1805
50	torben	1807	HashMap<Location,ChestBean> chestMap = new HashMap<Location, ChestBean>();
51	torben	1805
52
53			HoerupUtilsPlugin plugin;
54			Server server;
55
56	torben	1807	public AdvancedChest(HoerupUtilsPlugin plugin, Runnable r) {
57	torben	1805	this.plugin = plugin;
58			server = plugin.getServer();
59			try {
60			loadChests();
61			} catch (Exception e) {
62			e.printStackTrace();
63			//r.run();
64			loadChests();
65			}
66			}
67
68
69			@Override
70			public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
71			if (! (sender instanceof Player) ) {
72			sender.sendMessage("this is not a console command!");
73			return true;
74			}
75
76			Player player = (Player) sender;
77
78	torben	1807	if (args.length == 0) {
79			player.sendMessage("Usage:");
80	torben	1869	player.sendMessage("/chest (status\|lock\|snitch\|remove\|addplayer\|removeplayer\|setowner\|comment) [player]");
81	torben	1807	return true;
82			}
83	torben	1805
84	torben	1807
85			Block b = player.getTargetBlock(null, 30);
86	torben	1805
87			if (b.getTypeId() != 54) {
88	torben	1807	player.sendMessage("[Chest] Please look at the chest you want to protect");
89	torben	1805	return true;
90			}
91
92	torben	1807	Location loc = b.getLocation();
93	torben	1805	Location loc2 = getNeighborChest(loc);
94
95	torben	1807	ChestBean chest = chestMap.get(loc);
96			String cmd = args[0].toLowerCase();
97
98			if (cmd.equals("status")) {
99			if (chest != null) {
100			String mode = "";
101			switch (chest.getChestType()) {
102			case ChestBean.LOCKED:
103			mode = "locked";
104			break;
105			case ChestBean.SNITCHING:
106			mode = "snitching";
107			break;
108			default:
109			mode = "unknown ??";
110			}
111
112			player.sendMessage(ChatColor.GREEN + "Chest is a " + mode + " chest owned by " + chest.getOwner());
113			player.sendMessage(ChatColor.GREEN + "Allowed players: " + chest.getModifyPlayers() );
114	torben	1869	player.sendMessage(ChatColor.GREEN + "Comment: " + chest.getComment() );
115	torben	1807	} else {
116			player.sendMessage(ChatColor.GREEN + "The chest is not protected");
117			}
118			return true;
119			}
120
121			if (cmd.equals("lock") \|\| cmd.equals("snitch")) {
122			if (chest == null) {
123			chest = createChest(player.getName(), "", loc);
124			if (loc2 != null) {
125			chest.setDoublechest(true);
126			}
127			String modeStr = "";
128			if (cmd.equals("lock")) {
129			chest.setChestType( ChestBean.LOCKED);
130			modeStr = "locked";
131			} else {
132			chest.setChestType( ChestBean.SNITCHING);
133			modeStr = "snitching";
134			}
135			chest.setModifyPlayers("");
136	torben	1869	chest.setComment("");
137	torben	1807	addChest(loc, chest);
138			player.sendMessage("Chest is now " + modeStr);
139			} else {
140	torben	1874	server.getLogger().info( player.getName() + " tried to protect a chest owned by " + chest.getOwner() );
141	torben	1807	player.sendMessage("This chest is already protected");
142			}
143			return true;
144			}
145
146			if (cmd.equals("remove")) {
147	torben	1853	if (chest == null) {
148			player.sendMessage("This chest is not protected");
149			return true;
150			}
151	torben	1915	if ( chest.getOwner().equals( player.getName() ) \|\| player.isOp() ) {
152			//do nothing
153			} else {
154	torben	1852	player.sendMessage("You can not remove lock from a chest you don't own");
155	torben	1874	server.getLogger().info( player.getName() + " tried to remove protection froma chest owned by " + chest.getOwner() );
156	torben	1852	return true;
157			}
158	torben	1853
159			player.sendMessage("[LockedChest] Removing protection from chest");
160			removeChest(loc);
161
162	torben	1807	return true;
163			}
164	torben	1854
165			if (cmd.equals("setowner")) {
166			if (chest == null) {
167			player.sendMessage("This chest is not protected");
168			return true;
169			}
170	torben	1915	if ( chest.getOwner().equals( player.getName() ) \|\| player.isOp() ) {
171			//do nothing
172			} else {
173	torben	1854	player.sendMessage("You can not set new owner of a chest you dont own");
174	torben	1874	server.getLogger().info( player.getName() + " tried to set owner on a chest owned by " + chest.getOwner() );
175	torben	1854	return true;
176			}
177			if (args.length != 2) {
178			player.sendMessage("You need to specify which player should own this chest");
179			return true;
180			}
181			OfflinePlayer p2 = server.getOfflinePlayer(args[1]);
182			if ( p2.hasPlayedBefore() == false && p2.isOnline() == false) {
183			player.sendMessage("Unknown user: " + args[1] );
184			return true;
185			}
186			chest.setOwner( p2.getName() );
187			plugin.getDatabase().save( chest );
188			player.sendMessage("ok");
189			return true;
190			}
191	torben	1807
192			if (cmd.equals("addplayer") \|\| cmd.equals("removeplayer")) {
193			if (chest == null) {
194			player.sendMessage("This chest is not protected");
195			return true;
196			}
197	torben	1852	if (! chest.getOwner().equals( player.getName() ) ) {
198			player.sendMessage("You can not add/remove players from a chest you don't own");
199	torben	1874	server.getLogger().info( player.getName() + " tried to add/remove player on a chest owned by " + chest.getOwner() );
200	torben	1852	return true;
201			}
202	torben	1807	if (args.length != 2) {
203			player.sendMessage("You need to specify which player to add or remove");
204			return true;
205			}
206			OfflinePlayer p2 = server.getOfflinePlayer(args[1]);
207			if ( p2.hasPlayedBefore() == false && p2.isOnline() == false) {
208			player.sendMessage("Unknown user: " + args[1] );
209			return true;
210			}
211
212			Set<String> players = Util.stringToSet( chest.getModifyPlayers() );
213			if (cmd.equals("addplayer")) {
214	torben	1808	players.add(p2.getName());
215	torben	1807	} else {
216	torben	1808	players.remove(p2.getName());
217	torben	1807	}
218
219			chest.setModifyPlayers( Util.setToString(players) );
220			plugin.getDatabase().save( chest );
221			player.sendMessage("ok");
222			return true;
223			}
224	torben	1869	if (cmd.equals("comment")) {
225			if (chest == null) {
226			player.sendMessage("This chest is not protected");
227			return true;
228			}
229	torben	1874	if (! chest.getOwner().equals( player.getName() ) ) {
230	torben	1869	player.sendMessage("You can not comment a chest you don't own");
231	torben	1874	server.getLogger().info( player.getName() + " tried to comment on a chest owned by " + chest.getOwner() );
232	torben	1869	return true;
233			}
234
235			StringBuilder sb = new StringBuilder();
236			for (int i=1; i<args.length; i++) {
237			sb.append(args[i]).append(" ");
238			}
239			String comment = sb.toString().trim();
240
241			chest.setComment( comment );
242			plugin.getDatabase().save( chest );
243			player.sendMessage("Comment set");
244
245			return true;
246			}
247	torben	1807
248			/*
249	torben	1805	if (chest != null) {
250			if (chest.getOwner().equals(player.getName())) {
251			player.sendMessage("[LockedChest] Removing lock from chest");
252			removeChest(loc);
253			} else {
254	torben	1807	player.sendMessage("[LockedChest] Chest is already protected");
255	torben	1805	}
256
257			return true;
258			}
259
260			chest = createChest(player.getName(), "", loc);
261			if (loc2 != null) {
262			chest.setDoublechest(true);
263			}
264
265			addChest(loc, chest);
266
267
268			player.sendMessage("[LockedChest] Chest is now locked");
269	torben	1807	*/
270	torben	1805
271	torben	1807	player.sendMessage("Unknown argument, " + cmd);
272	torben	1805
273			return true;
274			}
275
276			@EventHandler
277			public void onBlockBreak(BlockBreakEvent event) {
278			Location loc = event.getBlock().getLocation();
279	torben	1807	ChestBean chest = chestMap.get(loc);
280	torben	1805	if (chest != null) {
281			if (chest.getOwner().equals(event.getPlayer().getName())) {
282			removeChest(loc);
283	torben	1807	event.getPlayer().sendMessage("[AdvancedChest] The destroyed chest was locked or snitching");
284	torben	1805	} else {
285			event.setCancelled(true);
286			event.getPlayer().sendMessage("You can't destroy that chest");
287	torben	1871	server.getLogger().info( "[AdvancedChest] " + event.getPlayer().getName() + " tried breaking a chest owned by " + chest.getOwner() + chest.getCommentString() );
288	torben	1805	}
289			}
290			}
291	torben	1807	public void addChest(Location loc, ChestBean chest) {
292	torben	1805	chestMap.put(loc, chest);
293			if (chest.isDoublechest()) {
294			Location loc2 = getNeighborChest(loc);
295			chestMap.put(loc2, chest);
296			}
297			plugin.getDatabase().save(chest);
298
299			reloadChests();
300
301			}
302
303			void removeChest(Location loc) {
304	torben	1807	ChestBean chest = chestMap.remove(loc);
305	torben	1805	if (chest != null) {
306			if (chest.isDoublechest()){
307			Location loc2 = getNeighborChest(loc);
308			chestMap.remove(loc2);
309			}
310			plugin.getDatabase().delete(chest);
311			}
312			}
313
314			int loadChestsWorker() {
315	torben	1807	List<ChestBean> chestlist = plugin.getDatabase().find( ChestBean.class).findList();
316			for (ChestBean chest : chestlist) {
317	torben	1805	Location loc = getChestLocation(server, chest);
318			chestMap.put(loc, chest);
319
320			if (chest.isDoublechest()) {
321			Location loc2 = getNeighborChest(loc);
322			chestMap.put(loc2, chest);
323			}
324			}
325
326			return chestlist.size();
327			}
328
329			void reloadChests() {
330			chestMap.clear();
331			loadChestsWorker();
332			}
333
334			void loadChests() {
335			int count = loadChestsWorker();
336	torben	1813	server.getLogger().info("[AdvancedChest] loaded " + count + " chests");
337	torben	1805	}
338
339
340	torben	1807	public ChestBean createChest(String owner, String description, Location loc) {
341	torben	1805
342	torben	1807	ChestBean chest = new ChestBean();
343	torben	1805	chest.setOwner(owner);
344			chest.setDescription(description);
345			setChestLocation(chest, loc);
346
347			return chest;
348			}
349
350
351	torben	1807	public void setChestLocation(ChestBean chest, Location loc) {
352	torben	1805	chest.setWorld( loc.getWorld().getName() );
353			chest.setX( loc.getBlockX() );
354			chest.setY( loc.getBlockY() );
355			chest.setZ( loc.getBlockZ() );
356			}
357
358	torben	1807	public Location getChestLocation(Server server, ChestBean chest) {
359	torben	1805	World wrld = server.getWorld(chest.getWorld());
360			return new Location(wrld,chest.getX(),chest.getY(),chest.getZ());
361			}
362
363
364			/*
365			void saveChests() {
366
367			}*/
368
369			Location getNeighborChest(Location loc) {
370			World world = loc.getWorld();
371
372			Location target = new Location(world, loc.getX()+1, loc.getY(), loc.getZ() );
373			if (world.getBlockAt(target).getType() == Material.CHEST )
374			return target;
375
376			target = new Location(world, loc.getX()-1, loc.getY(), loc.getZ() );
377			if (world.getBlockAt(target).getType() == Material.CHEST )
378			return target;
379
380			target = new Location(world, loc.getX(), loc.getY(), loc.getZ() +1);
381			if (world.getBlockAt(target).getType() == Material.CHEST )
382			return target;
383
384			target = new Location(world, loc.getX(), loc.getY(), loc.getZ() -1);
385			if (world.getBlockAt(target).getType() == Material.CHEST )
386			return target;
387
388			return null;
389			}
390
391
392			Location getChestLocation(InventoryHolder holder) {
393			Location loc;
394			if ( holder instanceof Chest) {
395			loc = ( (Chest)holder).getLocation();
396			} else {
397			loc = ( (DoubleChest)holder).getLocation();
398			}
399
400			loc.setX( loc.getBlockX() ); //round to integer, since double chests apparently are placed at pos + 0.5
401			loc.setZ( loc.getBlockZ() ); // -- // --
402
403			return loc;
404			}
405
406			@EventHandler
407			public void onChestPlaced(BlockPlaceEvent event) {
408			Block block = event.getBlock();
409
410			if (block.getType() != Material.CHEST) {
411			return;
412			}
413
414			Location chestloc = getNeighborChest( block.getLocation() );
415			if (chestloc != null) {
416	torben	1807	ChestBean chest = chestMap.get(chestloc);
417	torben	1805
418			if (chest != null) { //the neighbor is a locked chest
419
420
421			chest.setDoublechest(true);
422			addChest(chestloc, chest);
423
424
425	torben	1807	event.getPlayer().sendMessage( "[AdvancedChest] Chest has been expanded" );
426	torben	1805	}
427
428			}
429			}
430	torben	1806
431
432			@EventHandler
433			public void onChestExplode(EntityExplodeEvent event) {
434			for (Block b : event.blockList() ) {
435	torben	1807	ChestBean chest = chestMap.get( b.getLocation() );
436	torben	1806	if (chest != null) {
437	torben	1871	server.getLogger().info( "[AdvancedChest] Prevented an explosion from destroying chest owned by " + chest.getOwner() + chest.getCommentString() );
438	torben	1806	event.setCancelled( true );
439			return;
440			}
441			}
442	torben	1868	}
443
444			@EventHandler
445			public void onChestBurn(BlockBurnEvent event) {
446			ChestBean chest = chestMap.get( event.getBlock().getLocation() );
447			if (chest != null) {
448	torben	1871	server.getLogger().info( "[AdvancedChest] prevented a fire from destrying chest owned by " + chest.getOwner() + chest.getCommentString() );
449	torben	1868	event.setCancelled( true);
450			}
451			}
452	torben	1805
453			// prevent a user from opening a chest
454			@EventHandler
455			public void onChestInteract(PlayerInteractEvent event) {
456			if (event.getAction() == Action.RIGHT_CLICK_BLOCK) {
457			Block b = event.getClickedBlock();
458
459			if (b.getType() == Material.CHEST) {
460
461			Location loc = b.getLocation();
462
463	torben	1807	ChestBean chest = chestMap.get( loc );
464	torben	1805	if (chest == null) {
465			return; //chest not surveyed by this plugin
466			}
467
468	torben	1807	if (chest.getChestType() != ChestBean.LOCKED ) {
469			return; //this is not a locked chests
470			}
471
472	torben	1805	Player player = (Player) event.getPlayer();
473			if (player.getName().equals(chest.getOwner() )) {
474			return; //chest is opened by it's owner
475			}
476
477	torben	1904	Set<String> players = chest.getModifyPlayersSet() ;
478	torben	1809	if ( players.contains(player.getName()) ) {
479			return; //this player is on the whitelist so he may open
480	torben	1805	}
481
482	torben	1809
483	torben	1871	server.getLogger().info( "[AdvancedChest] " + event.getPlayer().getName() + " tried opening a chest owned by " + chest.getOwner() + chest.getCommentString() );
484	torben	1805	player.sendMessage( ChatColor.BLUE + "Sorry but this chest is locked !");
485			event.setCancelled(true);
486			}
487			}
488			}
489	torben	1807
490			@EventHandler
491			public void onChestOpen(InventoryOpenEvent event) {
492
493			if (! (event.getPlayer() instanceof Player)) {
494			return;
495			}
496
497
498
499			InventoryHolder holder = event.getInventory().getHolder();
500			if (holder instanceof Chest \|\| holder instanceof DoubleChest) {
501			Location loc = getChestLocation(holder);
502
503			ChestBean chest = chestMap.get( loc );
504			if (chest == null) {
505			return; //chest not surveyed by this plugin
506			}
507
508			if (chest.getChestType() != ChestBean.SNITCHING) {
509			return; // not a snitching chest
510			}
511
512
513			Player player = (Player) event.getPlayer();
514			if (player.getName().equals(chest.getOwner() )) {
515			return; //chest is owned by it's own player
516	torben	1809	}
517	torben	1807
518	torben	1904	Set<String> players = chest.getModifyPlayersSet();
519	torben	1809	if ( players.contains(player.getName()) ) {
520			return; //this player is on the whitelist so he may open
521			}
522	torben	1807
523	torben	1809
524	torben	1871	server.getLogger().info( "[AdvancedChest] " + event.getPlayer().getName() + " opened a snitching chest owned by " + chest.getOwner() + chest.getCommentString() );
525	torben	1869
526	torben	1807	ItemCount contents = countItems( event.getInventory().getContents() );
527
528			contentMap.put(player.getName(), contents );
529			}
530			}
531	torben	1805
532	torben	1807	@EventHandler
533			public void onChestClose(InventoryCloseEvent event) {
534			if (! (event.getPlayer() instanceof Player)) {
535			return;
536			}
537
538
539			InventoryHolder holder = event.getInventory().getHolder();
540			if (holder instanceof Chest \|\| holder instanceof DoubleChest) {
541			Location loc = getChestLocation(holder);
542			ChestBean chest = chestMap.get(loc);
543
544			if (chest == null) { //chest was not a snitching chest
545			return;
546			}
547
548			if (chest.getChestType() != ChestBean.SNITCHING) {
549			return; // not a snitching chest
550			}
551
552
553			OfflinePlayer owner = server.getOfflinePlayer( chest.getOwner() );
554
555
556			Player player = (Player) event.getPlayer();
557
558			ItemCount savedContent = contentMap.get( player.getName() );
559
560			if (savedContent == null) {
561			return;
562			}
563
564			contentMap.remove( player.getName() );
565
566			ItemCount content = countItems( event.getInventory().getContents() );
567
568			Set<Integer> combinedKeyset = new TreeSet<Integer>();
569			combinedKeyset.addAll( savedContent.keySet() );
570			combinedKeyset.addAll( content.keySet() );
571
572			for (Integer item : combinedKeyset ) {
573			Integer savedcount = savedContent.get(item);
574			Integer count = content.get(item);
575
576			if (savedcount == null)
577			savedcount = 0;
578			if (count == null)
579			count = 0;
580
581
582			int diff = Math.abs( savedcount - count);
583
584			if (diff > 0) {
585			String material = Material.getMaterial(item).name();
586			String msg = null;
587
588			if (count > savedcount) {
589	torben	1916	msg = player.getName() + " added " + diff + " units of " + material + "(" +item + ") to " + owner.getName() + "'s chest at " + loc.getWorld().getName() + "," + loc.getBlockX() + "," +loc.getBlockY() + "," + loc.getBlockZ() + chest.getCommentString();
590	torben	1807	} else { //(count < savedcount)
591	torben	1916	msg = player.getName() + " removed " + diff + " units of " + material + "(" +item + ") from " + owner.getName() + "'s chest at " + loc.getWorld().getName() + "," + loc.getBlockX() + "," +loc.getBlockY() + "," + loc.getBlockZ() + chest.getCommentString();
592	torben	1807	}
593
594
595	torben	1813	server.getLogger().info( "[AdvancedChest]" + msg);
596	torben	1807	plugin.getMessageWrapper().sendMessage("system", owner, msg);
597			}
598
599			}
600
601
602			}
603			}
604
605			ItemCount countItems(ItemStack[] input) {
606			ItemCount output = new ItemCount();
607			for (int i=0; i<input.length; i++) {
608			ItemStack current = input[i];
609			if (current == null)
610			continue;
611
612			int type = current.getTypeId();
613
614			Integer amount = output.get(type);
615			if (amount == null)
616			amount = 0;
617
618			output.put(type, amount + current.getAmount() );
619			}
620			return output;
621			}
622			/*
623			ItemStack[] cloneItemStacks(ItemStack[] input) {
624			ItemStack[] output = new ItemStack[ input.length ];
625			for (int i=0; i<input.length; i++) {
626			if (input[i] != null) {
627			output[i] = input[i].clone();
628			} else {
629			output[i] = new ItemStack(0, 0);
630			}
631			}
632			return output;
633			}*/
634
635
636	torben	1805	}