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
|
package org.bukkit.event.player;
import java.util.HashSet;
import java.util.Set;
import org.apache.commons.lang.Validate;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
/**
* This event is called whenever a player runs a command (by placing a slash
* at the start of their message). It is called early in the command handling
* process, and modifications in this event (via {@link #setMessage(String)})
* will be shown in the behavior.
* <p>
* Many plugins will have <b>no use for this event</b>, and you should
* attempt to avoid using it if it is not necessary.
* <p>
* Some examples of valid uses for this event are:
* <ul>
* <li>Logging executed commands to a separate file
* <li>Variable substitution. For example, replacing
* <code>${nearbyPlayer}</code> with the name of the nearest other
* player, or simulating the <code>@a</code> and <code>@p</code>
* decorators used by Command Blocks in plugins that do not handle it.
* <li>Conditionally blocking commands belonging to other plugins. For
* example, blocking the use of the <code>/home</code> command in a
* combat arena.
* <li>Per-sender command aliases. For example, after a player runs the
* command <code>/calias cr gamemode creative</code>, the next time they
* run <code>/cr</code>, it gets replaced into
* <code>/gamemode creative</code>. (Global command aliases should be
* done by registering the alias.)
* </ul>
* <p>
* Examples of incorrect uses are:
* <ul>
* <li>Using this event to run command logic
* </ul>
* <p>
* If the event is cancelled, processing of the command will halt.
* <p>
* The state of whether or not there is a slash (<code>/</code>) at the
* beginning of the message should be preserved. If a slash is added or
* removed, unexpected behavior may result.
*/
public class PlayerCommandPreprocessEvent extends PlayerEvent implements Cancellable {
private static final HandlerList handlers = new HandlerList();
private boolean cancel = false;
private String message;
private final Set<Player> recipients;
public PlayerCommandPreprocessEvent(final Player player, final String message) {
super(player);
this.recipients = new HashSet<Player>(player.getServer().getOnlinePlayers());
this.message = message;
}
public PlayerCommandPreprocessEvent(final Player player, final String message, final Set<Player> recipients) {
super(player);
this.recipients = recipients;
this.message = message;
}
public boolean isCancelled() {
return cancel;
}
public void setCancelled(boolean cancel) {
this.cancel = cancel;
}
/**
* Gets the command that the player is attempting to send.
* <p>
* All commands begin with a special character; implementations do not
* consider the first character when executing the content.
*
* @return Message the player is attempting to send
*/
public String getMessage() {
return message;
}
/**
* Sets the command that the player will send.
* <p>
* All commands begin with a special character; implementations do not
* consider the first character when executing the content.
*
* @param command New message that the player will send
* @throws IllegalArgumentException if command is null or empty
*/
public void setMessage(String command) throws IllegalArgumentException {
Validate.notNull(command, "Command cannot be null");
Validate.notEmpty(command, "Command cannot be empty");
this.message = command;
}
/**
* Sets the player that this command will be executed as.
*
* @param player New player which this event will execute as
* @throws IllegalArgumentException if the player provided is null
*/
public void setPlayer(final Player player) throws IllegalArgumentException {
Validate.notNull(player, "Player cannot be null");
this.player = player;
}
/**
* Gets a set of recipients that this chat message will be displayed to.
* <p>
* The set returned is not guaranteed to be mutable and may auto-populate
* on access. Any listener accessing the returned set should be aware that
* it may reduce performance for a lazy set implementation. Listeners
* should be aware that modifying the list may throw {@link
* UnsupportedOperationException} if the event caller provides an
* unmodifiable set.
*
* @deprecated This method is provided for backward compatibility with no
* guarantee to the effect of viewing or modifying the set.
* @return All Players who will see this chat message
*/
@Deprecated
public Set<Player> getRecipients() {
return recipients;
}
@Override
public HandlerList getHandlers() {
return handlers;
}
public static HandlerList getHandlerList() {
return handlers;
}
}
|
