1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
|
package org.bukkit.event.player;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
import org.bukkit.event.HandlerList;
import org.bukkit.inventory.ItemStack;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.block.Action;
import org.bukkit.event.block.BlockCanBuildEvent;
import org.bukkit.inventory.EquipmentSlot;
/**
* Represents an event that is called when a player interacts with an object or
* air, potentially fired once for each hand. The hand can be determined using
* {@link #getHand()}.
* <p>
* This event will fire as cancelled if the vanilla behavior is to do nothing
* (e.g interacting with air). For the purpose of avoiding doubt, this means
* that the event will only be in the cancelled state if it is fired as a result
* of some prediction made by the server where no subsequent code will run,
* rather than when the subsequent interaction activity (e.g. placing a block in
* an illegal position ({@link BlockCanBuildEvent}) will fail.
*/
public class PlayerInteractEvent extends PlayerEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();
protected ItemStack item;
protected Action action;
protected Block blockClicked;
protected BlockFace blockFace;
private Result useClickedBlock;
private Result useItemInHand;
private EquipmentSlot hand;
public PlayerInteractEvent(final Player who, final Action action, final ItemStack item, final Block clickedBlock, final BlockFace clickedFace) {
this(who, action, item, clickedBlock, clickedFace, EquipmentSlot.HAND);
}
public PlayerInteractEvent(final Player who, final Action action, final ItemStack item, final Block clickedBlock, final BlockFace clickedFace, final EquipmentSlot hand) {
super(who);
this.action = action;
this.item = item;
this.blockClicked = clickedBlock;
this.blockFace = clickedFace;
this.hand = hand;
useItemInHand = Result.DEFAULT;
useClickedBlock = clickedBlock == null ? Result.DENY : Result.ALLOW;
}
/**
* Returns the action type
*
* @return Action returns the type of interaction
*/
public Action getAction() {
return action;
}
/**
* Gets the cancellation state of this event. Set to true if you want to
* prevent buckets from placing water and so forth
*
* @return boolean cancellation state
*/
public boolean isCancelled() {
return useInteractedBlock() == Result.DENY;
}
/**
* Sets the cancellation state of this event. A canceled event will not be
* executed in the server, but will still pass to other plugins
* <p>
* Canceling this event will prevent use of food (player won't lose the
* food item), prevent bows/snowballs/eggs from firing, etc. (player won't
* lose the ammo)
*
* @param cancel true if you wish to cancel this event
*/
public void setCancelled(boolean cancel) {
setUseInteractedBlock(cancel ? Result.DENY : useInteractedBlock() == Result.DENY ? Result.DEFAULT : useInteractedBlock());
setUseItemInHand(cancel ? Result.DENY : useItemInHand() == Result.DENY ? Result.DEFAULT : useItemInHand());
}
/**
* Returns the item in hand represented by this event
*
* @return ItemStack the item used
*/
public ItemStack getItem() {
return this.item;
}
/**
* Convenience method. Returns the material of the item represented by
* this event
*
* @return Material the material of the item used
*/
public Material getMaterial() {
if (!hasItem()) {
return Material.AIR;
}
return item.getType();
}
/**
* Check if this event involved a block
*
* @return boolean true if it did
*/
public boolean hasBlock() {
return this.blockClicked != null;
}
/**
* Check if this event involved an item
*
* @return boolean true if it did
*/
public boolean hasItem() {
return this.item != null;
}
/**
* Convenience method to inform the user whether this was a block
* placement event.
*
* @return boolean true if the item in hand was a block
*/
public boolean isBlockInHand() {
if (!hasItem()) {
return false;
}
return item.getType().isBlock();
}
/**
* Returns the clicked block
*
* @return Block returns the block clicked with this item.
*/
public Block getClickedBlock() {
return blockClicked;
}
/**
* Returns the face of the block that was clicked
*
* @return BlockFace returns the face of the block that was clicked
*/
public BlockFace getBlockFace() {
return blockFace;
}
/**
* This controls the action to take with the block (if any) that was
* clicked on. This event gets processed for all blocks, but most don't
* have a default action
*
* @return the action to take with the interacted block
*/
public Result useInteractedBlock() {
return useClickedBlock;
}
/**
* @param useInteractedBlock the action to take with the interacted block
*/
public void setUseInteractedBlock(Result useInteractedBlock) {
this.useClickedBlock = useInteractedBlock;
}
/**
* This controls the action to take with the item the player is holding.
* This includes both blocks and items (such as flint and steel or
* records). When this is set to default, it will be allowed if no action
* is taken on the interacted block.
*
* @return the action to take with the item in hand
*/
public Result useItemInHand() {
return useItemInHand;
}
/**
* @param useItemInHand the action to take with the item in hand
*/
public void setUseItemInHand(Result useItemInHand) {
this.useItemInHand = useItemInHand;
}
/**
* The hand used to perform this interaction. May be null in the case of
* {@link Action#PHYSICAL}.
*
* @return the hand used to interact. May be null.
*/
public EquipmentSlot getHand() {
return hand;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
|
