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.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) [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() );
                        } 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("");
                                addChest(loc, chest);
                                player.sendMessage("Chest is now " + modeStr);
                        } else {
                                player.sendMessage("This chest is already protected");
                        }
                        return true;
                }
                
                if (cmd.equals("remove")) {
                        if (chest != null) {
                                player.sendMessage("[LockedChest] Removing protection from chest");
                                removeChest(loc);                               
                        } else {
                                player.sendMessage("This chest is not protected");      
                        }
                        return true;
                }
                
                if (cmd.equals("addplayer") || cmd.equals("removeplayer")) {
                        if (chest == null) {
                                player.sendMessage("This chest is not protected");
                                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 (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");
                        }
                }
        }
        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();
                plugin.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) {
                                event.setCancelled( true );
                                return;
                        }
                }
        }       
        
        // 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
                                }
                                
                                if (chest.getModifyPlayers() != null && chest.getModifyPlayers().length()>0) {
                                        String modplayers[] = chest.getModifyPlayers().split(",");
                                        for (String p : modplayers) {
                                                if ( player.getName().equals(p) ) {
                                                        return; //this player is on the whitelist so he may open
                                                }
                                        }
                                }

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