hoeruputils/chests/AdvancedChest.java

package dk.thoerup.bukkit.hoeruputils.chests;


import java.util.HashMap;
import java.util.List;

import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.Material;
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.player.PlayerInteractEvent;
import org.bukkit.inventory.InventoryHolder;

import dk.thoerup.bukkit.hoeruputils.HoerupUtilsPlugin;


public class LockedChest  implements Listener, CommandExecutor{
        
                
        HashMap<Location,LockedChestBean> chestMap = new HashMap<Location, LockedChestBean>();

        
        HoerupUtilsPlugin plugin;
        Server server;
        
        public LockedChest(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;
                
                
                Block b = player.getTargetBlock(null, 30);
                Location loc = b.getLocation();
                
                if (b.getTypeId() != 54) {
                        player.sendMessage("[LockedChest] Please look at the chest you want to lock");
                        return true;
                }
                
                Location loc2 = getNeighborChest(loc);
                
                LockedChestBean chest = chestMap.get(loc);
                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 locked");
                        }
                        
                        return true;
                }
                
                chest = createChest(player.getName(), "", loc);         
                if (loc2 != null) {
                        chest.setDoublechest(true);
                }
                
                addChest(loc, chest);
                
        
                player.sendMessage("[LockedChest] Chest is now locked");
                
                
                return true;
        }
        
        @EventHandler
        public void onBlockBreak(BlockBreakEvent event) {
                Location loc = event.getBlock().getLocation();
                LockedChestBean chest = chestMap.get(loc);
                if (chest != null) {
                        if (chest.getOwner().equals(event.getPlayer().getName())) {
                                removeChest(loc);
                                event.getPlayer().sendMessage("[LockedChest] The destroyed chest was locked");
                        } else {
                                event.setCancelled(true);
                                event.getPlayer().sendMessage("You can't destroy that chest");
                        }
                }
        }
        public void addChest(Location loc, LockedChestBean 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) {
                LockedChestBean chest = chestMap.remove(loc);
                if (chest != null) {                                                                    
                        if (chest.isDoublechest()){
                                Location loc2 = getNeighborChest(loc);
                                chestMap.remove(loc2);
                        }
                        plugin.getDatabase().delete(chest);
                }
        }
        
        int loadChestsWorker() {
                List<LockedChestBean> chestlist = plugin.getDatabase().find( LockedChestBean.class).findList();
                for (LockedChestBean 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("[LockedChest] loaded " + count + " chests");
        }
        
        
        public LockedChestBean createChest(String owner, String description, Location loc) {
                
                LockedChestBean chest = new LockedChestBean();
                chest.setOwner(owner);
                chest.setDescription(description);
                setChestLocation(chest, loc);

                return chest;
        }
        
        
        public void setChestLocation(LockedChestBean 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, LockedChestBean 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) {
                        LockedChestBean chest = chestMap.get(chestloc);
                        
                        if (chest != null) { //the neighbor is a locked chest

                                
                                chest.setDoublechest(true);
                                addChest(chestloc, chest);
                                
                                
                                event.getPlayer().sendMessage( "[LockedChest] Chest has been expanded" );
                        }                       
                        
                }
        }
        
        
        // 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();
                                
                                LockedChestBean chest = chestMap.get( loc );
                                if (chest == null) {                            
                                        return; //chest not surveyed by this plugin
                                }
                                
                                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);
                        }
                }               
        }
        
}
1	torben	1805	package dk.thoerup.bukkit.hoeruputils.chests;
2
3
4			import java.util.HashMap;
5			import java.util.List;
6
7			import org.bukkit.ChatColor;
8			import org.bukkit.Location;
9			import org.bukkit.Material;
10			import org.bukkit.Server;
11			import org.bukkit.World;
12			import org.bukkit.block.Block;
13			import org.bukkit.block.Chest;
14			import org.bukkit.block.DoubleChest;
15			import org.bukkit.command.Command;
16			import org.bukkit.command.CommandExecutor;
17			import org.bukkit.command.CommandSender;
18			import org.bukkit.entity.Player;
19			import org.bukkit.event.EventHandler;
20			import org.bukkit.event.Listener;
21			import org.bukkit.event.block.Action;
22			import org.bukkit.event.block.BlockBreakEvent;
23			import org.bukkit.event.block.BlockPlaceEvent;
24			import org.bukkit.event.player.PlayerInteractEvent;
25			import org.bukkit.inventory.InventoryHolder;
26
27			import dk.thoerup.bukkit.hoeruputils.HoerupUtilsPlugin;
28
29
30			public class LockedChest implements Listener, CommandExecutor{
31
32
33			HashMap<Location,LockedChestBean> chestMap = new HashMap<Location, LockedChestBean>();
34
35
36			HoerupUtilsPlugin plugin;
37			Server server;
38
39			public LockedChest(HoerupUtilsPlugin plugin, Runnable r) {
40			this.plugin = plugin;
41			server = plugin.getServer();
42			try {
43			loadChests();
44			} catch (Exception e) {
45			e.printStackTrace();
46			//r.run();
47			loadChests();
48			}
49			}
50
51
52			@Override
53			public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
54			if (! (sender instanceof Player) ) {
55			sender.sendMessage("this is not a console command!");
56			return true;
57			}
58
59			Player player = (Player) sender;
60
61
62			Block b = player.getTargetBlock(null, 30);
63			Location loc = b.getLocation();
64
65			if (b.getTypeId() != 54) {
66			player.sendMessage("[LockedChest] Please look at the chest you want to lock");
67			return true;
68			}
69
70			Location loc2 = getNeighborChest(loc);
71
72			LockedChestBean chest = chestMap.get(loc);
73			if (chest != null) {
74			if (chest.getOwner().equals(player.getName())) {
75			player.sendMessage("[LockedChest] Removing lock from chest");
76			removeChest(loc);
77			} else {
78			player.sendMessage("[LockedChest] Chest is already locked");
79			}
80
81			return true;
82			}
83
84			chest = createChest(player.getName(), "", loc);
85			if (loc2 != null) {
86			chest.setDoublechest(true);
87			}
88
89			addChest(loc, chest);
90
91
92			player.sendMessage("[LockedChest] Chest is now locked");
93
94
95			return true;
96			}
97
98			@EventHandler
99			public void onBlockBreak(BlockBreakEvent event) {
100			Location loc = event.getBlock().getLocation();
101			LockedChestBean chest = chestMap.get(loc);
102			if (chest != null) {
103			if (chest.getOwner().equals(event.getPlayer().getName())) {
104			removeChest(loc);
105			event.getPlayer().sendMessage("[LockedChest] The destroyed chest was locked");
106			} else {
107			event.setCancelled(true);
108			event.getPlayer().sendMessage("You can't destroy that chest");
109			}
110			}
111			}
112			public void addChest(Location loc, LockedChestBean chest) {
113			chestMap.put(loc, chest);
114			if (chest.isDoublechest()) {
115			Location loc2 = getNeighborChest(loc);
116			chestMap.put(loc2, chest);
117			}
118			plugin.getDatabase().save(chest);
119
120			reloadChests();
121
122			}
123
124			void removeChest(Location loc) {
125			LockedChestBean chest = chestMap.remove(loc);
126			if (chest != null) {
127			if (chest.isDoublechest()){
128			Location loc2 = getNeighborChest(loc);
129			chestMap.remove(loc2);
130			}
131			plugin.getDatabase().delete(chest);
132			}
133			}
134
135			int loadChestsWorker() {
136			List<LockedChestBean> chestlist = plugin.getDatabase().find( LockedChestBean.class).findList();
137			for (LockedChestBean chest : chestlist) {
138			Location loc = getChestLocation(server, chest);
139			chestMap.put(loc, chest);
140
141			if (chest.isDoublechest()) {
142			Location loc2 = getNeighborChest(loc);
143			chestMap.put(loc2, chest);
144			}
145			}
146
147			return chestlist.size();
148			}
149
150			void reloadChests() {
151			chestMap.clear();
152			loadChestsWorker();
153			}
154
155			void loadChests() {
156			int count = loadChestsWorker();
157			plugin.getLogger().info("[LockedChest] loaded " + count + " chests");
158			}
159
160
161			public LockedChestBean createChest(String owner, String description, Location loc) {
162
163			LockedChestBean chest = new LockedChestBean();
164			chest.setOwner(owner);
165			chest.setDescription(description);
166			setChestLocation(chest, loc);
167
168			return chest;
169			}
170
171
172			public void setChestLocation(LockedChestBean chest, Location loc) {
173			chest.setWorld( loc.getWorld().getName() );
174			chest.setX( loc.getBlockX() );
175			chest.setY( loc.getBlockY() );
176			chest.setZ( loc.getBlockZ() );
177			}
178
179			public Location getChestLocation(Server server, LockedChestBean chest) {
180			World wrld = server.getWorld(chest.getWorld());
181			return new Location(wrld,chest.getX(),chest.getY(),chest.getZ());
182			}
183
184
185			/*
186			void saveChests() {
187
188			}*/
189
190			Location getNeighborChest(Location loc) {
191			World world = loc.getWorld();
192
193			Location target = new Location(world, loc.getX()+1, loc.getY(), loc.getZ() );
194			if (world.getBlockAt(target).getType() == Material.CHEST )
195			return target;
196
197			target = new Location(world, loc.getX()-1, loc.getY(), loc.getZ() );
198			if (world.getBlockAt(target).getType() == Material.CHEST )
199			return target;
200
201			target = new Location(world, loc.getX(), loc.getY(), loc.getZ() +1);
202			if (world.getBlockAt(target).getType() == Material.CHEST )
203			return target;
204
205			target = new Location(world, loc.getX(), loc.getY(), loc.getZ() -1);
206			if (world.getBlockAt(target).getType() == Material.CHEST )
207			return target;
208
209			return null;
210			}
211
212
213			Location getChestLocation(InventoryHolder holder) {
214			Location loc;
215			if ( holder instanceof Chest) {
216			loc = ( (Chest)holder).getLocation();
217			} else {
218			loc = ( (DoubleChest)holder).getLocation();
219			}
220
221			loc.setX( loc.getBlockX() ); //round to integer, since double chests apparently are placed at pos + 0.5
222			loc.setZ( loc.getBlockZ() ); // -- // --
223
224			return loc;
225			}
226
227			@EventHandler
228			public void onChestPlaced(BlockPlaceEvent event) {
229			Block block = event.getBlock();
230
231			if (block.getType() != Material.CHEST) {
232			return;
233			}
234
235			Location chestloc = getNeighborChest( block.getLocation() );
236			if (chestloc != null) {
237			LockedChestBean chest = chestMap.get(chestloc);
238
239			if (chest != null) { //the neighbor is a locked chest
240
241
242			chest.setDoublechest(true);
243			addChest(chestloc, chest);
244
245
246			event.getPlayer().sendMessage( "[LockedChest] Chest has been expanded" );
247			}
248
249			}
250			}
251
252
253			// prevent a user from opening a chest
254			@EventHandler
255			public void onChestInteract(PlayerInteractEvent event) {
256			if (event.getAction() == Action.RIGHT_CLICK_BLOCK) {
257			Block b = event.getClickedBlock();
258
259			if (b.getType() == Material.CHEST) {
260
261			Location loc = b.getLocation();
262
263			LockedChestBean chest = chestMap.get( loc );
264			if (chest == null) {
265			return; //chest not surveyed by this plugin
266			}
267
268			Player player = (Player) event.getPlayer();
269			if (player.getName().equals(chest.getOwner() )) {
270			return; //chest is opened by it's owner
271			}
272
273			if (chest.getModifyPlayers() != null && chest.getModifyPlayers().length()>0) {
274			String modplayers[] = chest.getModifyPlayers().split(",");
275			for (String p : modplayers) {
276			if ( player.getName().equals(p) ) {
277			return; //this player is on the whitelist so he may open
278			}
279			}
280			}
281
282
283			player.sendMessage( ChatColor.BLUE + "Sorry but this chest is locked !");
284			event.setCancelled(true);
285			}
286			}
287			}
288
289			}