hoeruputils/secretdoor/DoorOpenListener.java

package dk.thoerup.bukkit.hoeruputils.secretdoor;

import java.util.Set;
import java.util.HashSet;

import org.bukkit.Effect;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.AsyncPlayerChatEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.plugin.Plugin;


public class DoorOpenListener implements Listener{
        
        private DoorStorage store;
        
        private Plugin plugin;
        
        public DoorOpenListener(DoorStorage store, Plugin plugin) {
                super();
                this.store = store;
                this.plugin = plugin;
        }
        
        @EventHandler
        public void onPlayerInteract(PlayerInteractEvent event) {

                Player player = event.getPlayer();

                if ( player.getInventory().getItemInMainHand().getType() != Material.AIR ) {
                        return;
                }

                if ( event.hasBlock() == false ) {
                        return;
                }
        
                final Door door = store.findDoor( event.getClickedBlock().getLocation() );

                if (door == null) {
                        return;
                }

                if (door.isPrivate() == true && !door.getOwner().equals(player.getName() ) ) {
                        return;
                }

                openDoor(door, player,false );

        }
        
        private void openDoor(final Door door, Player player, boolean longDelay ) {
                final World world = player.getWorld();          
                
                //final Location loc = event.getClickedBlock().getLocation();
                final Location loc = door.getLeftUpper();

                door.open();

                world.playEffect( loc, Effect.DOOR_TOGGLE, 0);

                Runnable doorCloser = new Runnable() {
                        public void run() {
                                door.close( );
                                world.playEffect( loc, Effect.DOOR_TOGGLE, 0);
                        }
                };
                
                int delay = (longDelay == true) ? 8*20 : 4*20;

                player.getServer().getScheduler().scheduleSyncDelayedTask(plugin, doorCloser, delay);
                
        }
        
        
        @EventHandler
        public void onPlayerChat(AsyncPlayerChatEvent evt) {
                if (evt.isCancelled())
                        return;

                String parts[] = evt.getMessage().split(" ");
                if (parts.length == 1) {                        
                        Runnable r = new DooOpenOnChat( evt );
                        r.run();
                        //plugin.getServer().getScheduler().runTask(plugin, r); //force sync handling of this
                }
                
        }
        
        class DooOpenOnChat implements Runnable {
                AsyncPlayerChatEvent evt;
                public DooOpenOnChat(AsyncPlayerChatEvent evt) {
                        this.evt = evt;                 
                }
                

                @Override
                public void run() {
                        Player p = evt.getPlayer();
                        Block target = p.getTargetBlock( (Set<Material>)null, 40);
                        
                        if (target == null || target.getType() == Material.AIR) {
                                return;
                        }
                        
                        final Door door = store.findDoor( target.getLocation() );
                        
                        if (door == null) {
                                return;
                        }
                        
                        if (door.isPrivate() == true && !door.getOwner().equals(p.getName() ) ) {
                                return;
                        }                       
                        
                        if (door.getPassword().equals(  evt.getMessage() )) {
                                openDoor(door, p, true);
                                evt.setCancelled(true);
                        }
                }               
        }
}
1	package dk.thoerup.bukkit.hoeruputils.secretdoor;
2
3	import java.util.Set;
4	import java.util.HashSet;
5
6	import org.bukkit.Effect;
7	import org.bukkit.Location;
8	import org.bukkit.Material;
9	import org.bukkit.World;
10	import org.bukkit.block.Block;
11	import org.bukkit.entity.Player;
12	import org.bukkit.event.EventHandler;
13	import org.bukkit.event.Listener;
14	import org.bukkit.event.player.AsyncPlayerChatEvent;
15	import org.bukkit.event.player.PlayerInteractEvent;
16	import org.bukkit.plugin.Plugin;
17
18
19
20
21	public class DoorOpenListener implements Listener{
22
23	private DoorStorage store;
24
25	private Plugin plugin;
26
27	public DoorOpenListener(DoorStorage store, Plugin plugin) {
28	super();
29	this.store = store;
30	this.plugin = plugin;
31	}
32
33	@EventHandler
34	public void onPlayerInteract(PlayerInteractEvent event) {
35
36	Player player = event.getPlayer();
37
38	if ( player.getInventory().getItemInMainHand().getType() != Material.AIR ) {
39	return;
40	}
41
42	if ( event.hasBlock() == false ) {
43	return;
44	}
45
46	final Door door = store.findDoor( event.getClickedBlock().getLocation() );
47
48	if (door == null) {
49	return;
50	}
51
52	if (door.isPrivate() == true && !door.getOwner().equals(player.getName() ) ) {
53	return;
54	}
55
56	openDoor(door, player,false );
57
58	}
59
60	private void openDoor(final Door door, Player player, boolean longDelay ) {
61	final World world = player.getWorld();
62
63	//final Location loc = event.getClickedBlock().getLocation();
64	final Location loc = door.getLeftUpper();
65
66	door.open();
67
68	world.playEffect( loc, Effect.DOOR_TOGGLE, 0);
69
70	Runnable doorCloser = new Runnable() {
71	public void run() {
72	door.close( );
73	world.playEffect( loc, Effect.DOOR_TOGGLE, 0);
74	}
75	};
76
77	int delay = (longDelay == true) ? 820 : 420;
78
79	player.getServer().getScheduler().scheduleSyncDelayedTask(plugin, doorCloser, delay);
80
81	}
82
83
84	@EventHandler
85	public void onPlayerChat(AsyncPlayerChatEvent evt) {
86	if (evt.isCancelled())
87	return;
88
89	String parts[] = evt.getMessage().split(" ");
90	if (parts.length == 1) {
91	Runnable r = new DooOpenOnChat( evt );
92	r.run();
93	//plugin.getServer().getScheduler().runTask(plugin, r); //force sync handling of this
94	}
95
96	}
97
98	class DooOpenOnChat implements Runnable {
99	AsyncPlayerChatEvent evt;
100	public DooOpenOnChat(AsyncPlayerChatEvent evt) {
101	this.evt = evt;
102	}
103
104
105	@Override
106	public void run() {
107	Player p = evt.getPlayer();
108	Block target = p.getTargetBlock( (Set<Material>)null, 40);
109
110	if (target == null \|\| target.getType() == Material.AIR) {
111	return;
112	}
113
114	final Door door = store.findDoor( target.getLocation() );
115
116	if (door == null) {
117	return;
118	}
119
120	if (door.isPrivate() == true && !door.getOwner().equals(p.getName() ) ) {
121	return;
122	}
123
124	if (door.getPassword().equals( evt.getMessage() )) {
125	openDoor(door, p, true);
126	evt.setCancelled(true);
127	}
128	}
129	}
130	}