mirror of
https://github.com/UraniumMC/KCauldron-Bukkit
synced 2026-11-20 12:09:43 +00:00
Upload Bukkit API.
This commit is contained in:
1 parent
a97367b322
commit
220f57b421
739 files changed
+67046
No files matched your search
@@ -0,0 +1,69 @@
|
||||
package org.bukkit;
|
||||
|
||||
/**
|
||||
* Represents an achievement, which may be given to players.
|
||||
*/
|
||||
public enum Achievement {
|
||||
OPEN_INVENTORY,
|
||||
MINE_WOOD (OPEN_INVENTORY),
|
||||
BUILD_WORKBENCH (MINE_WOOD),
|
||||
BUILD_PICKAXE (BUILD_WORKBENCH),
|
||||
BUILD_FURNACE (BUILD_PICKAXE),
|
||||
ACQUIRE_IRON (BUILD_FURNACE),
|
||||
BUILD_HOE (BUILD_WORKBENCH),
|
||||
MAKE_BREAD (BUILD_HOE),
|
||||
BAKE_CAKE (BUILD_HOE),
|
||||
BUILD_BETTER_PICKAXE (BUILD_PICKAXE),
|
||||
COOK_FISH (BUILD_FURNACE),
|
||||
ON_A_RAIL (ACQUIRE_IRON),
|
||||
BUILD_SWORD (BUILD_WORKBENCH),
|
||||
KILL_ENEMY (BUILD_SWORD),
|
||||
KILL_COW (BUILD_SWORD),
|
||||
FLY_PIG (KILL_COW),
|
||||
SNIPE_SKELETON (KILL_ENEMY),
|
||||
GET_DIAMONDS (ACQUIRE_IRON),
|
||||
NETHER_PORTAL (GET_DIAMONDS),
|
||||
GHAST_RETURN (NETHER_PORTAL),
|
||||
GET_BLAZE_ROD (NETHER_PORTAL),
|
||||
BREW_POTION (GET_BLAZE_ROD),
|
||||
END_PORTAL (GET_BLAZE_ROD),
|
||||
THE_END (END_PORTAL),
|
||||
ENCHANTMENTS (GET_DIAMONDS),
|
||||
OVERKILL (ENCHANTMENTS),
|
||||
BOOKCASE (ENCHANTMENTS),
|
||||
EXPLORE_ALL_BIOMES (END_PORTAL),
|
||||
SPAWN_WITHER (THE_END),
|
||||
KILL_WITHER (SPAWN_WITHER),
|
||||
FULL_BEACON (KILL_WITHER),
|
||||
BREED_COW (KILL_COW),
|
||||
DIAMONDS_TO_YOU (GET_DIAMONDS),
|
||||
;
|
||||
|
||||
private final Achievement parent;
|
||||
|
||||
private Achievement() {
|
||||
parent = null;
|
||||
}
|
||||
|
||||
private Achievement(Achievement parent) {
|
||||
this.parent = parent;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns whether or not this achievement has a parent achievement.
|
||||
*
|
||||
* @return whether the achievement has a parent achievement
|
||||
*/
|
||||
public boolean hasParent() {
|
||||
return parent != null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the parent achievement of this achievement, or null if none.
|
||||
*
|
||||
* @return the parent achievement or null
|
||||
*/
|
||||
public Achievement getParent() {
|
||||
return parent;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,111 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.util.HashMap;
|
||||
|
||||
import org.apache.commons.lang.Validate;
|
||||
|
||||
import com.google.common.collect.Maps;
|
||||
|
||||
/**
|
||||
* Represents the art on a painting
|
||||
*/
|
||||
public enum Art {
|
||||
KEBAB(0, 1, 1),
|
||||
AZTEC(1, 1, 1),
|
||||
ALBAN(2, 1, 1),
|
||||
AZTEC2(3, 1, 1),
|
||||
BOMB(4, 1, 1),
|
||||
PLANT(5, 1, 1),
|
||||
WASTELAND(6, 1, 1),
|
||||
POOL(7, 2, 1),
|
||||
COURBET(8, 2, 1),
|
||||
SEA(9, 2, 1),
|
||||
SUNSET(10, 2, 1),
|
||||
CREEBET(11, 2, 1),
|
||||
WANDERER(12, 1, 2),
|
||||
GRAHAM(13, 1, 2),
|
||||
MATCH(14, 2, 2),
|
||||
BUST(15, 2, 2),
|
||||
STAGE(16, 2, 2),
|
||||
VOID(17, 2, 2),
|
||||
SKULL_AND_ROSES(18, 2, 2),
|
||||
WITHER(19, 2, 2),
|
||||
FIGHTERS(20, 4, 2),
|
||||
POINTER(21, 4, 4),
|
||||
PIGSCENE(22, 4, 4),
|
||||
BURNINGSKULL(23, 4, 4),
|
||||
SKELETON(24, 4, 3),
|
||||
DONKEYKONG(25, 4, 3);
|
||||
|
||||
private int id, width, height;
|
||||
private static final HashMap<String, Art> BY_NAME = Maps.newHashMap();
|
||||
private static final HashMap<Integer, Art> BY_ID = Maps.newHashMap();
|
||||
|
||||
private Art(int id, int width, int height) {
|
||||
this.id = id;
|
||||
this.width = width;
|
||||
this.height = height;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the width of the painting, in blocks
|
||||
*
|
||||
* @return The width of the painting, in blocks
|
||||
*/
|
||||
public int getBlockWidth() {
|
||||
return width;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the height of the painting, in blocks
|
||||
*
|
||||
* @return The height of the painting, in blocks
|
||||
*/
|
||||
public int getBlockHeight() {
|
||||
return height;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the ID of this painting.
|
||||
*
|
||||
* @return The ID of this painting
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public int getId() {
|
||||
return id;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a painting by its numeric ID
|
||||
*
|
||||
* @param id The ID
|
||||
* @return The painting
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public static Art getById(int id) {
|
||||
return BY_ID.get(id);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get a painting by its unique name
|
||||
* <p>
|
||||
* This ignores underscores and capitalization
|
||||
*
|
||||
* @param name The name
|
||||
* @return The painting
|
||||
*/
|
||||
public static Art getByName(String name) {
|
||||
Validate.notNull(name, "Name cannot be null");
|
||||
|
||||
return BY_NAME.get(name.toLowerCase().replaceAll("_", ""));
|
||||
}
|
||||
|
||||
static {
|
||||
for (Art art : values()) {
|
||||
BY_ID.put(art.id, art);
|
||||
BY_NAME.put(art.toString().toLowerCase().replaceAll("_", ""), art);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,127 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.util.Date;
|
||||
|
||||
/**
|
||||
* A single entry from a ban list. This may represent either a player ban or
|
||||
* an IP ban.
|
||||
* <p>
|
||||
* Ban entries include the following properties:
|
||||
* <table border=1>
|
||||
* <tr>
|
||||
* <th>Property</th>
|
||||
* <th>Description</th>
|
||||
* </tr><tr>
|
||||
* <td>Target Name / IP Address</td>
|
||||
* <td>The target name or IP address</td>
|
||||
* </tr><tr>
|
||||
* <td>Creation Date</td>
|
||||
* <td>The creation date of the ban</td>
|
||||
* </tr><tr>
|
||||
* <td>Source</td>
|
||||
* <td>The source of the ban, such as a player, console, plugin, etc</td>
|
||||
* </tr><tr>
|
||||
* <td>Expiration Date</td>
|
||||
* <td>The expiration date of the ban</td>
|
||||
* </tr><tr>
|
||||
* <td>Reason</td>
|
||||
* <td>The reason for the ban</td>
|
||||
* </tr>
|
||||
* </table>
|
||||
* <p>
|
||||
* Unsaved information is not automatically written to the implementation's
|
||||
* ban list, instead, the {@link #save()} method must be called to write the
|
||||
* changes to the ban list. If this ban entry has expired (such as from an
|
||||
* unban) and is no longer found in the list, the {@link #save()} call will
|
||||
* re-add it to the list, therefore banning the victim specified.
|
||||
* <p>
|
||||
* Likewise, changes to the associated {@link BanList} or other entries may or
|
||||
* may not be reflected in this entry.
|
||||
*/
|
||||
public interface BanEntry {
|
||||
|
||||
/**
|
||||
* Gets the target involved. This may be in the form of an IP or a player
|
||||
* name.
|
||||
*
|
||||
* @return the target name or IP address
|
||||
*/
|
||||
public String getTarget();
|
||||
|
||||
/**
|
||||
* Gets the date this ban entry was created.
|
||||
*
|
||||
* @return the creation date
|
||||
*/
|
||||
public Date getCreated();
|
||||
|
||||
/**
|
||||
* Sets the date this ban entry was created.
|
||||
*
|
||||
* @param created the new created date, cannot be null
|
||||
* @see #save() saving changes
|
||||
*/
|
||||
public void setCreated(Date created);
|
||||
|
||||
/**
|
||||
* Gets the source of this ban.
|
||||
* <p>
|
||||
* Note: A source is considered any String, although this is generally a
|
||||
* player name.
|
||||
*
|
||||
* @return the source of the ban
|
||||
*/
|
||||
public String getSource();
|
||||
|
||||
/**
|
||||
* Sets the source of this ban.
|
||||
* <p>
|
||||
* Note: A source is considered any String, although this is generally a
|
||||
* player name.
|
||||
*
|
||||
* @param source the new source where null values become empty strings
|
||||
* @see #save() saving changes
|
||||
*/
|
||||
public void setSource(String source);
|
||||
|
||||
/**
|
||||
* Gets the date this ban expires on, or null for no defined end date.
|
||||
*
|
||||
* @return the expiration date
|
||||
*/
|
||||
public Date getExpiration();
|
||||
|
||||
/**
|
||||
* Sets the date this ban expires on. Null values are considered
|
||||
* "infinite" bans.
|
||||
*
|
||||
* @param expiration the new expiration date, or null to indicate an
|
||||
* eternity
|
||||
* @see #save() saving changes
|
||||
*/
|
||||
public void setExpiration(Date expiration);
|
||||
|
||||
/**
|
||||
* Gets the reason for this ban.
|
||||
*
|
||||
* @return the ban reason, or null if not set
|
||||
*/
|
||||
public String getReason();
|
||||
|
||||
/**
|
||||
* Sets the reason for this ban. Reasons must not be null.
|
||||
*
|
||||
* @param reason the new reason, null values assume the implementation
|
||||
* default
|
||||
* @see #save() saving changes
|
||||
*/
|
||||
public void setReason(String reason);
|
||||
|
||||
/**
|
||||
* Saves the ban entry, overwriting any previous data in the ban list.
|
||||
* <p>
|
||||
* Saving the ban entry of an unbanned player will cause the player to be
|
||||
* banned once again.
|
||||
*/
|
||||
public void save();
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.util.Date;
|
||||
import java.util.Set;
|
||||
|
||||
/**
|
||||
* A ban list, containing bans of some {@link Type}.
|
||||
*/
|
||||
public interface BanList {
|
||||
|
||||
/**
|
||||
* Represents a ban-type that a {@link BanList} may track.
|
||||
*/
|
||||
public enum Type {
|
||||
/**
|
||||
* Banned player names
|
||||
*/
|
||||
NAME,
|
||||
/**
|
||||
* Banned player IP addresses
|
||||
*/
|
||||
IP,
|
||||
;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a {@link BanEntry} by target.
|
||||
*
|
||||
* @param target entry parameter to search for
|
||||
* @return the corresponding entry, or null if none found
|
||||
*/
|
||||
public BanEntry getBanEntry(String target);
|
||||
|
||||
/**
|
||||
* Adds a ban to the this list. If a previous ban exists, this will
|
||||
* update the previous entry.
|
||||
*
|
||||
* @param target the target of the ban
|
||||
* @param reason reason for the ban, null indicates implementation default
|
||||
* @param expires date for the ban's expiration (unban), or null to imply
|
||||
* forever
|
||||
* @param source source of the ban, null indicates implementation default
|
||||
* @return the entry for the newly created ban, or the entry for the
|
||||
* (updated) previous ban
|
||||
*/
|
||||
public BanEntry addBan(String target, String reason, Date expires, String source);
|
||||
|
||||
/**
|
||||
* Gets a set containing every {@link BanEntry} in this list.
|
||||
*
|
||||
* @return an immutable set containing every entry tracked by this list
|
||||
*/
|
||||
public Set<BanEntry> getBanEntries();
|
||||
|
||||
/**
|
||||
* Gets if a {@link BanEntry} exists for the target, indicating an active
|
||||
* ban status.
|
||||
*
|
||||
* @param target the target to find
|
||||
* @return true if a {@link BanEntry} exists for the name, indicating an
|
||||
* active ban status, false otherwise
|
||||
*/
|
||||
public boolean isBanned(String target);
|
||||
|
||||
/**
|
||||
* Removes the specified target from this list, therefore indicating a
|
||||
* "not banned" status.
|
||||
*
|
||||
* @param target the target to remove from this list
|
||||
*/
|
||||
public void pardon(String target);
|
||||
}
|
||||
@@ -0,0 +1,104 @@
|
||||
package org.bukkit;
|
||||
|
||||
/**
|
||||
* A delegate for handling block changes. This serves as a direct interface
|
||||
* between generation algorithms in the server implementation and utilizing
|
||||
* code.
|
||||
*/
|
||||
public interface BlockChangeDelegate {
|
||||
|
||||
/**
|
||||
* Set a block type at the specified coordinates without doing all world
|
||||
* updates and notifications.
|
||||
* <p>
|
||||
* It is safe to have this call World.setTypeId, but it may be slower than
|
||||
* World.setRawTypeId.
|
||||
*
|
||||
* @param x X coordinate
|
||||
* @param y Y coordinate
|
||||
* @param z Z coordinate
|
||||
* @param typeId New block ID
|
||||
* @return true if the block was set successfully
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public boolean setRawTypeId(int x, int y, int z, int typeId);
|
||||
|
||||
/**
|
||||
* Set a block type and data at the specified coordinates without doing
|
||||
* all world updates and notifications.
|
||||
* <p>
|
||||
* It is safe to have this call World.setTypeId, but it may be slower than
|
||||
* World.setRawTypeId.
|
||||
*
|
||||
* @param x X coordinate
|
||||
* @param y Y coordinate
|
||||
* @param z Z coordinate
|
||||
* @param typeId New block ID
|
||||
* @param data Block data
|
||||
* @return true if the block was set successfully
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public boolean setRawTypeIdAndData(int x, int y, int z, int typeId, int data);
|
||||
|
||||
/**
|
||||
* Set a block type at the specified coordinates.
|
||||
* <p>
|
||||
* This method cannot call World.setRawTypeId, a full update is needed.
|
||||
*
|
||||
* @param x X coordinate
|
||||
* @param y Y coordinate
|
||||
* @param z Z coordinate
|
||||
* @param typeId New block ID
|
||||
* @return true if the block was set successfully
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public boolean setTypeId(int x, int y, int z, int typeId);
|
||||
|
||||
/**
|
||||
* Set a block type and data at the specified coordinates.
|
||||
* <p>
|
||||
* This method cannot call World.setRawTypeId, a full update is needed.
|
||||
*
|
||||
* @param x X coordinate
|
||||
* @param y Y coordinate
|
||||
* @param z Z coordinate
|
||||
* @param typeId New block ID
|
||||
* @param data Block data
|
||||
* @return true if the block was set successfully
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public boolean setTypeIdAndData(int x, int y, int z, int typeId, int data);
|
||||
|
||||
/**
|
||||
* Get the block type at the location.
|
||||
*
|
||||
* @param x X coordinate
|
||||
* @param y Y coordinate
|
||||
* @param z Z coordinate
|
||||
* @return The block ID
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public int getTypeId(int x, int y, int z);
|
||||
|
||||
/**
|
||||
* Gets the height of the world.
|
||||
*
|
||||
* @return Height of the world
|
||||
*/
|
||||
public int getHeight();
|
||||
|
||||
/**
|
||||
* Checks if the specified block is empty (air) or not.
|
||||
*
|
||||
* @param x X coordinate
|
||||
* @param y Y coordinate
|
||||
* @param z Z coordinate
|
||||
* @return True if the block is considered empty.
|
||||
*/
|
||||
public boolean isEmpty(int x, int y, int z);
|
||||
}
|
||||
@@ -0,0 +1,750 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.awt.image.BufferedImage;
|
||||
import java.io.File;
|
||||
import java.util.Collection;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.UUID;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import org.bukkit.Warning.WarningState;
|
||||
import org.bukkit.command.CommandException;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.command.ConsoleCommandSender;
|
||||
import org.bukkit.command.PluginCommand;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.event.inventory.InventoryType;
|
||||
import org.bukkit.help.HelpMap;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
import org.bukkit.inventory.Inventory;
|
||||
import org.bukkit.inventory.InventoryHolder;
|
||||
import org.bukkit.inventory.ItemFactory;
|
||||
import org.bukkit.inventory.Recipe;
|
||||
import org.bukkit.map.MapView;
|
||||
import org.bukkit.plugin.PluginManager;
|
||||
import org.bukkit.plugin.ServicesManager;
|
||||
import org.bukkit.plugin.messaging.Messenger;
|
||||
import org.bukkit.scheduler.BukkitScheduler;
|
||||
import org.bukkit.scoreboard.ScoreboardManager;
|
||||
import org.bukkit.util.CachedServerIcon;
|
||||
|
||||
import com.avaje.ebean.config.ServerConfig;
|
||||
|
||||
/**
|
||||
* Represents the Bukkit core, for version and Server singleton handling
|
||||
*/
|
||||
public final class Bukkit {
|
||||
private static Server server;
|
||||
|
||||
/**
|
||||
* Static class cannot be initialized.
|
||||
*/
|
||||
private Bukkit() {}
|
||||
|
||||
/**
|
||||
* Gets the current {@link Server} singleton
|
||||
*
|
||||
* @return Server instance being ran
|
||||
*/
|
||||
public static Server getServer() {
|
||||
return server;
|
||||
}
|
||||
|
||||
/**
|
||||
* Attempts to set the {@link Server} singleton.
|
||||
* <p>
|
||||
* This cannot be done if the Server is already set.
|
||||
*
|
||||
* @param server Server instance
|
||||
*/
|
||||
public static void setServer(Server server) {
|
||||
if (Bukkit.server != null) {
|
||||
throw new UnsupportedOperationException("Cannot redefine singleton Server");
|
||||
}
|
||||
|
||||
Bukkit.server = server;
|
||||
server.getLogger().info("This server is running " + getName() + " version " + getVersion() + " (Implementing API version " + getBukkitVersion() + ")");
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getName()
|
||||
*/
|
||||
public static String getName() {
|
||||
return server.getName();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getVersion()
|
||||
*/
|
||||
public static String getVersion() {
|
||||
return server.getVersion();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getBukkitVersion()
|
||||
*/
|
||||
public static String getBukkitVersion() {
|
||||
return server.getBukkitVersion();
|
||||
}
|
||||
|
||||
/**
|
||||
* This method exists for legacy reasons to provide backwards
|
||||
* compatibility. It will not exist at runtime and should not be used
|
||||
* under any circumstances.
|
||||
*
|
||||
* @Deprecated
|
||||
* @see Server#_INVALID_getOnlinePlayers()
|
||||
*/
|
||||
@Deprecated
|
||||
public static Player[] _INVALID_getOnlinePlayers() {
|
||||
return server._INVALID_getOnlinePlayers();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getOnlinePlayers()
|
||||
*/
|
||||
public static Collection<? extends Player> getOnlinePlayers() {
|
||||
return server.getOnlinePlayers();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getMaxPlayers()
|
||||
*/
|
||||
public static int getMaxPlayers() {
|
||||
return server.getMaxPlayers();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getPort()
|
||||
*/
|
||||
public static int getPort() {
|
||||
return server.getPort();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getViewDistance()
|
||||
*/
|
||||
public static int getViewDistance() {
|
||||
return server.getViewDistance();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getIp()
|
||||
*/
|
||||
public static String getIp() {
|
||||
return server.getIp();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getServerName()
|
||||
*/
|
||||
public static String getServerName() {
|
||||
return server.getServerName();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getServerId()
|
||||
*/
|
||||
public static String getServerId() {
|
||||
return server.getServerId();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getWorldType()
|
||||
*/
|
||||
public static String getWorldType() {
|
||||
return server.getWorldType();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getGenerateStructures()
|
||||
*/
|
||||
public static boolean getGenerateStructures() {
|
||||
return server.getGenerateStructures();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getAllowNether()
|
||||
*/
|
||||
public static boolean getAllowNether() {
|
||||
return server.getAllowNether();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#hasWhitelist()
|
||||
*/
|
||||
public static boolean hasWhitelist() {
|
||||
return server.hasWhitelist();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#broadcastMessage(String message)
|
||||
*/
|
||||
public static int broadcastMessage(String message) {
|
||||
return server.broadcastMessage(message);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getUpdateFolder()
|
||||
*/
|
||||
public static String getUpdateFolder() {
|
||||
return server.getUpdateFolder();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getPlayer(String name)
|
||||
*/
|
||||
@Deprecated
|
||||
public static Player getPlayer(String name) {
|
||||
return server.getPlayer(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#matchPlayer(String name)
|
||||
*/
|
||||
@Deprecated
|
||||
public static List<Player> matchPlayer(String name) {
|
||||
return server.matchPlayer(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getPlayer(java.util.UUID)
|
||||
*/
|
||||
public static Player getPlayer(UUID id) {
|
||||
return server.getPlayer(id);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getPluginManager()
|
||||
*/
|
||||
public static PluginManager getPluginManager() {
|
||||
return server.getPluginManager();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getScheduler()
|
||||
*/
|
||||
public static BukkitScheduler getScheduler() {
|
||||
return server.getScheduler();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getServicesManager()
|
||||
*/
|
||||
public static ServicesManager getServicesManager() {
|
||||
return server.getServicesManager();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getWorlds()
|
||||
*/
|
||||
public static List<World> getWorlds() {
|
||||
return server.getWorlds();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#createWorld(WorldCreator options)
|
||||
*/
|
||||
public static World createWorld(WorldCreator options) {
|
||||
return server.createWorld(options);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#unloadWorld(String name, boolean save)
|
||||
*/
|
||||
public static boolean unloadWorld(String name, boolean save) {
|
||||
return server.unloadWorld(name, save);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#unloadWorld(World world, boolean save)
|
||||
*/
|
||||
public static boolean unloadWorld(World world, boolean save) {
|
||||
return server.unloadWorld(world, save);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getWorld(String name)
|
||||
*/
|
||||
public static World getWorld(String name) {
|
||||
return server.getWorld(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getWorld(UUID uid)
|
||||
*/
|
||||
public static World getWorld(UUID uid) {
|
||||
return server.getWorld(uid);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getMap(short id)
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public static MapView getMap(short id) {
|
||||
return server.getMap(id);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#createMap(World world)
|
||||
*/
|
||||
public static MapView createMap(World world) {
|
||||
return server.createMap(world);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#reload()
|
||||
*/
|
||||
public static void reload() {
|
||||
server.reload();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getLogger()
|
||||
*/
|
||||
public static Logger getLogger() {
|
||||
return server.getLogger();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getPluginCommand(String name)
|
||||
*/
|
||||
public static PluginCommand getPluginCommand(String name) {
|
||||
return server.getPluginCommand(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#savePlayers()
|
||||
*/
|
||||
public static void savePlayers() {
|
||||
server.savePlayers();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#dispatchCommand(CommandSender sender, String commandLine)
|
||||
*/
|
||||
public static boolean dispatchCommand(CommandSender sender, String commandLine) throws CommandException {
|
||||
return server.dispatchCommand(sender, commandLine);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#configureDbConfig(ServerConfig config)
|
||||
*/
|
||||
public static void configureDbConfig(ServerConfig config) {
|
||||
server.configureDbConfig(config);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#addRecipe(Recipe recipe)
|
||||
*/
|
||||
public static boolean addRecipe(Recipe recipe) {
|
||||
return server.addRecipe(recipe);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getRecipesFor(ItemStack result)
|
||||
*/
|
||||
public static List<Recipe> getRecipesFor(ItemStack result) {
|
||||
return server.getRecipesFor(result);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#recipeIterator()
|
||||
*/
|
||||
public static Iterator<Recipe> recipeIterator() {
|
||||
return server.recipeIterator();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#clearRecipes()
|
||||
*/
|
||||
public static void clearRecipes() {
|
||||
server.clearRecipes();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#resetRecipes()
|
||||
*/
|
||||
public static void resetRecipes() {
|
||||
server.resetRecipes();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getCommandAliases()
|
||||
*/
|
||||
public static Map<String, String[]> getCommandAliases() {
|
||||
return server.getCommandAliases();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getSpawnRadius()
|
||||
*/
|
||||
public static int getSpawnRadius() {
|
||||
return server.getSpawnRadius();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#setSpawnRadius(int value)
|
||||
*/
|
||||
public static void setSpawnRadius(int value) {
|
||||
server.setSpawnRadius(value);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getOnlineMode()
|
||||
*/
|
||||
public static boolean getOnlineMode() {
|
||||
return server.getOnlineMode();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getAllowFlight()
|
||||
*/
|
||||
public static boolean getAllowFlight() {
|
||||
return server.getAllowFlight();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#isHardcore()
|
||||
*/
|
||||
public static boolean isHardcore() {
|
||||
return server.isHardcore();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#shutdown()
|
||||
*/
|
||||
public static void shutdown() {
|
||||
server.shutdown();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#broadcast(String message, String permission)
|
||||
*/
|
||||
public static int broadcast(String message, String permission) {
|
||||
return server.broadcast(message, permission);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getOfflinePlayer(String name)
|
||||
*/
|
||||
@Deprecated
|
||||
public static OfflinePlayer getOfflinePlayer(String name) {
|
||||
return server.getOfflinePlayer(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getOfflinePlayer(java.util.UUID)
|
||||
*/
|
||||
public static OfflinePlayer getOfflinePlayer(UUID id) {
|
||||
return server.getOfflinePlayer(id);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getPlayerExact(String name)
|
||||
*/
|
||||
@Deprecated
|
||||
public static Player getPlayerExact(String name) {
|
||||
return server.getPlayerExact(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getIPBans()
|
||||
*/
|
||||
public static Set<String> getIPBans() {
|
||||
return server.getIPBans();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#banIP(String address)
|
||||
*/
|
||||
public static void banIP(String address) {
|
||||
server.banIP(address);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#unbanIP(String address)
|
||||
*/
|
||||
public static void unbanIP(String address) {
|
||||
server.unbanIP(address);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getBannedPlayers()
|
||||
*/
|
||||
public static Set<OfflinePlayer> getBannedPlayers() {
|
||||
return server.getBannedPlayers();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getBanList(BanList.Type)
|
||||
*/
|
||||
public static BanList getBanList(BanList.Type type){
|
||||
return server.getBanList(type);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#setWhitelist(boolean value)
|
||||
*/
|
||||
public static void setWhitelist(boolean value) {
|
||||
server.setWhitelist(value);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getWhitelistedPlayers()
|
||||
*/
|
||||
public static Set<OfflinePlayer> getWhitelistedPlayers() {
|
||||
return server.getWhitelistedPlayers();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#reloadWhitelist()
|
||||
*/
|
||||
public static void reloadWhitelist() {
|
||||
server.reloadWhitelist();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getConsoleSender()
|
||||
*/
|
||||
public static ConsoleCommandSender getConsoleSender() {
|
||||
return server.getConsoleSender();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getOperators()
|
||||
*/
|
||||
public static Set<OfflinePlayer> getOperators() {
|
||||
return server.getOperators();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getWorldContainer()
|
||||
*/
|
||||
public static File getWorldContainer() {
|
||||
return server.getWorldContainer();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getMessenger()
|
||||
*/
|
||||
public static Messenger getMessenger() {
|
||||
return server.getMessenger();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getAllowEnd()
|
||||
*/
|
||||
public static boolean getAllowEnd() {
|
||||
return server.getAllowEnd();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getUpdateFolderFile()
|
||||
*/
|
||||
public static File getUpdateFolderFile() {
|
||||
return server.getUpdateFolderFile();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getConnectionThrottle()
|
||||
*/
|
||||
public static long getConnectionThrottle() {
|
||||
return server.getConnectionThrottle();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getTicksPerAnimalSpawns()
|
||||
*/
|
||||
public static int getTicksPerAnimalSpawns() {
|
||||
return server.getTicksPerAnimalSpawns();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getTicksPerMonsterSpawns()
|
||||
*/
|
||||
public static int getTicksPerMonsterSpawns() {
|
||||
return server.getTicksPerMonsterSpawns();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#useExactLoginLocation()
|
||||
*/
|
||||
public static boolean useExactLoginLocation() {
|
||||
return server.useExactLoginLocation();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getDefaultGameMode()
|
||||
*/
|
||||
public static GameMode getDefaultGameMode() {
|
||||
return server.getDefaultGameMode();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#setDefaultGameMode(GameMode mode)
|
||||
*/
|
||||
public static void setDefaultGameMode(GameMode mode) {
|
||||
server.setDefaultGameMode(mode);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getOfflinePlayers()
|
||||
*/
|
||||
public static OfflinePlayer[] getOfflinePlayers() {
|
||||
return server.getOfflinePlayers();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#createInventory(InventoryHolder owner, InventoryType type)
|
||||
*/
|
||||
public static Inventory createInventory(InventoryHolder owner, InventoryType type) {
|
||||
return server.createInventory(owner, type);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#createInventory(InventoryHolder owner, InventoryType type, String title)
|
||||
*/
|
||||
public static Inventory createInventory(InventoryHolder owner, InventoryType type, String title) {
|
||||
return server.createInventory(owner, type, title);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#createInventory(InventoryHolder owner, int size)
|
||||
*/
|
||||
public static Inventory createInventory(InventoryHolder owner, int size) throws IllegalArgumentException {
|
||||
return server.createInventory(owner, size);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#createInventory(InventoryHolder owner, int size, String
|
||||
* title)
|
||||
*/
|
||||
public static Inventory createInventory(InventoryHolder owner, int size, String title) throws IllegalArgumentException {
|
||||
return server.createInventory(owner, size, title);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getHelpMap()
|
||||
*/
|
||||
public static HelpMap getHelpMap() {
|
||||
return server.getHelpMap();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getMonsterSpawnLimit()
|
||||
*/
|
||||
public static int getMonsterSpawnLimit() {
|
||||
return server.getMonsterSpawnLimit();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getAnimalSpawnLimit()
|
||||
*/
|
||||
public static int getAnimalSpawnLimit() {
|
||||
return server.getAnimalSpawnLimit();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getWaterAnimalSpawnLimit()
|
||||
*/
|
||||
public static int getWaterAnimalSpawnLimit() {
|
||||
return server.getWaterAnimalSpawnLimit();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getAmbientSpawnLimit()
|
||||
*/
|
||||
public static int getAmbientSpawnLimit() {
|
||||
return server.getAmbientSpawnLimit();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#isPrimaryThread()
|
||||
*/
|
||||
public static boolean isPrimaryThread() {
|
||||
return server.isPrimaryThread();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getMotd()
|
||||
*/
|
||||
public static String getMotd() {
|
||||
return server.getMotd();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getShutdownMessage()
|
||||
*/
|
||||
public static String getShutdownMessage() {
|
||||
return server.getShutdownMessage();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getWarningState()
|
||||
*/
|
||||
public static WarningState getWarningState() {
|
||||
return server.getWarningState();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getItemFactory()
|
||||
*/
|
||||
public static ItemFactory getItemFactory() {
|
||||
return server.getItemFactory();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getScoreboardManager()
|
||||
*/
|
||||
public static ScoreboardManager getScoreboardManager() {
|
||||
return server.getScoreboardManager();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getServerIcon()
|
||||
*/
|
||||
public static CachedServerIcon getServerIcon() {
|
||||
return server.getServerIcon();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#loadServerIcon(File)
|
||||
*/
|
||||
public static CachedServerIcon loadServerIcon(File file) throws IllegalArgumentException, Exception {
|
||||
return server.loadServerIcon(file);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#loadServerIcon(BufferedImage)
|
||||
*/
|
||||
public static CachedServerIcon loadServerIcon(BufferedImage image) throws IllegalArgumentException, Exception {
|
||||
return server.loadServerIcon(image);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#setIdleTimeout(int)
|
||||
*/
|
||||
public static void setIdleTimeout(int threshold) {
|
||||
server.setIdleTimeout(threshold);
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getIdleTimeout()
|
||||
*/
|
||||
public static int getIdleTimeout() {
|
||||
return server.getIdleTimeout();
|
||||
}
|
||||
|
||||
/**
|
||||
* @see Server#getUnsafe()
|
||||
*/
|
||||
@Deprecated
|
||||
public static UnsafeValues getUnsafe() {
|
||||
return server.getUnsafe();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,253 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.util.Map;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
import org.apache.commons.lang.Validate;
|
||||
|
||||
import com.google.common.collect.Maps;
|
||||
|
||||
/**
|
||||
* All supported color values for chat
|
||||
*/
|
||||
public enum ChatColor {
|
||||
/**
|
||||
* Represents black
|
||||
*/
|
||||
BLACK('0', 0x00),
|
||||
/**
|
||||
* Represents dark blue
|
||||
*/
|
||||
DARK_BLUE('1', 0x1),
|
||||
/**
|
||||
* Represents dark green
|
||||
*/
|
||||
DARK_GREEN('2', 0x2),
|
||||
/**
|
||||
* Represents dark blue (aqua)
|
||||
*/
|
||||
DARK_AQUA('3', 0x3),
|
||||
/**
|
||||
* Represents dark red
|
||||
*/
|
||||
DARK_RED('4', 0x4),
|
||||
/**
|
||||
* Represents dark purple
|
||||
*/
|
||||
DARK_PURPLE('5', 0x5),
|
||||
/**
|
||||
* Represents gold
|
||||
*/
|
||||
GOLD('6', 0x6),
|
||||
/**
|
||||
* Represents gray
|
||||
*/
|
||||
GRAY('7', 0x7),
|
||||
/**
|
||||
* Represents dark gray
|
||||
*/
|
||||
DARK_GRAY('8', 0x8),
|
||||
/**
|
||||
* Represents blue
|
||||
*/
|
||||
BLUE('9', 0x9),
|
||||
/**
|
||||
* Represents green
|
||||
*/
|
||||
GREEN('a', 0xA),
|
||||
/**
|
||||
* Represents aqua
|
||||
*/
|
||||
AQUA('b', 0xB),
|
||||
/**
|
||||
* Represents red
|
||||
*/
|
||||
RED('c', 0xC),
|
||||
/**
|
||||
* Represents light purple
|
||||
*/
|
||||
LIGHT_PURPLE('d', 0xD),
|
||||
/**
|
||||
* Represents yellow
|
||||
*/
|
||||
YELLOW('e', 0xE),
|
||||
/**
|
||||
* Represents white
|
||||
*/
|
||||
WHITE('f', 0xF),
|
||||
/**
|
||||
* Represents magical characters that change around randomly
|
||||
*/
|
||||
MAGIC('k', 0x10, true),
|
||||
/**
|
||||
* Makes the text bold.
|
||||
*/
|
||||
BOLD('l', 0x11, true),
|
||||
/**
|
||||
* Makes a line appear through the text.
|
||||
*/
|
||||
STRIKETHROUGH('m', 0x12, true),
|
||||
/**
|
||||
* Makes the text appear underlined.
|
||||
*/
|
||||
UNDERLINE('n', 0x13, true),
|
||||
/**
|
||||
* Makes the text italic.
|
||||
*/
|
||||
ITALIC('o', 0x14, true),
|
||||
/**
|
||||
* Resets all previous chat colors or formats.
|
||||
*/
|
||||
RESET('r', 0x15);
|
||||
|
||||
/**
|
||||
* The special character which prefixes all chat colour codes. Use this if
|
||||
* you need to dynamically convert colour codes from your custom format.
|
||||
*/
|
||||
public static final char COLOR_CHAR = '\u00A7';
|
||||
private static final Pattern STRIP_COLOR_PATTERN = Pattern.compile("(?i)" + String.valueOf(COLOR_CHAR) + "[0-9A-FK-OR]");
|
||||
|
||||
private final int intCode;
|
||||
private final char code;
|
||||
private final boolean isFormat;
|
||||
private final String toString;
|
||||
private final static Map<Integer, ChatColor> BY_ID = Maps.newHashMap();
|
||||
private final static Map<Character, ChatColor> BY_CHAR = Maps.newHashMap();
|
||||
|
||||
private ChatColor(char code, int intCode) {
|
||||
this(code, intCode, false);
|
||||
}
|
||||
|
||||
private ChatColor(char code, int intCode, boolean isFormat) {
|
||||
this.code = code;
|
||||
this.intCode = intCode;
|
||||
this.isFormat = isFormat;
|
||||
this.toString = new String(new char[] {COLOR_CHAR, code});
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the char value associated with this color
|
||||
*
|
||||
* @return A char value of this color code
|
||||
*/
|
||||
public char getChar() {
|
||||
return code;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return toString;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if this code is a format code as opposed to a color code.
|
||||
*/
|
||||
public boolean isFormat() {
|
||||
return isFormat;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if this code is a color code as opposed to a format code.
|
||||
*/
|
||||
public boolean isColor() {
|
||||
return !isFormat && this != RESET;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the color represented by the specified color code
|
||||
*
|
||||
* @param code Code to check
|
||||
* @return Associative {@link org.bukkit.ChatColor} with the given code,
|
||||
* or null if it doesn't exist
|
||||
*/
|
||||
public static ChatColor getByChar(char code) {
|
||||
return BY_CHAR.get(code);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the color represented by the specified color code
|
||||
*
|
||||
* @param code Code to check
|
||||
* @return Associative {@link org.bukkit.ChatColor} with the given code,
|
||||
* or null if it doesn't exist
|
||||
*/
|
||||
public static ChatColor getByChar(String code) {
|
||||
Validate.notNull(code, "Code cannot be null");
|
||||
Validate.isTrue(code.length() > 0, "Code must have at least one char");
|
||||
|
||||
return BY_CHAR.get(code.charAt(0));
|
||||
}
|
||||
|
||||
/**
|
||||
* Strips the given message of all color codes
|
||||
*
|
||||
* @param input String to strip of color
|
||||
* @return A copy of the input string, without any coloring
|
||||
*/
|
||||
public static String stripColor(final String input) {
|
||||
if (input == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return STRIP_COLOR_PATTERN.matcher(input).replaceAll("");
|
||||
}
|
||||
|
||||
/**
|
||||
* Translates a string using an alternate color code character into a
|
||||
* string that uses the internal ChatColor.COLOR_CODE color code
|
||||
* character. The alternate color code character will only be replaced if
|
||||
* it is immediately followed by 0-9, A-F, a-f, K-O, k-o, R or r.
|
||||
*
|
||||
* @param altColorChar The alternate color code character to replace. Ex: &
|
||||
* @param textToTranslate Text containing the alternate color code character.
|
||||
* @return Text containing the ChatColor.COLOR_CODE color code character.
|
||||
*/
|
||||
public static String translateAlternateColorCodes(char altColorChar, String textToTranslate) {
|
||||
char[] b = textToTranslate.toCharArray();
|
||||
for (int i = 0; i < b.length - 1; i++) {
|
||||
if (b[i] == altColorChar && "0123456789AaBbCcDdEeFfKkLlMmNnOoRr".indexOf(b[i+1]) > -1) {
|
||||
b[i] = ChatColor.COLOR_CHAR;
|
||||
b[i+1] = Character.toLowerCase(b[i+1]);
|
||||
}
|
||||
}
|
||||
return new String(b);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the ChatColors used at the end of the given input string.
|
||||
*
|
||||
* @param input Input string to retrieve the colors from.
|
||||
* @return Any remaining ChatColors to pass onto the next line.
|
||||
*/
|
||||
public static String getLastColors(String input) {
|
||||
String result = "";
|
||||
int length = input.length();
|
||||
|
||||
// Search backwards from the end as it is faster
|
||||
for (int index = length - 1; index > -1; index--) {
|
||||
char section = input.charAt(index);
|
||||
if (section == COLOR_CHAR && index < length - 1) {
|
||||
char c = input.charAt(index + 1);
|
||||
ChatColor color = getByChar(c);
|
||||
|
||||
if (color != null) {
|
||||
result = color.toString() + result;
|
||||
|
||||
// Once we find a color or reset we can stop searching
|
||||
if (color.isColor() || color.equals(RESET)) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static {
|
||||
for (ChatColor color : values()) {
|
||||
BY_ID.put(color.intCode, color);
|
||||
BY_CHAR.put(color.code, color);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,124 @@
|
||||
package org.bukkit;
|
||||
|
||||
import org.bukkit.block.Block;
|
||||
import org.bukkit.block.BlockState;
|
||||
import org.bukkit.entity.Entity;
|
||||
|
||||
/**
|
||||
* Represents a chunk of blocks
|
||||
*/
|
||||
public interface Chunk {
|
||||
|
||||
/**
|
||||
* Gets the X-coordinate of this chunk
|
||||
*
|
||||
* @return X-coordinate
|
||||
*/
|
||||
int getX();
|
||||
|
||||
/**
|
||||
* Gets the Z-coordinate of this chunk
|
||||
*
|
||||
* @return Z-coordinate
|
||||
*/
|
||||
int getZ();
|
||||
|
||||
/**
|
||||
* Gets the world containing this chunk
|
||||
*
|
||||
* @return Parent World
|
||||
*/
|
||||
World getWorld();
|
||||
|
||||
/**
|
||||
* Gets a block from this chunk
|
||||
*
|
||||
* @param x 0-15
|
||||
* @param y 0-127
|
||||
* @param z 0-15
|
||||
* @return the Block
|
||||
*/
|
||||
Block getBlock(int x, int y, int z);
|
||||
|
||||
/**
|
||||
* Capture thread-safe read-only snapshot of chunk data
|
||||
*
|
||||
* @return ChunkSnapshot
|
||||
*/
|
||||
ChunkSnapshot getChunkSnapshot();
|
||||
|
||||
/**
|
||||
* Capture thread-safe read-only snapshot of chunk data
|
||||
*
|
||||
* @param includeMaxblocky - if true, snapshot includes per-coordinate
|
||||
* maximum Y values
|
||||
* @param includeBiome - if true, snapshot includes per-coordinate biome
|
||||
* type
|
||||
* @param includeBiomeTempRain - if true, snapshot includes per-coordinate
|
||||
* raw biome temperature and rainfall
|
||||
* @return ChunkSnapshot
|
||||
*/
|
||||
ChunkSnapshot getChunkSnapshot(boolean includeMaxblocky, boolean includeBiome, boolean includeBiomeTempRain);
|
||||
|
||||
/**
|
||||
* Get a list of all entities in the chunk.
|
||||
*
|
||||
* @return The entities.
|
||||
*/
|
||||
Entity[] getEntities();
|
||||
|
||||
/**
|
||||
* Get a list of all tile entities in the chunk.
|
||||
*
|
||||
* @return The tile entities.
|
||||
*/
|
||||
BlockState[] getTileEntities();
|
||||
|
||||
/**
|
||||
* Checks if the chunk is loaded.
|
||||
*
|
||||
* @return True if it is loaded.
|
||||
*/
|
||||
boolean isLoaded();
|
||||
|
||||
/**
|
||||
* Loads the chunk.
|
||||
*
|
||||
* @param generate Whether or not to generate a chunk if it doesn't
|
||||
* already exist
|
||||
* @return true if the chunk has loaded successfully, otherwise false
|
||||
*/
|
||||
boolean load(boolean generate);
|
||||
|
||||
/**
|
||||
* Loads the chunk.
|
||||
*
|
||||
* @return true if the chunk has loaded successfully, otherwise false
|
||||
*/
|
||||
boolean load();
|
||||
|
||||
/**
|
||||
* Unloads and optionally saves the Chunk
|
||||
*
|
||||
* @param save Controls whether the chunk is saved
|
||||
* @param safe Controls whether to unload the chunk when players are
|
||||
* nearby
|
||||
* @return true if the chunk has unloaded successfully, otherwise false
|
||||
*/
|
||||
boolean unload(boolean save, boolean safe);
|
||||
|
||||
/**
|
||||
* Unloads and optionally saves the Chunk
|
||||
*
|
||||
* @param save Controls whether the chunk is saved
|
||||
* @return true if the chunk has unloaded successfully, otherwise false
|
||||
*/
|
||||
boolean unload(boolean save);
|
||||
|
||||
/**
|
||||
* Unloads and optionally saves the Chunk
|
||||
*
|
||||
* @return true if the chunk has unloaded successfully, otherwise false
|
||||
*/
|
||||
boolean unload();
|
||||
}
|
||||
@@ -0,0 +1,129 @@
|
||||
package org.bukkit;
|
||||
|
||||
import org.bukkit.block.Biome;
|
||||
|
||||
/**
|
||||
* Represents a static, thread-safe snapshot of chunk of blocks.
|
||||
* <p>
|
||||
* Purpose is to allow clean, efficient copy of a chunk data to be made, and
|
||||
* then handed off for processing in another thread (e.g. map rendering)
|
||||
*/
|
||||
public interface ChunkSnapshot {
|
||||
|
||||
/**
|
||||
* Gets the X-coordinate of this chunk
|
||||
*
|
||||
* @return X-coordinate
|
||||
*/
|
||||
int getX();
|
||||
|
||||
/**
|
||||
* Gets the Z-coordinate of this chunk
|
||||
*
|
||||
* @return Z-coordinate
|
||||
*/
|
||||
int getZ();
|
||||
|
||||
/**
|
||||
* Gets name of the world containing this chunk
|
||||
*
|
||||
* @return Parent World Name
|
||||
*/
|
||||
String getWorldName();
|
||||
|
||||
/**
|
||||
* Get block type for block at corresponding coordinate in the chunk
|
||||
*
|
||||
* @param x 0-15
|
||||
* @param y 0-127
|
||||
* @param z 0-15
|
||||
* @return 0-255
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
int getBlockTypeId(int x, int y, int z);
|
||||
|
||||
/**
|
||||
* Get block data for block at corresponding coordinate in the chunk
|
||||
*
|
||||
* @param x 0-15
|
||||
* @param y 0-127
|
||||
* @param z 0-15
|
||||
* @return 0-15
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
int getBlockData(int x, int y, int z);
|
||||
|
||||
/**
|
||||
* Get sky light level for block at corresponding coordinate in the chunk
|
||||
*
|
||||
* @param x 0-15
|
||||
* @param y 0-127
|
||||
* @param z 0-15
|
||||
* @return 0-15
|
||||
*/
|
||||
int getBlockSkyLight(int x, int y, int z);
|
||||
|
||||
/**
|
||||
* Get light level emitted by block at corresponding coordinate in the
|
||||
* chunk
|
||||
*
|
||||
* @param x 0-15
|
||||
* @param y 0-127
|
||||
* @param z 0-15
|
||||
* @return 0-15
|
||||
*/
|
||||
int getBlockEmittedLight(int x, int y, int z);
|
||||
|
||||
/**
|
||||
* Gets the highest non-air coordinate at the given coordinates
|
||||
*
|
||||
* @param x X-coordinate of the blocks
|
||||
* @param z Z-coordinate of the blocks
|
||||
* @return Y-coordinate of the highest non-air block
|
||||
*/
|
||||
int getHighestBlockYAt(int x, int z);
|
||||
|
||||
/**
|
||||
* Get biome at given coordinates
|
||||
*
|
||||
* @param x X-coordinate
|
||||
* @param z Z-coordinate
|
||||
* @return Biome at given coordinate
|
||||
*/
|
||||
Biome getBiome(int x, int z);
|
||||
|
||||
/**
|
||||
* Get raw biome temperature (0.0-1.0) at given coordinate
|
||||
*
|
||||
* @param x X-coordinate
|
||||
* @param z Z-coordinate
|
||||
* @return temperature at given coordinate
|
||||
*/
|
||||
double getRawBiomeTemperature(int x, int z);
|
||||
|
||||
/**
|
||||
* Get raw biome rainfall (0.0-1.0) at given coordinate
|
||||
*
|
||||
* @param x X-coordinate
|
||||
* @param z Z-coordinate
|
||||
* @return rainfall at given coordinate
|
||||
*/
|
||||
double getRawBiomeRainfall(int x, int z);
|
||||
|
||||
/**
|
||||
* Get world full time when chunk snapshot was captured
|
||||
*
|
||||
* @return time in ticks
|
||||
*/
|
||||
long getCaptureFullTime();
|
||||
|
||||
/**
|
||||
* Test if section is empty
|
||||
*
|
||||
* @param sy - section Y coordinate (block Y / 16)
|
||||
* @return true if empty, false if not
|
||||
*/
|
||||
boolean isSectionEmpty(int sy);
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import com.google.common.collect.Maps;
|
||||
|
||||
/**
|
||||
* Represents the two types of coal
|
||||
*/
|
||||
public enum CoalType {
|
||||
COAL(0x0),
|
||||
CHARCOAL(0x1);
|
||||
|
||||
private final byte data;
|
||||
private final static Map<Byte, CoalType> BY_DATA = Maps.newHashMap();
|
||||
|
||||
private CoalType(final int data) {
|
||||
this.data = (byte) data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the associated data value representing this type of coal
|
||||
*
|
||||
* @return A byte containing the data value of this coal type
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public byte getData() {
|
||||
return data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the type of coal with the given data value
|
||||
*
|
||||
* @param data Data value to fetch
|
||||
* @return The {@link CoalType} representing the given value, or null if
|
||||
* it doesn't exist
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public static CoalType getByData(final byte data) {
|
||||
return BY_DATA.get(data);
|
||||
}
|
||||
|
||||
static {
|
||||
for (CoalType type : values()) {
|
||||
BY_DATA.put(type.data, type);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,344 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.configuration.serialization.ConfigurationSerializable;
|
||||
import org.bukkit.configuration.serialization.SerializableAs;
|
||||
|
||||
import com.google.common.collect.ImmutableMap;
|
||||
|
||||
/**
|
||||
* A container for a color palette. This class is immutable; the set methods
|
||||
* return a new color. The color names listed as fields are HTML4 standards,
|
||||
* but subject to change.
|
||||
*/
|
||||
@SerializableAs("Color")
|
||||
public final class Color implements ConfigurationSerializable {
|
||||
private static final int BIT_MASK = 0xff;
|
||||
|
||||
/**
|
||||
* White, or (0xFF,0xFF,0xFF) in (R,G,B)
|
||||
*/
|
||||
public static final Color WHITE = fromRGB(0xFFFFFF);
|
||||
|
||||
/**
|
||||
* Silver, or (0xC0,0xC0,0xC0) in (R,G,B)
|
||||
*/
|
||||
public static final Color SILVER = fromRGB(0xC0C0C0);
|
||||
|
||||
/**
|
||||
* Gray, or (0x80,0x80,0x80) in (R,G,B)
|
||||
*/
|
||||
public static final Color GRAY = fromRGB(0x808080);
|
||||
|
||||
/**
|
||||
* Black, or (0x00,0x00,0x00) in (R,G,B)
|
||||
*/
|
||||
public static final Color BLACK = fromRGB(0x000000);
|
||||
|
||||
/**
|
||||
* Red, or (0xFF,0x00,0x00) in (R,G,B)
|
||||
*/
|
||||
public static final Color RED = fromRGB(0xFF0000);
|
||||
|
||||
/**
|
||||
* Maroon, or (0x80,0x00,0x00) in (R,G,B)
|
||||
*/
|
||||
public static final Color MAROON = fromRGB(0x800000);
|
||||
|
||||
/**
|
||||
* Yellow, or (0xFF,0xFF,0x00) in (R,G,B)
|
||||
*/
|
||||
public static final Color YELLOW = fromRGB(0xFFFF00);
|
||||
|
||||
/**
|
||||
* Olive, or (0x80,0x80,0x00) in (R,G,B)
|
||||
*/
|
||||
public static final Color OLIVE = fromRGB(0x808000);
|
||||
|
||||
/**
|
||||
* Lime, or (0x00,0xFF,0x00) in (R,G,B)
|
||||
*/
|
||||
public static final Color LIME = fromRGB(0x00FF00);
|
||||
|
||||
/**
|
||||
* Green, or (0x00,0x80,0x00) in (R,G,B)
|
||||
*/
|
||||
public static final Color GREEN = fromRGB(0x008000);
|
||||
|
||||
/**
|
||||
* Aqua, or (0x00,0xFF,0xFF) in (R,G,B)
|
||||
*/
|
||||
public static final Color AQUA = fromRGB(0x00FFFF);
|
||||
|
||||
/**
|
||||
* Teal, or (0x00,0x80,0x80) in (R,G,B)
|
||||
*/
|
||||
public static final Color TEAL = fromRGB(0x008080);
|
||||
|
||||
/**
|
||||
* Blue, or (0x00,0x00,0xFF) in (R,G,B)
|
||||
*/
|
||||
public static final Color BLUE = fromRGB(0x0000FF);
|
||||
|
||||
/**
|
||||
* Navy, or (0x00,0x00,0x80) in (R,G,B)
|
||||
*/
|
||||
public static final Color NAVY = fromRGB(0x000080);
|
||||
|
||||
/**
|
||||
* Fuchsia, or (0xFF,0x00,0xFF) in (R,G,B)
|
||||
*/
|
||||
public static final Color FUCHSIA = fromRGB(0xFF00FF);
|
||||
|
||||
/**
|
||||
* Purple, or (0x80,0x00,0x80) in (R,G,B)
|
||||
*/
|
||||
public static final Color PURPLE = fromRGB(0x800080);
|
||||
|
||||
/**
|
||||
* Orange, or (0xFF,0xA5,0x00) in (R,G,B)
|
||||
*/
|
||||
public static final Color ORANGE = fromRGB(0xFFA500);
|
||||
|
||||
private final byte red;
|
||||
private final byte green;
|
||||
private final byte blue;
|
||||
|
||||
/**
|
||||
* Creates a new Color object from a red, green, and blue
|
||||
*
|
||||
* @param red integer from 0-255
|
||||
* @param green integer from 0-255
|
||||
* @param blue integer from 0-255
|
||||
* @return a new Color object for the red, green, blue
|
||||
* @throws IllegalArgumentException if any value is strictly >255 or <0
|
||||
*/
|
||||
public static Color fromRGB(int red, int green, int blue) throws IllegalArgumentException {
|
||||
return new Color(red, green, blue);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new Color object from a blue, green, and red
|
||||
*
|
||||
* @param blue integer from 0-255
|
||||
* @param green integer from 0-255
|
||||
* @param red integer from 0-255
|
||||
* @return a new Color object for the red, green, blue
|
||||
* @throws IllegalArgumentException if any value is strictly >255 or <0
|
||||
*/
|
||||
public static Color fromBGR(int blue, int green, int red) throws IllegalArgumentException {
|
||||
return new Color(red, green, blue);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new color object from an integer that contains the red,
|
||||
* green, and blue bytes in the lowest order 24 bits.
|
||||
*
|
||||
* @param rgb the integer storing the red, green, and blue values
|
||||
* @return a new color object for specified values
|
||||
* @throws IllegalArgumentException if any data is in the highest order 8
|
||||
* bits
|
||||
*/
|
||||
public static Color fromRGB(int rgb) throws IllegalArgumentException {
|
||||
Validate.isTrue((rgb >> 24) == 0, "Extrenuous data in: ", rgb);
|
||||
return fromRGB(rgb >> 16 & BIT_MASK, rgb >> 8 & BIT_MASK, rgb >> 0 & BIT_MASK);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new color object from an integer that contains the blue,
|
||||
* green, and red bytes in the lowest order 24 bits.
|
||||
*
|
||||
* @param bgr the integer storing the blue, green, and red values
|
||||
* @return a new color object for specified values
|
||||
* @throws IllegalArgumentException if any data is in the highest order 8
|
||||
* bits
|
||||
*/
|
||||
public static Color fromBGR(int bgr) throws IllegalArgumentException {
|
||||
Validate.isTrue((bgr >> 24) == 0, "Extrenuous data in: ", bgr);
|
||||
return fromBGR(bgr >> 16 & BIT_MASK, bgr >> 8 & BIT_MASK, bgr >> 0 & BIT_MASK);
|
||||
}
|
||||
|
||||
private Color(int red, int green, int blue) {
|
||||
Validate.isTrue(red >= 0 && red <= BIT_MASK, "Red is not between 0-255: ", red);
|
||||
Validate.isTrue(green >= 0 && green <= BIT_MASK, "Green is not between 0-255: ", green);
|
||||
Validate.isTrue(blue >= 0 && blue <= BIT_MASK, "Blue is not between 0-255: ", blue);
|
||||
|
||||
this.red = (byte) red;
|
||||
this.green = (byte) green;
|
||||
this.blue = (byte) blue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the red component
|
||||
*
|
||||
* @return red component, from 0 to 255
|
||||
*/
|
||||
public int getRed() {
|
||||
return BIT_MASK & red;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new Color object with specified component
|
||||
*
|
||||
* @param red the red component, from 0 to 255
|
||||
* @return a new color object with the red component
|
||||
*/
|
||||
public Color setRed(int red) {
|
||||
return fromRGB(red, getGreen(), getBlue());
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the green component
|
||||
*
|
||||
* @return green component, from 0 to 255
|
||||
*/
|
||||
public int getGreen() {
|
||||
return BIT_MASK & green;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new Color object with specified component
|
||||
*
|
||||
* @param green the red component, from 0 to 255
|
||||
* @return a new color object with the red component
|
||||
*/
|
||||
public Color setGreen(int green) {
|
||||
return fromRGB(getRed(), green, getBlue());
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the blue component
|
||||
*
|
||||
* @return blue component, from 0 to 255
|
||||
*/
|
||||
public int getBlue() {
|
||||
return BIT_MASK & blue;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new Color object with specified component
|
||||
*
|
||||
* @param blue the red component, from 0 to 255
|
||||
* @return a new color object with the red component
|
||||
*/
|
||||
public Color setBlue(int blue) {
|
||||
return fromRGB(getRed(), getGreen(), blue);
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @return An integer representation of this color, as 0xRRGGBB
|
||||
*/
|
||||
public int asRGB() {
|
||||
return getRed() << 16 | getGreen() << 8 | getBlue() << 0;
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @return An integer representation of this color, as 0xBBGGRR
|
||||
*/
|
||||
public int asBGR() {
|
||||
return getBlue() << 16 | getGreen() << 8 | getRed() << 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new color with its RGB components changed as if it was dyed
|
||||
* with the colors passed in, replicating vanilla workbench dyeing
|
||||
*
|
||||
* @param colors The DyeColors to dye with
|
||||
* @return A new color with the changed rgb components
|
||||
*/
|
||||
// TODO: Javadoc what this method does, not what it mimics. API != Implementation
|
||||
public Color mixDyes(DyeColor... colors) {
|
||||
Validate.noNullElements(colors, "Colors cannot be null");
|
||||
|
||||
Color[] toPass = new Color[colors.length];
|
||||
for (int i = 0; i < colors.length; i++) {
|
||||
toPass[i] = colors[i].getColor();
|
||||
}
|
||||
|
||||
return mixColors(toPass);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new color with its RGB components changed as if it was dyed
|
||||
* with the colors passed in, replicating vanilla workbench dyeing
|
||||
*
|
||||
* @param colors The colors to dye with
|
||||
* @return A new color with the changed rgb components
|
||||
*/
|
||||
// TODO: Javadoc what this method does, not what it mimics. API != Implementation
|
||||
public Color mixColors(Color... colors) {
|
||||
Validate.noNullElements(colors, "Colors cannot be null");
|
||||
|
||||
int totalRed = this.getRed();
|
||||
int totalGreen = this.getGreen();
|
||||
int totalBlue = this.getBlue();
|
||||
int totalMax = Math.max(Math.max(totalRed, totalGreen), totalBlue);
|
||||
for (Color color : colors) {
|
||||
totalRed += color.getRed();
|
||||
totalGreen += color.getGreen();
|
||||
totalBlue += color.getBlue();
|
||||
totalMax += Math.max(Math.max(color.getRed(), color.getGreen()), color.getBlue());
|
||||
}
|
||||
|
||||
float averageRed = totalRed / (colors.length + 1);
|
||||
float averageGreen = totalGreen / (colors.length + 1);
|
||||
float averageBlue = totalBlue / (colors.length + 1);
|
||||
float averageMax = totalMax / (colors.length + 1);
|
||||
|
||||
float maximumOfAverages = Math.max(Math.max(averageRed, averageGreen), averageBlue);
|
||||
float gainFactor = averageMax / maximumOfAverages;
|
||||
|
||||
return Color.fromRGB((int) (averageRed * gainFactor), (int) (averageGreen * gainFactor), (int) (averageBlue * gainFactor));
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object o) {
|
||||
if (!(o instanceof Color)) {
|
||||
return false;
|
||||
}
|
||||
final Color that = (Color) o;
|
||||
return this.blue == that.blue && this.green == that.green && this.red == that.red;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return asRGB() ^ Color.class.hashCode();
|
||||
}
|
||||
|
||||
public Map<String, Object> serialize() {
|
||||
return ImmutableMap.<String, Object>of(
|
||||
"RED", getRed(),
|
||||
"BLUE", getBlue(),
|
||||
"GREEN", getGreen()
|
||||
);
|
||||
}
|
||||
|
||||
@SuppressWarnings("javadoc")
|
||||
public static Color deserialize(Map<String, Object> map) {
|
||||
return fromRGB(
|
||||
asInt("RED", map),
|
||||
asInt("GREEN", map),
|
||||
asInt("BLUE", map)
|
||||
);
|
||||
}
|
||||
|
||||
private static int asInt(String string, Map<String, Object> map) {
|
||||
Object value = map.get(string);
|
||||
if (value == null) {
|
||||
throw new IllegalArgumentException(string + " not in map " + map);
|
||||
}
|
||||
if (!(value instanceof Number)) {
|
||||
throw new IllegalArgumentException(string + '(' + value + ") is not a number");
|
||||
}
|
||||
return ((Number) value).intValue();
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "Color:[rgb0x" + Integer.toHexString(getRed()).toUpperCase() + Integer.toHexString(getGreen()).toUpperCase() + Integer.toHexString(getBlue()).toUpperCase() + "]";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import com.google.common.collect.Maps;
|
||||
|
||||
/**
|
||||
* Represents the different growth states of crops
|
||||
*/
|
||||
public enum CropState {
|
||||
|
||||
/**
|
||||
* State when first seeded
|
||||
*/
|
||||
SEEDED(0x0),
|
||||
/**
|
||||
* First growth stage
|
||||
*/
|
||||
GERMINATED(0x1),
|
||||
/**
|
||||
* Second growth stage
|
||||
*/
|
||||
VERY_SMALL(0x2),
|
||||
/**
|
||||
* Third growth stage
|
||||
*/
|
||||
SMALL(0x3),
|
||||
/**
|
||||
* Fourth growth stage
|
||||
*/
|
||||
MEDIUM(0x4),
|
||||
/**
|
||||
* Fifth growth stage
|
||||
*/
|
||||
TALL(0x5),
|
||||
/**
|
||||
* Almost ripe stage
|
||||
*/
|
||||
VERY_TALL(0x6),
|
||||
/**
|
||||
* Ripe stage
|
||||
*/
|
||||
RIPE(0x7);
|
||||
|
||||
private final byte data;
|
||||
private final static Map<Byte, CropState> BY_DATA = Maps.newHashMap();
|
||||
|
||||
private CropState(final int data) {
|
||||
this.data = (byte) data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the associated data value representing this growth state
|
||||
*
|
||||
* @return A byte containing the data value of this growth state
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public byte getData() {
|
||||
return data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the CropState with the given data value
|
||||
*
|
||||
* @param data Data value to fetch
|
||||
* @return The {@link CropState} representing the given value, or null if
|
||||
* it doesn't exist
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public static CropState getByData(final byte data) {
|
||||
return BY_DATA.get(data);
|
||||
}
|
||||
|
||||
static {
|
||||
for (CropState cropState : values()) {
|
||||
BY_DATA.put(cropState.getData(), cropState);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import com.google.common.collect.Maps;
|
||||
|
||||
/**
|
||||
* Represents the various difficulty levels that are available.
|
||||
*/
|
||||
public enum Difficulty {
|
||||
/**
|
||||
* Players regain health over time, hostile mobs don't spawn, the hunger
|
||||
* bar does not deplete.
|
||||
*/
|
||||
PEACEFUL(0),
|
||||
|
||||
/**
|
||||
* Hostile mobs spawn, enemies deal less damage than on normal difficulty,
|
||||
* the hunger bar does deplete and starving deals up to 5 hearts of
|
||||
* damage. (Default value)
|
||||
*/
|
||||
EASY(1),
|
||||
|
||||
/**
|
||||
* Hostile mobs spawn, enemies deal normal amounts of damage, the hunger
|
||||
* bar does deplete and starving deals up to 9.5 hearts of damage.
|
||||
*/
|
||||
NORMAL(2),
|
||||
|
||||
/**
|
||||
* Hostile mobs spawn, enemies deal greater damage than on normal
|
||||
* difficulty, the hunger bar does deplete and starving can kill players.
|
||||
*/
|
||||
HARD(3);
|
||||
|
||||
private final int value;
|
||||
private final static Map<Integer, Difficulty> BY_ID = Maps.newHashMap();
|
||||
|
||||
private Difficulty(final int value) {
|
||||
this.value = value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the difficulty value associated with this Difficulty.
|
||||
*
|
||||
* @return An integer value of this difficulty
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public int getValue() {
|
||||
return value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the Difficulty represented by the specified value
|
||||
*
|
||||
* @param value Value to check
|
||||
* @return Associative {@link Difficulty} with the given value, or null if
|
||||
* it doesn't exist
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public static Difficulty getByValue(final int value) {
|
||||
return BY_ID.get(value);
|
||||
}
|
||||
|
||||
static {
|
||||
for (Difficulty diff : values()) {
|
||||
BY_ID.put(diff.value, diff);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,239 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import com.google.common.collect.ImmutableMap;
|
||||
|
||||
/**
|
||||
* All supported color values for dyes and cloth
|
||||
*/
|
||||
public enum DyeColor {
|
||||
|
||||
/**
|
||||
* Represents white dye.
|
||||
*/
|
||||
WHITE(0x0, 0xF, Color.WHITE, Color.fromRGB(0xF0F0F0)),
|
||||
/**
|
||||
* Represents orange dye.
|
||||
*/
|
||||
ORANGE(0x1, 0xE, Color.fromRGB(0xD87F33), Color.fromRGB(0xEB8844)),
|
||||
/**
|
||||
* Represents magenta dye.
|
||||
*/
|
||||
MAGENTA(0x2, 0xD, Color.fromRGB(0xB24CD8), Color.fromRGB(0xC354CD)),
|
||||
/**
|
||||
* Represents light blue dye.
|
||||
*/
|
||||
LIGHT_BLUE(0x3, 0xC, Color.fromRGB(0x6699D8), Color.fromRGB(0x6689D3)),
|
||||
/**
|
||||
* Represents yellow dye.
|
||||
*/
|
||||
YELLOW(0x4, 0xB, Color.fromRGB(0xE5E533), Color.fromRGB(0xDECF2A)),
|
||||
/**
|
||||
* Represents lime dye.
|
||||
*/
|
||||
LIME(0x5, 0xA, Color.fromRGB(0x7FCC19), Color.fromRGB(0x41CD34)),
|
||||
/**
|
||||
* Represents pink dye.
|
||||
*/
|
||||
PINK(0x6, 0x9, Color.fromRGB(0xF27FA5), Color.fromRGB(0xD88198)),
|
||||
/**
|
||||
* Represents gray dye.
|
||||
*/
|
||||
GRAY(0x7, 0x8, Color.fromRGB(0x4C4C4C), Color.fromRGB(0x434343)),
|
||||
/**
|
||||
* Represents silver dye.
|
||||
*/
|
||||
SILVER(0x8, 0x7, Color.fromRGB(0x999999), Color.fromRGB(0xABABAB)),
|
||||
/**
|
||||
* Represents cyan dye.
|
||||
*/
|
||||
CYAN(0x9, 0x6, Color.fromRGB(0x4C7F99), Color.fromRGB(0x287697)),
|
||||
/**
|
||||
* Represents purple dye.
|
||||
*/
|
||||
PURPLE(0xA, 0x5, Color.fromRGB(0x7F3FB2), Color.fromRGB(0x7B2FBE)),
|
||||
/**
|
||||
* Represents blue dye.
|
||||
*/
|
||||
BLUE(0xB, 0x4, Color.fromRGB(0x334CB2), Color.fromRGB(0x253192)),
|
||||
/**
|
||||
* Represents brown dye.
|
||||
*/
|
||||
BROWN(0xC, 0x3, Color.fromRGB(0x664C33), Color.fromRGB(0x51301A)),
|
||||
/**
|
||||
* Represents green dye.
|
||||
*/
|
||||
GREEN(0xD, 0x2, Color.fromRGB(0x667F33), Color.fromRGB(0x3B511A)),
|
||||
/**
|
||||
* Represents red dye.
|
||||
*/
|
||||
RED(0xE, 0x1, Color.fromRGB(0x993333), Color.fromRGB(0xB3312C)),
|
||||
/**
|
||||
* Represents black dye.
|
||||
*/
|
||||
BLACK(0xF, 0x0, Color.fromRGB(0x191919), Color.fromRGB(0x1E1B1B));
|
||||
|
||||
private final byte woolData;
|
||||
private final byte dyeData;
|
||||
private final Color color;
|
||||
private final Color firework;
|
||||
private final static DyeColor[] BY_WOOL_DATA;
|
||||
private final static DyeColor[] BY_DYE_DATA;
|
||||
private final static Map<Color, DyeColor> BY_COLOR;
|
||||
private final static Map<Color, DyeColor> BY_FIREWORK;
|
||||
|
||||
private DyeColor(final int woolData, final int dyeData, Color color, Color firework) {
|
||||
this.woolData = (byte) woolData;
|
||||
this.dyeData = (byte) dyeData;
|
||||
this.color = color;
|
||||
this.firework = firework;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the associated (wool) data value representing this color.
|
||||
*
|
||||
* @return A byte containing the (wool) data value of this color
|
||||
* @deprecated The name is misleading. It would imply {@link
|
||||
* Material#INK_SACK} but uses {@link Material#WOOL}
|
||||
* @see #getWoolData()
|
||||
* @see #getDyeData()
|
||||
*/
|
||||
@Deprecated
|
||||
public byte getData() {
|
||||
return getWoolData();
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the associated wool data value representing this color.
|
||||
*
|
||||
* @return A byte containing the wool data value of this color
|
||||
* @see #getDyeData()
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public byte getWoolData() {
|
||||
return woolData;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the associated dye data value representing this color.
|
||||
*
|
||||
* @return A byte containing the dye data value of this color
|
||||
* @see #getWoolData()
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public byte getDyeData() {
|
||||
return dyeData;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the color that this dye represents.
|
||||
*
|
||||
* @return The {@link Color} that this dye represents
|
||||
*/
|
||||
public Color getColor() {
|
||||
return color;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the firework color that this dye represents.
|
||||
*
|
||||
* @return The {@link Color} that this dye represents
|
||||
*/
|
||||
public Color getFireworkColor() {
|
||||
return firework;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the DyeColor with the given (wool) data value.
|
||||
*
|
||||
* @param data (wool) data value to fetch
|
||||
* @return The {@link DyeColor} representing the given value, or null if
|
||||
* it doesn't exist
|
||||
* @deprecated The name is misleading. It would imply {@link
|
||||
* Material#INK_SACK} but uses {@link Material#WOOL}
|
||||
* @see #getByDyeData(byte)
|
||||
* @see #getByWoolData(byte)
|
||||
*/
|
||||
@Deprecated
|
||||
public static DyeColor getByData(final byte data) {
|
||||
return getByWoolData(data);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the DyeColor with the given wool data value.
|
||||
*
|
||||
* @param data Wool data value to fetch
|
||||
* @return The {@link DyeColor} representing the given value, or null if
|
||||
* it doesn't exist
|
||||
* @see #getByDyeData(byte)
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public static DyeColor getByWoolData(final byte data) {
|
||||
int i = 0xff & data;
|
||||
if (i >= BY_WOOL_DATA.length) {
|
||||
return null;
|
||||
}
|
||||
return BY_WOOL_DATA[i];
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the DyeColor with the given dye data value.
|
||||
*
|
||||
* @param data Dye data value to fetch
|
||||
* @return The {@link DyeColor} representing the given value, or null if
|
||||
* it doesn't exist
|
||||
* @see #getByWoolData(byte)
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public static DyeColor getByDyeData(final byte data) {
|
||||
int i = 0xff & data;
|
||||
if (i >= BY_DYE_DATA.length) {
|
||||
return null;
|
||||
}
|
||||
return BY_DYE_DATA[i];
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the DyeColor with the given color value.
|
||||
*
|
||||
* @param color Color value to get the dye by
|
||||
* @return The {@link DyeColor} representing the given value, or null if
|
||||
* it doesn't exist
|
||||
*/
|
||||
public static DyeColor getByColor(final Color color) {
|
||||
return BY_COLOR.get(color);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the DyeColor with the given firework color value.
|
||||
*
|
||||
* @param color Color value to get dye by
|
||||
* @return The {@link DyeColor} representing the given value, or null if
|
||||
* it doesn't exist
|
||||
*/
|
||||
public static DyeColor getByFireworkColor(final Color color) {
|
||||
return BY_FIREWORK.get(color);
|
||||
}
|
||||
|
||||
static {
|
||||
BY_WOOL_DATA = values();
|
||||
BY_DYE_DATA = values();
|
||||
ImmutableMap.Builder<Color, DyeColor> byColor = ImmutableMap.builder();
|
||||
ImmutableMap.Builder<Color, DyeColor> byFirework = ImmutableMap.builder();
|
||||
|
||||
for (DyeColor color : values()) {
|
||||
BY_WOOL_DATA[color.woolData & 0xff] = color;
|
||||
BY_DYE_DATA[color.dyeData & 0xff] = color;
|
||||
byColor.put(color.getColor(), color);
|
||||
byFirework.put(color.getFireworkColor(), color);
|
||||
}
|
||||
|
||||
BY_COLOR = byColor.build();
|
||||
BY_FIREWORK = byFirework.build();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,147 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import com.google.common.collect.Maps;
|
||||
|
||||
import org.bukkit.block.BlockFace;
|
||||
import org.bukkit.potion.Potion;
|
||||
|
||||
/**
|
||||
* A list of effects that the server is able to send to players.
|
||||
*/
|
||||
public enum Effect {
|
||||
/**
|
||||
* An alternate click sound.
|
||||
*/
|
||||
CLICK2(1000, Type.SOUND),
|
||||
/**
|
||||
* A click sound.
|
||||
*/
|
||||
CLICK1(1001, Type.SOUND),
|
||||
/**
|
||||
* Sound of a bow firing.
|
||||
*/
|
||||
BOW_FIRE(1002, Type.SOUND),
|
||||
/**
|
||||
* Sound of a door opening/closing.
|
||||
*/
|
||||
DOOR_TOGGLE(1003, Type.SOUND),
|
||||
/**
|
||||
* Sound of fire being extinguished.
|
||||
*/
|
||||
EXTINGUISH(1004, Type.SOUND),
|
||||
/**
|
||||
* A song from a record. Needs the record item ID as additional info
|
||||
*/
|
||||
RECORD_PLAY(1005, Type.SOUND, Material.class),
|
||||
/**
|
||||
* Sound of ghast shrieking.
|
||||
*/
|
||||
GHAST_SHRIEK(1007, Type.SOUND),
|
||||
/**
|
||||
* Sound of ghast firing.
|
||||
*/
|
||||
GHAST_SHOOT(1008, Type.SOUND),
|
||||
/**
|
||||
* Sound of blaze firing.
|
||||
*/
|
||||
BLAZE_SHOOT(1009, Type.SOUND),
|
||||
/**
|
||||
* Sound of zombies chewing on wooden doors.
|
||||
*/
|
||||
ZOMBIE_CHEW_WOODEN_DOOR(1010, Type.SOUND),
|
||||
/**
|
||||
* Sound of zombies chewing on iron doors.
|
||||
*/
|
||||
ZOMBIE_CHEW_IRON_DOOR(1011, Type.SOUND),
|
||||
/**
|
||||
* Sound of zombies destroying a door.
|
||||
*/
|
||||
ZOMBIE_DESTROY_DOOR(1012, Type.SOUND),
|
||||
/**
|
||||
* A visual smoke effect. Needs direction as additional info.
|
||||
*/
|
||||
SMOKE(2000, Type.VISUAL, BlockFace.class),
|
||||
/**
|
||||
* Sound of a block breaking. Needs block ID as additional info.
|
||||
*/
|
||||
STEP_SOUND(2001, Type.SOUND, Material.class),
|
||||
/**
|
||||
* Visual effect of a splash potion breaking. Needs potion data value as
|
||||
* additional info.
|
||||
*/
|
||||
POTION_BREAK(2002, Type.VISUAL, Potion.class),
|
||||
/**
|
||||
* An ender eye signal; a visual effect.
|
||||
*/
|
||||
ENDER_SIGNAL(2003, Type.VISUAL),
|
||||
/**
|
||||
* The flames seen on a mobspawner; a visual effect.
|
||||
*/
|
||||
MOBSPAWNER_FLAMES(2004, Type.VISUAL);
|
||||
|
||||
private final int id;
|
||||
private final Type type;
|
||||
private final Class<?> data;
|
||||
private static final Map<Integer, Effect> BY_ID = Maps.newHashMap();
|
||||
|
||||
Effect(int id, Type type) {
|
||||
this(id,type,null);
|
||||
}
|
||||
|
||||
Effect(int id, Type type, Class<?> data) {
|
||||
this.id = id;
|
||||
this.type = type;
|
||||
this.data = data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the ID for this effect.
|
||||
*
|
||||
* @return ID of this effect
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public int getId() {
|
||||
return this.id;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return The type of the effect.
|
||||
*/
|
||||
public Type getType() {
|
||||
return this.type;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return The class which represents data for this effect, or null if
|
||||
* none
|
||||
*/
|
||||
public Class<?> getData() {
|
||||
return this.data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the Effect associated with the given ID.
|
||||
*
|
||||
* @param id ID of the Effect to return
|
||||
* @return Effect with the given ID
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public static Effect getById(int id) {
|
||||
return BY_ID.get(id);
|
||||
}
|
||||
|
||||
static {
|
||||
for (Effect effect : values()) {
|
||||
BY_ID.put(effect.id, effect);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Represents the type of an effect.
|
||||
*/
|
||||
public enum Type {SOUND, VISUAL}
|
||||
}
|
||||
@@ -0,0 +1,136 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import com.google.common.collect.Maps;
|
||||
|
||||
/**
|
||||
* A list of all Effects that can happen to entities.
|
||||
*/
|
||||
public enum EntityEffect {
|
||||
|
||||
/**
|
||||
* When mobs get hurt.
|
||||
*/
|
||||
HURT(2),
|
||||
|
||||
/**
|
||||
* When a mob dies.
|
||||
* <p>
|
||||
* <b>This will cause client-glitches!
|
||||
*/
|
||||
DEATH(3),
|
||||
|
||||
/**
|
||||
* The smoke when taming a wolf fails.
|
||||
* <p>
|
||||
* Without client-mods this will be ignored if the entity is not a wolf.
|
||||
*/
|
||||
WOLF_SMOKE(6),
|
||||
|
||||
/**
|
||||
* The hearts when taming a wolf succeeds.
|
||||
* <p>
|
||||
* Without client-mods this will be ignored if the entity is not a wolf.
|
||||
*/
|
||||
WOLF_HEARTS(7),
|
||||
|
||||
/**
|
||||
* When a wolf shakes (after being wet).
|
||||
* <p>
|
||||
* Without client-mods this will be ignored if the entity is not a wolf.
|
||||
*/
|
||||
WOLF_SHAKE(8),
|
||||
|
||||
/**
|
||||
* When a sheep eats a LONG_GRASS block.
|
||||
*/
|
||||
SHEEP_EAT(10),
|
||||
|
||||
/**
|
||||
* When an Iron Golem gives a rose.
|
||||
* <p>
|
||||
* This will not play an effect if the entity is not an iron golem.
|
||||
*/
|
||||
IRON_GOLEM_ROSE(11),
|
||||
|
||||
/**
|
||||
* Hearts from a villager.
|
||||
* <p>
|
||||
* This will not play an effect if the entity is not a villager.
|
||||
*/
|
||||
VILLAGER_HEART(12),
|
||||
|
||||
/**
|
||||
* When a villager is angry.
|
||||
* <p>
|
||||
* This will not play an effect if the entity is not a villager.
|
||||
*/
|
||||
VILLAGER_ANGRY(13),
|
||||
|
||||
/**
|
||||
* Happy particles from a villager.
|
||||
* <p>
|
||||
* This will not play an effect if the entity is not a villager.
|
||||
*/
|
||||
VILLAGER_HAPPY(14),
|
||||
|
||||
/**
|
||||
* Magic particles from a witch.
|
||||
* <p>
|
||||
* This will not play an effect if the entity is not a witch.
|
||||
*/
|
||||
WITCH_MAGIC(15),
|
||||
|
||||
/**
|
||||
* When a zombie transforms into a villager by shaking violently.
|
||||
* <p>
|
||||
* This will not play an effect if the entity is not a zombie.
|
||||
*/
|
||||
ZOMBIE_TRANSFORM(16),
|
||||
|
||||
/**
|
||||
* When a firework explodes.
|
||||
* <p>
|
||||
* This will not play an effect if the entity is not a firework.
|
||||
*/
|
||||
FIREWORK_EXPLODE(17);
|
||||
|
||||
private final byte data;
|
||||
private final static Map<Byte, EntityEffect> BY_DATA = Maps.newHashMap();
|
||||
|
||||
EntityEffect(final int data) {
|
||||
this.data = (byte) data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the data value of this EntityEffect
|
||||
*
|
||||
* @return The data value
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public byte getData() {
|
||||
return data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the EntityEffect with the given data value
|
||||
*
|
||||
* @param data Data value to fetch
|
||||
* @return The {@link EntityEffect} representing the given value, or null
|
||||
* if it doesn't exist
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public static EntityEffect getByData(final byte data) {
|
||||
return BY_DATA.get(data);
|
||||
}
|
||||
|
||||
|
||||
static {
|
||||
for (EntityEffect entityEffect : values()) {
|
||||
BY_DATA.put(entityEffect.data, entityEffect);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,421 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.configuration.serialization.ConfigurationSerializable;
|
||||
import org.bukkit.configuration.serialization.SerializableAs;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import com.google.common.collect.ImmutableMap;
|
||||
|
||||
/**
|
||||
* Represents a single firework effect.
|
||||
*/
|
||||
@SerializableAs("Firework")
|
||||
public final class FireworkEffect implements ConfigurationSerializable {
|
||||
|
||||
/**
|
||||
* The type or shape of the effect.
|
||||
*/
|
||||
public enum Type {
|
||||
/**
|
||||
* A small ball effect.
|
||||
*/
|
||||
BALL,
|
||||
/**
|
||||
* A large ball effect.
|
||||
*/
|
||||
BALL_LARGE,
|
||||
/**
|
||||
* A star-shaped effect.
|
||||
*/
|
||||
STAR,
|
||||
/**
|
||||
* A burst effect.
|
||||
*/
|
||||
BURST,
|
||||
/**
|
||||
* A creeper-face effect.
|
||||
*/
|
||||
CREEPER,
|
||||
;
|
||||
}
|
||||
|
||||
/**
|
||||
* Construct a firework effect.
|
||||
*
|
||||
* @return A utility object for building a firework effect
|
||||
*/
|
||||
public static Builder builder() {
|
||||
return new Builder();
|
||||
}
|
||||
|
||||
/**
|
||||
* This is a builder for FireworkEffects.
|
||||
*
|
||||
* @see FireworkEffect#builder()
|
||||
*/
|
||||
public static final class Builder {
|
||||
boolean flicker = false;
|
||||
boolean trail = false;
|
||||
final ImmutableList.Builder<Color> colors = ImmutableList.builder();
|
||||
ImmutableList.Builder<Color> fadeColors = null;
|
||||
Type type = Type.BALL;
|
||||
|
||||
Builder() {}
|
||||
|
||||
/**
|
||||
* Specify the type of the firework effect.
|
||||
*
|
||||
* @param type The effect type
|
||||
* @return This object, for chaining
|
||||
* @throws IllegalArgumentException If type is null
|
||||
*/
|
||||
public Builder with(Type type) throws IllegalArgumentException {
|
||||
Validate.notNull(type, "Cannot have null type");
|
||||
this.type = type;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a flicker to the firework effect.
|
||||
*
|
||||
* @return This object, for chaining
|
||||
*/
|
||||
public Builder withFlicker() {
|
||||
flicker = true;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set whether the firework effect should flicker.
|
||||
*
|
||||
* @param flicker true if it should flicker, false if not
|
||||
* @return This object, for chaining
|
||||
*/
|
||||
public Builder flicker(boolean flicker) {
|
||||
this.flicker = flicker;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a trail to the firework effect.
|
||||
*
|
||||
* @return This object, for chaining
|
||||
*/
|
||||
public Builder withTrail() {
|
||||
trail = true;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set whether the firework effect should have a trail.
|
||||
*
|
||||
* @param trail true if it should have a trail, false for no trail
|
||||
* @return This object, for chaining
|
||||
*/
|
||||
public Builder trail(boolean trail) {
|
||||
this.trail = trail;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a primary color to the firework effect.
|
||||
*
|
||||
* @param color The color to add
|
||||
* @return This object, for chaining
|
||||
* @throws IllegalArgumentException If color is null
|
||||
*/
|
||||
public Builder withColor(Color color) throws IllegalArgumentException {
|
||||
Validate.notNull(color, "Cannot have null color");
|
||||
|
||||
colors.add(color);
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add several primary colors to the firework effect.
|
||||
*
|
||||
* @param colors The colors to add
|
||||
* @return This object, for chaining
|
||||
* @throws IllegalArgumentException If colors is null
|
||||
* @throws IllegalArgumentException If any color is null (may be
|
||||
* thrown after changes have occurred)
|
||||
*/
|
||||
public Builder withColor(Color...colors) throws IllegalArgumentException {
|
||||
Validate.notNull(colors, "Cannot have null colors");
|
||||
if (colors.length == 0) {
|
||||
return this;
|
||||
}
|
||||
|
||||
ImmutableList.Builder<Color> list = this.colors;
|
||||
for (Color color : colors) {
|
||||
Validate.notNull(color, "Color cannot be null");
|
||||
list.add(color);
|
||||
}
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add several primary colors to the firework effect.
|
||||
*
|
||||
* @param colors An iterable object whose iterator yields the desired
|
||||
* colors
|
||||
* @return This object, for chaining
|
||||
* @throws IllegalArgumentException If colors is null
|
||||
* @throws IllegalArgumentException If any color is null (may be
|
||||
* thrown after changes have occurred)
|
||||
*/
|
||||
public Builder withColor(Iterable<?> colors) throws IllegalArgumentException {
|
||||
Validate.notNull(colors, "Cannot have null colors");
|
||||
|
||||
ImmutableList.Builder<Color> list = this.colors;
|
||||
for (Object color : colors) {
|
||||
if (!(color instanceof Color)) {
|
||||
throw new IllegalArgumentException(color + " is not a Color in " + colors);
|
||||
}
|
||||
list.add((Color) color);
|
||||
}
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add a fade color to the firework effect.
|
||||
*
|
||||
* @param color The color to add
|
||||
* @return This object, for chaining
|
||||
* @throws IllegalArgumentException If colors is null
|
||||
* @throws IllegalArgumentException If any color is null (may be
|
||||
* thrown after changes have occurred)
|
||||
*/
|
||||
public Builder withFade(Color color) throws IllegalArgumentException {
|
||||
Validate.notNull(color, "Cannot have null color");
|
||||
|
||||
if (fadeColors == null) {
|
||||
fadeColors = ImmutableList.builder();
|
||||
}
|
||||
|
||||
fadeColors.add(color);
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add several fade colors to the firework effect.
|
||||
*
|
||||
* @param colors The colors to add
|
||||
* @return This object, for chaining
|
||||
* @throws IllegalArgumentException If colors is null
|
||||
* @throws IllegalArgumentException If any color is null (may be
|
||||
* thrown after changes have occurred)
|
||||
*/
|
||||
public Builder withFade(Color...colors) throws IllegalArgumentException {
|
||||
Validate.notNull(colors, "Cannot have null colors");
|
||||
if (colors.length == 0) {
|
||||
return this;
|
||||
}
|
||||
|
||||
ImmutableList.Builder<Color> list = this.fadeColors;
|
||||
if (list == null) {
|
||||
list = this.fadeColors = ImmutableList.builder();
|
||||
}
|
||||
|
||||
for (Color color : colors) {
|
||||
Validate.notNull(color, "Color cannot be null");
|
||||
list.add(color);
|
||||
}
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Add several fade colors to the firework effect.
|
||||
*
|
||||
* @param colors An iterable object whose iterator yields the desired
|
||||
* colors
|
||||
* @return This object, for chaining
|
||||
* @throws IllegalArgumentException If colors is null
|
||||
* @throws IllegalArgumentException If any color is null (may be
|
||||
* thrown after changes have occurred)
|
||||
*/
|
||||
public Builder withFade(Iterable<?> colors) throws IllegalArgumentException {
|
||||
Validate.notNull(colors, "Cannot have null colors");
|
||||
|
||||
ImmutableList.Builder<Color> list = this.fadeColors;
|
||||
if (list == null) {
|
||||
list = this.fadeColors = ImmutableList.builder();
|
||||
}
|
||||
|
||||
for (Object color : colors) {
|
||||
if (!(color instanceof Color)) {
|
||||
throw new IllegalArgumentException(color + " is not a Color in " + colors);
|
||||
}
|
||||
list.add((Color) color);
|
||||
}
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a {@link FireworkEffect} from the current contents of this
|
||||
* builder.
|
||||
* <p>
|
||||
* To successfully build, you must have specified at least one color.
|
||||
*
|
||||
* @return The representative firework effect
|
||||
*/
|
||||
public FireworkEffect build() {
|
||||
return new FireworkEffect(
|
||||
flicker,
|
||||
trail,
|
||||
colors.build(),
|
||||
fadeColors == null ? ImmutableList.<Color>of() : fadeColors.build(),
|
||||
type
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
private static final String FLICKER = "flicker";
|
||||
private static final String TRAIL = "trail";
|
||||
private static final String COLORS = "colors";
|
||||
private static final String FADE_COLORS = "fade-colors";
|
||||
private static final String TYPE = "type";
|
||||
|
||||
private final boolean flicker;
|
||||
private final boolean trail;
|
||||
private final ImmutableList<Color> colors;
|
||||
private final ImmutableList<Color> fadeColors;
|
||||
private final Type type;
|
||||
private String string = null;
|
||||
|
||||
FireworkEffect(boolean flicker, boolean trail, ImmutableList<Color> colors, ImmutableList<Color> fadeColors, Type type) {
|
||||
if (colors.isEmpty()) {
|
||||
throw new IllegalStateException("Cannot make FireworkEffect without any color");
|
||||
}
|
||||
this.flicker = flicker;
|
||||
this.trail = trail;
|
||||
this.colors = colors;
|
||||
this.fadeColors = fadeColors;
|
||||
this.type = type;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get whether the firework effect flickers.
|
||||
*
|
||||
* @return true if it flickers, false if not
|
||||
*/
|
||||
public boolean hasFlicker() {
|
||||
return flicker;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get whether the firework effect has a trail.
|
||||
*
|
||||
* @return true if it has a trail, false if not
|
||||
*/
|
||||
public boolean hasTrail() {
|
||||
return trail;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the primary colors of the firework effect.
|
||||
*
|
||||
* @return An immutable list of the primary colors
|
||||
*/
|
||||
public List<Color> getColors() {
|
||||
return colors;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the fade colors of the firework effect.
|
||||
*
|
||||
* @return An immutable list of the fade colors
|
||||
*/
|
||||
public List<Color> getFadeColors() {
|
||||
return fadeColors;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the type of the firework effect.
|
||||
*
|
||||
* @return The effect type
|
||||
*/
|
||||
public Type getType() {
|
||||
return type;
|
||||
}
|
||||
|
||||
/**
|
||||
* @see ConfigurationSerializable
|
||||
*/
|
||||
public static ConfigurationSerializable deserialize(Map<String, Object> map) {
|
||||
Type type = Type.valueOf((String) map.get(TYPE));
|
||||
if (type == null) {
|
||||
throw new IllegalArgumentException(map.get(TYPE) + " is not a valid Type");
|
||||
}
|
||||
|
||||
return builder()
|
||||
.flicker((Boolean) map.get(FLICKER))
|
||||
.trail((Boolean) map.get(TRAIL))
|
||||
.withColor((Iterable<?>) map.get(COLORS))
|
||||
.withFade((Iterable<?>) map.get(FADE_COLORS))
|
||||
.with(type)
|
||||
.build();
|
||||
}
|
||||
|
||||
public Map<String, Object> serialize() {
|
||||
return ImmutableMap.<String, Object>of(
|
||||
FLICKER, flicker,
|
||||
TRAIL, trail,
|
||||
COLORS, colors,
|
||||
FADE_COLORS, fadeColors,
|
||||
TYPE, type.name()
|
||||
);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
final String string = this.string;
|
||||
if (string == null) {
|
||||
return this.string = "FireworkEffect:" + serialize();
|
||||
}
|
||||
return string;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
/**
|
||||
* TRUE and FALSE as per boolean.hashCode()
|
||||
*/
|
||||
final int PRIME = 31, TRUE = 1231, FALSE = 1237;
|
||||
int hash = 1;
|
||||
hash = hash * PRIME + (flicker ? TRUE : FALSE);
|
||||
hash = hash * PRIME + (trail ? TRUE : FALSE);
|
||||
hash = hash * PRIME + type.hashCode();
|
||||
hash = hash * PRIME + colors.hashCode();
|
||||
hash = hash * PRIME + fadeColors.hashCode();
|
||||
return hash;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
if (this == obj) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (!(obj instanceof FireworkEffect)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
FireworkEffect that = (FireworkEffect) obj;
|
||||
return this.flicker == that.flicker
|
||||
&& this.trail == that.trail
|
||||
&& this.type == that.type
|
||||
&& this.colors.equals(that.colors)
|
||||
&& this.fadeColors.equals(that.fadeColors);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import org.bukkit.entity.HumanEntity;
|
||||
|
||||
import com.google.common.collect.Maps;
|
||||
|
||||
/**
|
||||
* Represents the various type of game modes that {@link HumanEntity}s may
|
||||
* have
|
||||
*/
|
||||
public enum GameMode {
|
||||
/**
|
||||
* Creative mode may fly, build instantly, become invulnerable and create
|
||||
* free items.
|
||||
*/
|
||||
CREATIVE(1),
|
||||
|
||||
/**
|
||||
* Survival mode is the "normal" gameplay type, with no special features.
|
||||
*/
|
||||
SURVIVAL(0),
|
||||
|
||||
/**
|
||||
* Adventure mode cannot break blocks, use chat, use buckets, etc.
|
||||
*/
|
||||
ADVENTURE(2);
|
||||
|
||||
private final int value;
|
||||
private final static Map<Integer, GameMode> BY_ID = Maps.newHashMap();
|
||||
|
||||
private GameMode(final int value) {
|
||||
this.value = value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the mode value associated with this GameMode
|
||||
*
|
||||
* @return An integer value of this gamemode
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public int getValue() {
|
||||
return value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the GameMode represented by the specified value
|
||||
*
|
||||
* @param value Value to check
|
||||
* @return Associative {@link GameMode} with the given value, or null if
|
||||
* it doesn't exist
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public static GameMode getByValue(final int value) {
|
||||
return BY_ID.get(value);
|
||||
}
|
||||
|
||||
static {
|
||||
for (GameMode mode : values()) {
|
||||
BY_ID.put(mode.getValue(), mode);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import com.google.common.collect.Maps;
|
||||
|
||||
/**
|
||||
* Represents the different types of grass.
|
||||
*/
|
||||
public enum GrassSpecies {
|
||||
|
||||
/**
|
||||
* Represents the dead looking grass.
|
||||
*/
|
||||
DEAD(0x0),
|
||||
/**
|
||||
* Represents the normal grass species.
|
||||
*/
|
||||
NORMAL(0x1),
|
||||
/**
|
||||
* Represents the fern-looking grass species.
|
||||
*/
|
||||
FERN_LIKE(0x2);
|
||||
|
||||
private final byte data;
|
||||
private final static Map<Byte, GrassSpecies> BY_DATA = Maps.newHashMap();
|
||||
|
||||
private GrassSpecies(final int data) {
|
||||
this.data = (byte) data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the associated data value representing this species
|
||||
*
|
||||
* @return A byte containing the data value of this grass species
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public byte getData() {
|
||||
return data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the GrassSpecies with the given data value
|
||||
*
|
||||
* @param data Data value to fetch
|
||||
* @return The {@link GrassSpecies} representing the given value, or null
|
||||
* if it doesn't exist
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public static GrassSpecies getByData(final byte data) {
|
||||
return BY_DATA.get(data);
|
||||
}
|
||||
|
||||
static {
|
||||
for (GrassSpecies grassSpecies : values()) {
|
||||
BY_DATA.put(grassSpecies.getData(), grassSpecies);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,67 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import com.google.common.collect.Maps;
|
||||
|
||||
public enum Instrument {
|
||||
|
||||
/**
|
||||
* Piano is the standard instrument for a note block.
|
||||
*/
|
||||
PIANO(0x0),
|
||||
/**
|
||||
* Bass drum is normally played when a note block is on top of a
|
||||
* stone-like block
|
||||
*/
|
||||
BASS_DRUM(0x1),
|
||||
/**
|
||||
* Snare drum is normally played when a note block is on top of a sandy
|
||||
* block.
|
||||
*/
|
||||
SNARE_DRUM(0x2),
|
||||
/**
|
||||
* Sticks are normally played when a note block is on top of a glass
|
||||
* block.
|
||||
*/
|
||||
STICKS(0x3),
|
||||
/**
|
||||
* Bass guitar is normally played when a note block is on top of a wooden
|
||||
* block.
|
||||
*/
|
||||
BASS_GUITAR(0x4);
|
||||
|
||||
private final byte type;
|
||||
private final static Map<Byte, Instrument> BY_DATA = Maps.newHashMap();
|
||||
|
||||
private Instrument(final int type) {
|
||||
this.type = (byte) type;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return The type ID of this instrument.
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public byte getType() {
|
||||
return this.type;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get an instrument by its type ID.
|
||||
*
|
||||
* @param type The type ID
|
||||
* @return The instrument
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public static Instrument getByType(final byte type) {
|
||||
return BY_DATA.get(type);
|
||||
}
|
||||
|
||||
static {
|
||||
for (Instrument instrument : Instrument.values()) {
|
||||
BY_DATA.put(instrument.getType(), instrument);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,560 @@
|
||||
package org.bukkit;
|
||||
|
||||
import org.bukkit.block.Block;
|
||||
import org.bukkit.util.NumberConversions;
|
||||
import org.bukkit.util.Vector;
|
||||
|
||||
/**
|
||||
* Represents a 3-dimensional position in a world
|
||||
*/
|
||||
public class Location implements Cloneable {
|
||||
private World world;
|
||||
private double x;
|
||||
private double y;
|
||||
private double z;
|
||||
private float pitch;
|
||||
private float yaw;
|
||||
|
||||
/**
|
||||
* Constructs a new Location with the given coordinates
|
||||
*
|
||||
* @param world The world in which this location resides
|
||||
* @param x The x-coordinate of this new location
|
||||
* @param y The y-coordinate of this new location
|
||||
* @param z The z-coordinate of this new location
|
||||
*/
|
||||
public Location(final World world, final double x, final double y, final double z) {
|
||||
this(world, x, y, z, 0, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructs a new Location with the given coordinates and direction
|
||||
*
|
||||
* @param world The world in which this location resides
|
||||
* @param x The x-coordinate of this new location
|
||||
* @param y The y-coordinate of this new location
|
||||
* @param z The z-coordinate of this new location
|
||||
* @param yaw The absolute rotation on the x-plane, in degrees
|
||||
* @param pitch The absolute rotation on the y-plane, in degrees
|
||||
*/
|
||||
public Location(final World world, final double x, final double y, final double z, final float yaw, final float pitch) {
|
||||
this.world = world;
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
this.z = z;
|
||||
this.pitch = pitch;
|
||||
this.yaw = yaw;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the world that this location resides in
|
||||
*
|
||||
* @param world New world that this location resides in
|
||||
*/
|
||||
public void setWorld(World world) {
|
||||
this.world = world;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the world that this location resides in
|
||||
*
|
||||
* @return World that contains this location
|
||||
*/
|
||||
public World getWorld() {
|
||||
return world;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the chunk at the represented location
|
||||
*
|
||||
* @return Chunk at the represented location
|
||||
*/
|
||||
public Chunk getChunk() {
|
||||
return world.getChunkAt(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the block at the represented location
|
||||
*
|
||||
* @return Block at the represented location
|
||||
*/
|
||||
public Block getBlock() {
|
||||
return world.getBlockAt(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the x-coordinate of this location
|
||||
*
|
||||
* @param x X-coordinate
|
||||
*/
|
||||
public void setX(double x) {
|
||||
this.x = x;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the x-coordinate of this location
|
||||
*
|
||||
* @return x-coordinate
|
||||
*/
|
||||
public double getX() {
|
||||
return x;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the floored value of the X component, indicating the block that
|
||||
* this location is contained with.
|
||||
*
|
||||
* @return block X
|
||||
*/
|
||||
public int getBlockX() {
|
||||
return locToBlock(x);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the y-coordinate of this location
|
||||
*
|
||||
* @param y y-coordinate
|
||||
*/
|
||||
public void setY(double y) {
|
||||
this.y = y;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the y-coordinate of this location
|
||||
*
|
||||
* @return y-coordinate
|
||||
*/
|
||||
public double getY() {
|
||||
return y;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the floored value of the Y component, indicating the block that
|
||||
* this location is contained with.
|
||||
*
|
||||
* @return block y
|
||||
*/
|
||||
public int getBlockY() {
|
||||
return locToBlock(y);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the z-coordinate of this location
|
||||
*
|
||||
* @param z z-coordinate
|
||||
*/
|
||||
public void setZ(double z) {
|
||||
this.z = z;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the z-coordinate of this location
|
||||
*
|
||||
* @return z-coordinate
|
||||
*/
|
||||
public double getZ() {
|
||||
return z;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the floored value of the Z component, indicating the block that
|
||||
* this location is contained with.
|
||||
*
|
||||
* @return block z
|
||||
*/
|
||||
public int getBlockZ() {
|
||||
return locToBlock(z);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the yaw of this location, measured in degrees.
|
||||
* <ul>
|
||||
* <li>A yaw of 0 or 360 represents the positive z direction.
|
||||
* <li>A yaw of 180 represents the negative z direction.
|
||||
* <li>A yaw of 90 represents the negative x direction.
|
||||
* <li>A yaw of 270 represents the positive x direction.
|
||||
* </ul>
|
||||
* Increasing yaw values are the equivalent of turning to your
|
||||
* right-facing, increasing the scale of the next respective axis, and
|
||||
* decreasing the scale of the previous axis.
|
||||
*
|
||||
* @param yaw new rotation's yaw
|
||||
*/
|
||||
public void setYaw(float yaw) {
|
||||
this.yaw = yaw;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the yaw of this location, measured in degrees.
|
||||
* <ul>
|
||||
* <li>A yaw of 0 or 360 represents the positive z direction.
|
||||
* <li>A yaw of 180 represents the negative z direction.
|
||||
* <li>A yaw of 90 represents the negative x direction.
|
||||
* <li>A yaw of 270 represents the positive x direction.
|
||||
* </ul>
|
||||
* Increasing yaw values are the equivalent of turning to your
|
||||
* right-facing, increasing the scale of the next respective axis, and
|
||||
* decreasing the scale of the previous axis.
|
||||
*
|
||||
* @return the rotation's yaw
|
||||
*/
|
||||
public float getYaw() {
|
||||
return yaw;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the pitch of this location, measured in degrees.
|
||||
* <ul>
|
||||
* <li>A pitch of 0 represents level forward facing.
|
||||
* <li>A pitch of 90 represents downward facing, or negative y
|
||||
* direction.
|
||||
* <li>A pitch of -90 represents upward facing, or positive y direction.
|
||||
* <ul>
|
||||
* Increasing pitch values the equivalent of looking down.
|
||||
*
|
||||
* @param pitch new incline's pitch
|
||||
*/
|
||||
public void setPitch(float pitch) {
|
||||
this.pitch = pitch;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the pitch of this location, measured in degrees.
|
||||
* <ul>
|
||||
* <li>A pitch of 0 represents level forward facing.
|
||||
* <li>A pitch of 90 represents downward facing, or negative y
|
||||
* direction.
|
||||
* <li>A pitch of -90 represents upward facing, or positive y direction.
|
||||
* <ul>
|
||||
* Increasing pitch values the equivalent of looking down.
|
||||
*
|
||||
* @return the incline's pitch
|
||||
*/
|
||||
public float getPitch() {
|
||||
return pitch;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a unit-vector pointing in the direction that this Location is
|
||||
* facing.
|
||||
*
|
||||
* @return a vector pointing the direction of this location's {@link
|
||||
* #getPitch() pitch} and {@link #getYaw() yaw}
|
||||
*/
|
||||
public Vector getDirection() {
|
||||
Vector vector = new Vector();
|
||||
|
||||
double rotX = this.getYaw();
|
||||
double rotY = this.getPitch();
|
||||
|
||||
vector.setY(-Math.sin(Math.toRadians(rotY)));
|
||||
|
||||
double xz = Math.cos(Math.toRadians(rotY));
|
||||
|
||||
vector.setX(-xz * Math.sin(Math.toRadians(rotX)));
|
||||
vector.setZ(xz * Math.cos(Math.toRadians(rotX)));
|
||||
|
||||
return vector;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the {@link #getYaw() yaw} and {@link #getPitch() pitch} to point
|
||||
* in the direction of the vector.
|
||||
*/
|
||||
public Location setDirection(Vector vector) {
|
||||
/*
|
||||
* Sin = Opp / Hyp
|
||||
* Cos = Adj / Hyp
|
||||
* Tan = Opp / Adj
|
||||
*
|
||||
* x = -Opp
|
||||
* z = Adj
|
||||
*/
|
||||
final double _2PI = 2 * Math.PI;
|
||||
final double x = vector.getX();
|
||||
final double z = vector.getZ();
|
||||
|
||||
if (x == 0 && z == 0) {
|
||||
pitch = vector.getY() > 0 ? -90 : 90;
|
||||
return this;
|
||||
}
|
||||
|
||||
double theta = Math.atan2(-x, z);
|
||||
yaw = (float) Math.toDegrees((theta + _2PI) % _2PI);
|
||||
|
||||
double x2 = NumberConversions.square(x);
|
||||
double z2 = NumberConversions.square(z);
|
||||
double xz = Math.sqrt(x2 + z2);
|
||||
pitch = (float) Math.toDegrees(Math.atan(-vector.getY() / xz));
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds the location by another.
|
||||
*
|
||||
* @see Vector
|
||||
* @param vec The other location
|
||||
* @return the same location
|
||||
* @throws IllegalArgumentException for differing worlds
|
||||
*/
|
||||
public Location add(Location vec) {
|
||||
if (vec == null || vec.getWorld() != getWorld()) {
|
||||
throw new IllegalArgumentException("Cannot add Locations of differing worlds");
|
||||
}
|
||||
|
||||
x += vec.x;
|
||||
y += vec.y;
|
||||
z += vec.z;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds the location by a vector.
|
||||
*
|
||||
* @see Vector
|
||||
* @param vec Vector to use
|
||||
* @return the same location
|
||||
*/
|
||||
public Location add(Vector vec) {
|
||||
this.x += vec.getX();
|
||||
this.y += vec.getY();
|
||||
this.z += vec.getZ();
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Adds the location by another. Not world-aware.
|
||||
*
|
||||
* @see Vector
|
||||
* @param x X coordinate
|
||||
* @param y Y coordinate
|
||||
* @param z Z coordinate
|
||||
* @return the same location
|
||||
*/
|
||||
public Location add(double x, double y, double z) {
|
||||
this.x += x;
|
||||
this.y += y;
|
||||
this.z += z;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Subtracts the location by another.
|
||||
*
|
||||
* @see Vector
|
||||
* @param vec The other location
|
||||
* @return the same location
|
||||
* @throws IllegalArgumentException for differing worlds
|
||||
*/
|
||||
public Location subtract(Location vec) {
|
||||
if (vec == null || vec.getWorld() != getWorld()) {
|
||||
throw new IllegalArgumentException("Cannot add Locations of differing worlds");
|
||||
}
|
||||
|
||||
x -= vec.x;
|
||||
y -= vec.y;
|
||||
z -= vec.z;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Subtracts the location by a vector.
|
||||
*
|
||||
* @see Vector
|
||||
* @param vec The vector to use
|
||||
* @return the same location
|
||||
*/
|
||||
public Location subtract(Vector vec) {
|
||||
this.x -= vec.getX();
|
||||
this.y -= vec.getY();
|
||||
this.z -= vec.getZ();
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Subtracts the location by another. Not world-aware and
|
||||
* orientation independent.
|
||||
*
|
||||
* @see Vector
|
||||
* @param x X coordinate
|
||||
* @param y Y coordinate
|
||||
* @param z Z coordinate
|
||||
* @return the same location
|
||||
*/
|
||||
public Location subtract(double x, double y, double z) {
|
||||
this.x -= x;
|
||||
this.y -= y;
|
||||
this.z -= z;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the magnitude of the location, defined as sqrt(x^2+y^2+z^2). The
|
||||
* value of this method is not cached and uses a costly square-root
|
||||
* function, so do not repeatedly call this method to get the location's
|
||||
* magnitude. NaN will be returned if the inner result of the sqrt()
|
||||
* function overflows, which will be caused if the length is too long. Not
|
||||
* world-aware and orientation independent.
|
||||
*
|
||||
* @see Vector
|
||||
* @return the magnitude
|
||||
*/
|
||||
public double length() {
|
||||
return Math.sqrt(NumberConversions.square(x) + NumberConversions.square(y) + NumberConversions.square(z));
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the magnitude of the location squared. Not world-aware and
|
||||
* orientation independent.
|
||||
*
|
||||
* @see Vector
|
||||
* @return the magnitude
|
||||
*/
|
||||
public double lengthSquared() {
|
||||
return NumberConversions.square(x) + NumberConversions.square(y) + NumberConversions.square(z);
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the distance between this location and another. The value of this
|
||||
* method is not cached and uses a costly square-root function, so do not
|
||||
* repeatedly call this method to get the location's magnitude. NaN will
|
||||
* be returned if the inner result of the sqrt() function overflows, which
|
||||
* will be caused if the distance is too long.
|
||||
*
|
||||
* @see Vector
|
||||
* @param o The other location
|
||||
* @return the distance
|
||||
* @throws IllegalArgumentException for differing worlds
|
||||
*/
|
||||
public double distance(Location o) {
|
||||
return Math.sqrt(distanceSquared(o));
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the squared distance between this location and another.
|
||||
*
|
||||
* @see Vector
|
||||
* @param o The other location
|
||||
* @return the distance
|
||||
* @throws IllegalArgumentException for differing worlds
|
||||
*/
|
||||
public double distanceSquared(Location o) {
|
||||
if (o == null) {
|
||||
throw new IllegalArgumentException("Cannot measure distance to a null location");
|
||||
} else if (o.getWorld() == null || getWorld() == null) {
|
||||
throw new IllegalArgumentException("Cannot measure distance to a null world");
|
||||
} else if (o.getWorld() != getWorld()) {
|
||||
throw new IllegalArgumentException("Cannot measure distance between " + getWorld().getName() + " and " + o.getWorld().getName());
|
||||
}
|
||||
|
||||
return NumberConversions.square(x - o.x) + NumberConversions.square(y - o.y) + NumberConversions.square(z - o.z);
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs scalar multiplication, multiplying all components with a
|
||||
* scalar. Not world-aware.
|
||||
*
|
||||
* @param m The factor
|
||||
* @see Vector
|
||||
* @return the same location
|
||||
*/
|
||||
public Location multiply(double m) {
|
||||
x *= m;
|
||||
y *= m;
|
||||
z *= m;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Zero this location's components. Not world-aware.
|
||||
*
|
||||
* @see Vector
|
||||
* @return the same location
|
||||
*/
|
||||
public Location zero() {
|
||||
x = 0;
|
||||
y = 0;
|
||||
z = 0;
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
if (obj == null) {
|
||||
return false;
|
||||
}
|
||||
if (getClass() != obj.getClass()) {
|
||||
return false;
|
||||
}
|
||||
final Location other = (Location) obj;
|
||||
|
||||
if (this.world != other.world && (this.world == null || !this.world.equals(other.world))) {
|
||||
return false;
|
||||
}
|
||||
if (Double.doubleToLongBits(this.x) != Double.doubleToLongBits(other.x)) {
|
||||
return false;
|
||||
}
|
||||
if (Double.doubleToLongBits(this.y) != Double.doubleToLongBits(other.y)) {
|
||||
return false;
|
||||
}
|
||||
if (Double.doubleToLongBits(this.z) != Double.doubleToLongBits(other.z)) {
|
||||
return false;
|
||||
}
|
||||
if (Float.floatToIntBits(this.pitch) != Float.floatToIntBits(other.pitch)) {
|
||||
return false;
|
||||
}
|
||||
if (Float.floatToIntBits(this.yaw) != Float.floatToIntBits(other.yaw)) {
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
int hash = 3;
|
||||
|
||||
hash = 19 * hash + (this.world != null ? this.world.hashCode() : 0);
|
||||
hash = 19 * hash + (int) (Double.doubleToLongBits(this.x) ^ (Double.doubleToLongBits(this.x) >>> 32));
|
||||
hash = 19 * hash + (int) (Double.doubleToLongBits(this.y) ^ (Double.doubleToLongBits(this.y) >>> 32));
|
||||
hash = 19 * hash + (int) (Double.doubleToLongBits(this.z) ^ (Double.doubleToLongBits(this.z) >>> 32));
|
||||
hash = 19 * hash + Float.floatToIntBits(this.pitch);
|
||||
hash = 19 * hash + Float.floatToIntBits(this.yaw);
|
||||
return hash;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "Location{" + "world=" + world + ",x=" + x + ",y=" + y + ",z=" + z + ",pitch=" + pitch + ",yaw=" + yaw + '}';
|
||||
}
|
||||
|
||||
/**
|
||||
* Constructs a new {@link Vector} based on this Location
|
||||
*
|
||||
* @return New Vector containing the coordinates represented by this
|
||||
* Location
|
||||
*/
|
||||
public Vector toVector() {
|
||||
return new Vector(x, y, z);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Location clone() {
|
||||
try {
|
||||
return (Location) super.clone();
|
||||
} catch (CloneNotSupportedException e) {
|
||||
throw new Error(e);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Safely converts a double (location coordinate) to an int (block
|
||||
* coordinate)
|
||||
*
|
||||
* @param loc Precise coordinate
|
||||
* @return Block coordinate
|
||||
*/
|
||||
public static int locToBlock(double loc) {
|
||||
return NumberConversions.floor(loc);
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,21 @@
|
||||
package org.bukkit;
|
||||
|
||||
public enum NetherWartsState {
|
||||
|
||||
/**
|
||||
* State when first seeded
|
||||
*/
|
||||
SEEDED,
|
||||
/**
|
||||
* First growth stage
|
||||
*/
|
||||
STAGE_ONE,
|
||||
/**
|
||||
* Second growth stage
|
||||
*/
|
||||
STAGE_TWO,
|
||||
/**
|
||||
* Ready to harvest
|
||||
*/
|
||||
RIPE;
|
||||
}
|
||||
@@ -0,0 +1,276 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import org.apache.commons.lang.Validate;
|
||||
|
||||
import com.google.common.collect.Maps;
|
||||
|
||||
/**
|
||||
* A note class to store a specific note.
|
||||
*/
|
||||
public class Note {
|
||||
|
||||
/**
|
||||
* An enum holding tones.
|
||||
*/
|
||||
public enum Tone {
|
||||
G(0x1, true),
|
||||
A(0x3, true),
|
||||
B(0x5, false),
|
||||
C(0x6, true),
|
||||
D(0x8, true),
|
||||
E(0xA, false),
|
||||
F(0xB, true);
|
||||
|
||||
private final boolean sharpable;
|
||||
private final byte id;
|
||||
|
||||
private static final Map<Byte, Note.Tone> BY_DATA = Maps.newHashMap();
|
||||
/** The number of tones including sharped tones. */
|
||||
public static final byte TONES_COUNT = 12;
|
||||
|
||||
private Tone(int id, boolean sharpable) {
|
||||
this.id = (byte) (id % TONES_COUNT);
|
||||
this.sharpable = sharpable;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the not sharped id of this tone.
|
||||
*
|
||||
* @return the not sharped id of this tone.
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public byte getId() {
|
||||
return getId(false);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the id of this tone. These method allows to return the
|
||||
* sharped id of the tone. If the tone couldn't be sharped it always
|
||||
* return the not sharped id of this tone.
|
||||
*
|
||||
* @param sharped Set to true to return the sharped id.
|
||||
* @return the id of this tone.
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public byte getId(boolean sharped) {
|
||||
byte id = (byte) (sharped && sharpable ? this.id + 1 : this.id);
|
||||
|
||||
return (byte) (id % TONES_COUNT);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns if this tone could be sharped.
|
||||
*
|
||||
* @return if this tone could be sharped.
|
||||
*/
|
||||
public boolean isSharpable() {
|
||||
return sharpable;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns if this tone id is the sharped id of the tone.
|
||||
*
|
||||
* @param id the id of the tone.
|
||||
* @return if the tone id is the sharped id of the tone.
|
||||
* @throws IllegalArgumentException if neither the tone nor the
|
||||
* semitone have the id.
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public boolean isSharped(byte id) {
|
||||
if (id == getId(false)) {
|
||||
return false;
|
||||
} else if (id == getId(true)) {
|
||||
return true;
|
||||
} else {
|
||||
// The id isn't matching to the tone!
|
||||
throw new IllegalArgumentException("The id isn't matching to the tone.");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the tone to id. Also returning the semitones.
|
||||
*
|
||||
* @param id the id of the tone.
|
||||
* @return the tone to id.
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public static Tone getById(byte id) {
|
||||
return BY_DATA.get(id);
|
||||
}
|
||||
|
||||
static {
|
||||
for (Tone tone : values()) {
|
||||
int id = tone.id % TONES_COUNT;
|
||||
BY_DATA.put((byte) id, tone);
|
||||
|
||||
if (tone.isSharpable()) {
|
||||
id = (id + 1) % TONES_COUNT;
|
||||
BY_DATA.put((byte) id, tone);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private final byte note;
|
||||
|
||||
/**
|
||||
* Creates a new note.
|
||||
*
|
||||
* @param note Internal note id. {@link #getId()} always return this
|
||||
* value. The value has to be in the interval [0; 24].
|
||||
*/
|
||||
public Note(int note) {
|
||||
Validate.isTrue(note >= 0 && note <= 24, "The note value has to be between 0 and 24.");
|
||||
|
||||
this.note = (byte) note;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new note.
|
||||
*
|
||||
* @param octave The octave where the note is in. Has to be 0 - 2.
|
||||
* @param tone The tone within the octave. If the octave is 2 the note has
|
||||
* to be F#.
|
||||
* @param sharped Set if the tone is sharped (e.g. for F#).
|
||||
*/
|
||||
public Note(int octave, Tone tone, boolean sharped) {
|
||||
if (sharped && !tone.isSharpable()) {
|
||||
tone = Tone.values()[tone.ordinal() + 1];
|
||||
sharped = false;
|
||||
}
|
||||
if (octave < 0 || octave > 2 || (octave == 2 && !(tone == Tone.F && sharped))) {
|
||||
throw new IllegalArgumentException("Tone and octave have to be between F#0 and F#2");
|
||||
}
|
||||
|
||||
this.note = (byte) (octave * Tone.TONES_COUNT + tone.getId(sharped));
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new note for a flat tone, such as A-flat.
|
||||
*
|
||||
* @param octave The octave where the note is in. Has to be 0 - 1.
|
||||
* @param tone The tone within the octave.
|
||||
* @return The new note.
|
||||
*/
|
||||
public static Note flat(int octave, Tone tone) {
|
||||
Validate.isTrue(octave != 2, "Octave cannot be 2 for flats");
|
||||
tone = tone == Tone.G ? Tone.F : Tone.values()[tone.ordinal() - 1];
|
||||
return new Note(octave, tone, tone.isSharpable());
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new note for a sharp tone, such as A-sharp.
|
||||
*
|
||||
* @param octave The octave where the note is in. Has to be 0 - 2.
|
||||
* @param tone The tone within the octave. If the octave is 2 the note has
|
||||
* to be F#.
|
||||
* @return The new note.
|
||||
*/
|
||||
public static Note sharp(int octave, Tone tone) {
|
||||
return new Note(octave, tone, true);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new note for a natural tone, such as A-natural.
|
||||
*
|
||||
* @param octave The octave where the note is in. Has to be 0 - 1.
|
||||
* @param tone The tone within the octave.
|
||||
* @return The new note.
|
||||
*/
|
||||
public static Note natural(int octave, Tone tone) {
|
||||
Validate.isTrue(octave != 2, "Octave cannot be 2 for naturals");
|
||||
return new Note(octave, tone, false);
|
||||
}
|
||||
|
||||
/**
|
||||
* @return The note a semitone above this one.
|
||||
*/
|
||||
public Note sharped() {
|
||||
Validate.isTrue(note < 24, "This note cannot be sharped because it is the highest known note!");
|
||||
return new Note(note + 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* @return The note a semitone below this one.
|
||||
*/
|
||||
public Note flattened() {
|
||||
Validate.isTrue(note > 0, "This note cannot be flattened because it is the lowest known note!");
|
||||
return new Note(note - 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the internal id of this note.
|
||||
*
|
||||
* @return the internal id of this note.
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public byte getId() {
|
||||
return note;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the octave of this note.
|
||||
*
|
||||
* @return the octave of this note.
|
||||
*/
|
||||
public int getOctave() {
|
||||
return note / Tone.TONES_COUNT;
|
||||
}
|
||||
|
||||
private byte getToneByte() {
|
||||
return (byte) (note % Tone.TONES_COUNT);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the tone of this note.
|
||||
*
|
||||
* @return the tone of this note.
|
||||
*/
|
||||
public Tone getTone() {
|
||||
return Tone.getById(getToneByte());
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns if this note is sharped.
|
||||
*
|
||||
* @return if this note is sharped.
|
||||
*/
|
||||
public boolean isSharped() {
|
||||
byte note = getToneByte();
|
||||
return Tone.getById(note).isSharped(note);
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
final int prime = 31;
|
||||
int result = 1;
|
||||
result = prime * result + note;
|
||||
return result;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object obj) {
|
||||
if (this == obj)
|
||||
return true;
|
||||
if (obj == null)
|
||||
return false;
|
||||
if (getClass() != obj.getClass())
|
||||
return false;
|
||||
Note other = (Note) obj;
|
||||
if (note != other.note)
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return "Note{" + getTone().toString() + (isSharped() ? "#" : "") + "}";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,118 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.util.Date;
|
||||
import java.util.UUID;
|
||||
|
||||
import org.bukkit.configuration.serialization.ConfigurationSerializable;
|
||||
import org.bukkit.entity.AnimalTamer;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.permissions.ServerOperator;
|
||||
|
||||
public interface OfflinePlayer extends ServerOperator, AnimalTamer, ConfigurationSerializable {
|
||||
|
||||
/**
|
||||
* Checks if this player is currently online
|
||||
*
|
||||
* @return true if they are online
|
||||
*/
|
||||
public boolean isOnline();
|
||||
|
||||
/**
|
||||
* Returns the name of this player
|
||||
* <p>
|
||||
* Names are no longer unique past a single game session. For persistent storage
|
||||
* it is recommended that you use {@link #getUniqueId()} instead.
|
||||
*
|
||||
* @return Player name or null if we have not seen a name for this player yet
|
||||
*/
|
||||
public String getName();
|
||||
|
||||
/**
|
||||
* Returns the UUID of this player
|
||||
*
|
||||
* @return Player UUID
|
||||
*/
|
||||
public UUID getUniqueId();
|
||||
|
||||
/**
|
||||
* Checks if this player is banned or not
|
||||
*
|
||||
* @return true if banned, otherwise false
|
||||
*/
|
||||
public boolean isBanned();
|
||||
|
||||
/**
|
||||
* Bans or unbans this player
|
||||
*
|
||||
* @param banned true if banned
|
||||
* @deprecated Use {@link org.bukkit.BanList#addBan(String, String, Date,
|
||||
* String)} or {@link org.bukkit.BanList#pardon(String)} to enhance
|
||||
* functionality
|
||||
*/
|
||||
@Deprecated
|
||||
public void setBanned(boolean banned);
|
||||
|
||||
/**
|
||||
* Checks if this player is whitelisted or not
|
||||
*
|
||||
* @return true if whitelisted
|
||||
*/
|
||||
public boolean isWhitelisted();
|
||||
|
||||
/**
|
||||
* Sets if this player is whitelisted or not
|
||||
*
|
||||
* @param value true if whitelisted
|
||||
*/
|
||||
public void setWhitelisted(boolean value);
|
||||
|
||||
/**
|
||||
* Gets a {@link Player} object that this represents, if there is one
|
||||
* <p>
|
||||
* If the player is online, this will return that player. Otherwise,
|
||||
* it will return null.
|
||||
*
|
||||
* @return Online player
|
||||
*/
|
||||
public Player getPlayer();
|
||||
|
||||
/**
|
||||
* Gets the first date and time that this player was witnessed on this
|
||||
* server.
|
||||
* <p>
|
||||
* If the player has never played before, this will return 0. Otherwise,
|
||||
* it will be the amount of milliseconds since midnight, January 1, 1970
|
||||
* UTC.
|
||||
*
|
||||
* @return Date of first log-in for this player, or 0
|
||||
*/
|
||||
public long getFirstPlayed();
|
||||
|
||||
/**
|
||||
* Gets the last date and time that this player was witnessed on this
|
||||
* server.
|
||||
* <p>
|
||||
* If the player has never played before, this will return 0. Otherwise,
|
||||
* it will be the amount of milliseconds since midnight, January 1, 1970
|
||||
* UTC.
|
||||
*
|
||||
* @return Date of last log-in for this player, or 0
|
||||
*/
|
||||
public long getLastPlayed();
|
||||
|
||||
/**
|
||||
* Checks if this player has played on this server before.
|
||||
*
|
||||
* @return True if the player has played before, otherwise false
|
||||
*/
|
||||
public boolean hasPlayedBefore();
|
||||
|
||||
/**
|
||||
* Gets the Location where the player will spawn at their bed, null if
|
||||
* they have not slept in one or their current bed spawn is invalid.
|
||||
*
|
||||
* @return Bed Spawn Location if bed exists, otherwise null.
|
||||
*/
|
||||
public Location getBedSpawnLocation();
|
||||
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
package org.bukkit;
|
||||
|
||||
/**
|
||||
* Represents various types of portals that can be made in a world.
|
||||
*/
|
||||
public enum PortalType {
|
||||
|
||||
/**
|
||||
* This is a Nether portal, made of obsidian.
|
||||
*/
|
||||
NETHER,
|
||||
|
||||
/**
|
||||
* This is an Ender portal.
|
||||
*/
|
||||
ENDER,
|
||||
|
||||
/**
|
||||
* This is a custom Plugin portal.
|
||||
*/
|
||||
CUSTOM;
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
package org.bukkit;
|
||||
|
||||
/**
|
||||
* An enum to specify a rotation based orientation, like that on a clock.
|
||||
* <p>
|
||||
* It represents how something is viewed, as opposed to cardinal directions.
|
||||
*/
|
||||
public enum Rotation {
|
||||
|
||||
/**
|
||||
* No rotation
|
||||
*/
|
||||
NONE,
|
||||
/**
|
||||
* Rotated clockwise by 90 degrees
|
||||
*/
|
||||
CLOCKWISE,
|
||||
/**
|
||||
* Flipped upside-down, a 180 degree rotation
|
||||
*/
|
||||
FLIPPED,
|
||||
/**
|
||||
* Rotated counter-clockwise by 90 degrees
|
||||
*/
|
||||
COUNTER_CLOCKWISE,
|
||||
;
|
||||
|
||||
private static final Rotation [] rotations = values();
|
||||
|
||||
/**
|
||||
* Rotate clockwise by 90 degrees.
|
||||
*
|
||||
* @return the relative rotation
|
||||
*/
|
||||
public Rotation rotateClockwise() {
|
||||
return rotations[(this.ordinal() + 1) & 0x3];
|
||||
}
|
||||
|
||||
/**
|
||||
* Rotate counter-clockwise by 90 degrees.
|
||||
*
|
||||
* @return the relative rotation
|
||||
*/
|
||||
public Rotation rotateCounterClockwise() {
|
||||
return rotations[(this.ordinal() - 1) & 0x3];
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import com.google.common.collect.Maps;
|
||||
|
||||
/**
|
||||
* Represents the three different types of Sandstone
|
||||
*/
|
||||
public enum SandstoneType {
|
||||
CRACKED(0x0),
|
||||
GLYPHED(0x1),
|
||||
SMOOTH(0x2);
|
||||
|
||||
private final byte data;
|
||||
private final static Map<Byte, SandstoneType> BY_DATA = Maps.newHashMap();
|
||||
|
||||
private SandstoneType(final int data) {
|
||||
this.data = (byte) data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the associated data value representing this type of sandstone
|
||||
*
|
||||
* @return A byte containing the data value of this sandstone type
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public byte getData() {
|
||||
return data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the type of sandstone with the given data value
|
||||
*
|
||||
* @param data Data value to fetch
|
||||
* @return The {@link SandstoneType} representing the given value, or null
|
||||
* if it doesn't exist
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public static SandstoneType getByData(final byte data) {
|
||||
return BY_DATA.get(data);
|
||||
}
|
||||
|
||||
static {
|
||||
for (SandstoneType type : values()) {
|
||||
BY_DATA.put(type.data, type);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,919 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.awt.image.BufferedImage;
|
||||
import java.io.File;
|
||||
import java.io.Serializable;
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.UUID;
|
||||
import java.util.logging.Logger;
|
||||
|
||||
import org.bukkit.Warning.WarningState;
|
||||
import org.bukkit.command.CommandException;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.command.ConsoleCommandSender;
|
||||
import org.bukkit.command.PluginCommand;
|
||||
import org.bukkit.entity.Entity;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.event.inventory.InventoryType;
|
||||
import org.bukkit.event.server.ServerListPingEvent;
|
||||
import org.bukkit.help.HelpMap;
|
||||
import org.bukkit.inventory.Inventory;
|
||||
import org.bukkit.inventory.InventoryHolder;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
import org.bukkit.inventory.Recipe;
|
||||
import org.bukkit.map.MapView;
|
||||
import org.bukkit.permissions.Permissible;
|
||||
import org.bukkit.plugin.PluginManager;
|
||||
import org.bukkit.plugin.ServicesManager;
|
||||
import org.bukkit.plugin.messaging.Messenger;
|
||||
import org.bukkit.plugin.messaging.PluginMessageRecipient;
|
||||
import org.bukkit.scheduler.BukkitScheduler;
|
||||
import org.bukkit.scoreboard.ScoreboardManager;
|
||||
import org.bukkit.util.CachedServerIcon;
|
||||
|
||||
import com.avaje.ebean.config.ServerConfig;
|
||||
import com.google.common.collect.ImmutableList;
|
||||
|
||||
import org.bukkit.inventory.ItemFactory;
|
||||
import org.bukkit.inventory.meta.ItemMeta;
|
||||
|
||||
/**
|
||||
* Represents a server implementation.
|
||||
*/
|
||||
public interface Server extends PluginMessageRecipient {
|
||||
|
||||
/**
|
||||
* Used for all administrative messages, such as an operator using a
|
||||
* command.
|
||||
* <p>
|
||||
* For use in {@link #broadcast(java.lang.String, java.lang.String)}.
|
||||
*/
|
||||
public static final String BROADCAST_CHANNEL_ADMINISTRATIVE = "bukkit.broadcast.admin";
|
||||
|
||||
/**
|
||||
* Used for all announcement messages, such as informing users that a
|
||||
* player has joined.
|
||||
* <p>
|
||||
* For use in {@link #broadcast(java.lang.String, java.lang.String)}.
|
||||
*/
|
||||
public static final String BROADCAST_CHANNEL_USERS = "bukkit.broadcast.user";
|
||||
|
||||
/**
|
||||
* Gets the name of this server implementation.
|
||||
*
|
||||
* @return name of this server implementation
|
||||
*/
|
||||
public String getName();
|
||||
|
||||
/**
|
||||
* Gets the version string of this server implementation.
|
||||
*
|
||||
* @return version of this server implementation
|
||||
*/
|
||||
public String getVersion();
|
||||
|
||||
/**
|
||||
* Gets the Bukkit version that this server is running.
|
||||
*
|
||||
* @return version of Bukkit
|
||||
*/
|
||||
public String getBukkitVersion();
|
||||
|
||||
/**
|
||||
* Gets an array copy of all currently logged in players.
|
||||
* <p>
|
||||
* This method exists for legacy reasons to provide backwards
|
||||
* compatibility. It will not exist at runtime and should not be used
|
||||
* under any circumstances.
|
||||
*
|
||||
* @Deprecated superseded by {@link #getOnlinePlayers()}
|
||||
* @return an array of Players that are currently online
|
||||
*/
|
||||
@Deprecated
|
||||
public Player[] _INVALID_getOnlinePlayers();
|
||||
|
||||
/**
|
||||
* Gets a view of all currently logged in players. This {@linkplain
|
||||
* Collections#unmodifiableCollection(Collection) view} is a reused
|
||||
* object, making some operations like {@link Collection#size()}
|
||||
* zero-allocation.
|
||||
* <p>
|
||||
* The collection is a view backed by the internal representation, such
|
||||
* that, changes to the internal state of the server will be reflected
|
||||
* immediately. However, the reuse of the returned collection (identity)
|
||||
* is not strictly guaranteed for future or all implementations. Casting
|
||||
* the collection, or relying on interface implementations (like {@link
|
||||
* Serializable} or {@link List}), is deprecated.
|
||||
* <p>
|
||||
* Iteration behavior is undefined outside of self-contained main-thread
|
||||
* uses. Normal and immediate iterator use without consequences that
|
||||
* affect the collection are fully supported. The effects following
|
||||
* (non-exhaustive) {@link Entity#teleport(Location) teleportation},
|
||||
* {@link Player#setHealth(double) death}, and {@link Player#kickPlayer(
|
||||
* String) kicking} are undefined. Any use of this collection from
|
||||
* asynchronous threads is unsafe.
|
||||
* <p>
|
||||
* For safe consequential iteration or mimicking the old array behavior,
|
||||
* using {@link Collection#toArray(Object[])} is recommended. For making
|
||||
* snapshots, {@link ImmutableList#copyOf(Collection)} is recommended.
|
||||
*
|
||||
* @return a view of currently online players.
|
||||
*/
|
||||
public Collection<? extends Player> getOnlinePlayers();
|
||||
|
||||
/**
|
||||
* Get the maximum amount of players which can login to this server.
|
||||
*
|
||||
* @return the amount of players this server allows
|
||||
*/
|
||||
public int getMaxPlayers();
|
||||
|
||||
/**
|
||||
* Get the game port that the server runs on.
|
||||
*
|
||||
* @return the port number of this server
|
||||
*/
|
||||
public int getPort();
|
||||
|
||||
/**
|
||||
* Get the view distance from this server.
|
||||
*
|
||||
* @return the view distance from this server.
|
||||
*/
|
||||
public int getViewDistance();
|
||||
|
||||
/**
|
||||
* Get the IP that this server is bound to, or empty string if not
|
||||
* specified.
|
||||
*
|
||||
* @return the IP string that this server is bound to, otherwise empty
|
||||
* string
|
||||
*/
|
||||
public String getIp();
|
||||
|
||||
/**
|
||||
* Get the name of this server.
|
||||
*
|
||||
* @return the name of this server
|
||||
*/
|
||||
public String getServerName();
|
||||
|
||||
/**
|
||||
* Get an ID of this server. The ID is a simple generally alphanumeric ID
|
||||
* that can be used for uniquely identifying this server.
|
||||
*
|
||||
* @return the ID of this server
|
||||
*/
|
||||
public String getServerId();
|
||||
|
||||
/**
|
||||
* Get world type (level-type setting) for default world.
|
||||
*
|
||||
* @return the value of level-type (e.g. DEFAULT, FLAT, DEFAULT_1_1)
|
||||
*/
|
||||
public String getWorldType();
|
||||
|
||||
/**
|
||||
* Get generate-structures setting.
|
||||
*
|
||||
* @return true if structure generation is enabled, false otherwise
|
||||
*/
|
||||
public boolean getGenerateStructures();
|
||||
|
||||
/**
|
||||
* Gets whether this server allows the End or not.
|
||||
*
|
||||
* @return whether this server allows the End or not
|
||||
*/
|
||||
public boolean getAllowEnd();
|
||||
|
||||
/**
|
||||
* Gets whether this server allows the Nether or not.
|
||||
*
|
||||
* @return whether this server allows the Nether or not
|
||||
*/
|
||||
public boolean getAllowNether();
|
||||
|
||||
/**
|
||||
* Gets whether this server has a whitelist or not.
|
||||
*
|
||||
* @return whether this server has a whitelist or not
|
||||
*/
|
||||
public boolean hasWhitelist();
|
||||
|
||||
/**
|
||||
* Sets if the server is whitelisted.
|
||||
*
|
||||
* @param value true for whitelist on, false for off
|
||||
*/
|
||||
public void setWhitelist(boolean value);
|
||||
|
||||
/**
|
||||
* Gets a list of whitelisted players.
|
||||
*
|
||||
* @return a set containing all whitelisted players
|
||||
*/
|
||||
public Set<OfflinePlayer> getWhitelistedPlayers();
|
||||
|
||||
/**
|
||||
* Reloads the whitelist from disk.
|
||||
*/
|
||||
public void reloadWhitelist();
|
||||
|
||||
/**
|
||||
* Broadcast a message to all players.
|
||||
* <p>
|
||||
* This is the same as calling {@link #broadcast(java.lang.String,
|
||||
* java.lang.String)} to {@link #BROADCAST_CHANNEL_USERS}
|
||||
*
|
||||
* @param message the message
|
||||
* @return the number of players
|
||||
*/
|
||||
public int broadcastMessage(String message);
|
||||
|
||||
/**
|
||||
* Gets the name of the update folder. The update folder is used to safely
|
||||
* update plugins at the right moment on a plugin load.
|
||||
* <p>
|
||||
* The update folder name is relative to the plugins folder.
|
||||
*
|
||||
* @return the name of the update folder
|
||||
*/
|
||||
public String getUpdateFolder();
|
||||
|
||||
/**
|
||||
* Gets the update folder. The update folder is used to safely update
|
||||
* plugins at the right moment on a plugin load.
|
||||
*
|
||||
* @return the update folder
|
||||
*/
|
||||
public File getUpdateFolderFile();
|
||||
|
||||
/**
|
||||
* Gets the value of the connection throttle setting.
|
||||
*
|
||||
* @return the value of the connection throttle setting
|
||||
*/
|
||||
public long getConnectionThrottle();
|
||||
|
||||
/**
|
||||
* Gets default ticks per animal spawns value.
|
||||
* <p>
|
||||
* <b>Example Usage:</b>
|
||||
* <ul>
|
||||
* <li>A value of 1 will mean the server will attempt to spawn monsters
|
||||
* every tick.
|
||||
* <li>A value of 400 will mean the server will attempt to spawn monsters
|
||||
* every 400th tick.
|
||||
* <li>A value below 0 will be reset back to Minecraft's default.
|
||||
* </ul>
|
||||
* <p>
|
||||
* <b>Note:</b> If set to 0, animal spawning will be disabled. We
|
||||
* recommend using spawn-animals to control this instead.
|
||||
* <p>
|
||||
* Minecraft default: 400.
|
||||
*
|
||||
* @return the default ticks per animal spawns value
|
||||
*/
|
||||
public int getTicksPerAnimalSpawns();
|
||||
|
||||
/**
|
||||
* Gets the default ticks per monster spawns value.
|
||||
* <p>
|
||||
* <b>Example Usage:</b>
|
||||
* <ul>
|
||||
* <li>A value of 1 will mean the server will attempt to spawn monsters
|
||||
* every tick.
|
||||
* <li>A value of 400 will mean the server will attempt to spawn monsters
|
||||
* every 400th tick.
|
||||
* <li>A value below 0 will be reset back to Minecraft's default.
|
||||
* </ul>
|
||||
* <p>
|
||||
* <b>Note:</b> If set to 0, monsters spawning will be disabled. We
|
||||
* recommend using spawn-monsters to control this instead.
|
||||
* <p>
|
||||
* Minecraft default: 1.
|
||||
*
|
||||
* @return the default ticks per monsters spawn value
|
||||
*/
|
||||
public int getTicksPerMonsterSpawns();
|
||||
|
||||
/**
|
||||
* Gets a player object by the given username.
|
||||
* <p>
|
||||
* This method may not return objects for offline players.
|
||||
*
|
||||
* @deprecated Use {@link #getPlayer(UUID)} as player names are no longer
|
||||
* guaranteed to be unique
|
||||
* @param name the name to look up
|
||||
* @return a player if one was found, null otherwise
|
||||
*/
|
||||
@Deprecated
|
||||
public Player getPlayer(String name);
|
||||
|
||||
/**
|
||||
* Gets the player with the exact given name, case insensitive.
|
||||
*
|
||||
* @deprecated Use {@link #getPlayer(UUID)} as player names are no longer
|
||||
* guaranteed to be unique
|
||||
* @param name Exact name of the player to retrieve
|
||||
* @return a player object if one was found, null otherwise
|
||||
*/
|
||||
@Deprecated
|
||||
public Player getPlayerExact(String name);
|
||||
|
||||
/**
|
||||
* Attempts to match any players with the given name, and returns a list
|
||||
* of all possibly matches.
|
||||
* <p>
|
||||
* This list is not sorted in any particular order. If an exact match is
|
||||
* found, the returned list will only contain a single result.
|
||||
*
|
||||
* @deprecated Use {@link #getPlayer(UUID)} as player names are no longer
|
||||
* guaranteed to be unique
|
||||
* @param name the (partial) name to match
|
||||
* @return list of all possible players
|
||||
*/
|
||||
@Deprecated
|
||||
public List<Player> matchPlayer(String name);
|
||||
|
||||
/**
|
||||
* Gets the player with the given UUID.
|
||||
*
|
||||
* @param id UUID of the player to retrieve
|
||||
* @return a player object if one was found, null otherwise
|
||||
*/
|
||||
public Player getPlayer(UUID id);
|
||||
|
||||
/**
|
||||
* Gets the plugin manager for interfacing with plugins.
|
||||
*
|
||||
* @return a plugin manager for this Server instance
|
||||
*/
|
||||
public PluginManager getPluginManager();
|
||||
|
||||
/**
|
||||
* Gets the scheduler for managing scheduled events.
|
||||
*
|
||||
* @return a scheduling service for this server
|
||||
*/
|
||||
public BukkitScheduler getScheduler();
|
||||
|
||||
/**
|
||||
* Gets a services manager.
|
||||
*
|
||||
* @return s services manager
|
||||
*/
|
||||
public ServicesManager getServicesManager();
|
||||
|
||||
/**
|
||||
* Gets a list of all worlds on this server.
|
||||
*
|
||||
* @return a list of worlds
|
||||
*/
|
||||
public List<World> getWorlds();
|
||||
|
||||
/**
|
||||
* Creates or loads a world with the given name using the specified
|
||||
* options.
|
||||
* <p>
|
||||
* If the world is already loaded, it will just return the equivalent of
|
||||
* getWorld(creator.name()).
|
||||
*
|
||||
* @param creator the options to use when creating the world
|
||||
* @return newly created or loaded world
|
||||
*/
|
||||
public World createWorld(WorldCreator creator);
|
||||
|
||||
/**
|
||||
* Unloads a world with the given name.
|
||||
*
|
||||
* @param name Name of the world to unload
|
||||
* @param save whether to save the chunks before unloading
|
||||
* @return true if successful, false otherwise
|
||||
*/
|
||||
public boolean unloadWorld(String name, boolean save);
|
||||
|
||||
/**
|
||||
* Unloads the given world.
|
||||
*
|
||||
* @param world the world to unload
|
||||
* @param save whether to save the chunks before unloading
|
||||
* @return true if successful, false otherwise
|
||||
*/
|
||||
public boolean unloadWorld(World world, boolean save);
|
||||
|
||||
/**
|
||||
* Gets the world with the given name.
|
||||
*
|
||||
* @param name the name of the world to retrieve
|
||||
* @return a world with the given name, or null if none exists
|
||||
*/
|
||||
public World getWorld(String name);
|
||||
|
||||
/**
|
||||
* Gets the world from the given Unique ID.
|
||||
*
|
||||
* @param uid a unique-id of the world to retrieve
|
||||
* @return a world with the given Unique ID, or null if none exists
|
||||
*/
|
||||
public World getWorld(UUID uid);
|
||||
|
||||
/**
|
||||
* Gets the map from the given item ID.
|
||||
*
|
||||
* @param id the id of the map to get
|
||||
* @return a map view if it exists, or null otherwise
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public MapView getMap(short id);
|
||||
|
||||
/**
|
||||
* Create a new map with an automatically assigned ID.
|
||||
*
|
||||
* @param world the world the map will belong to
|
||||
* @return a newly created map view
|
||||
*/
|
||||
public MapView createMap(World world);
|
||||
|
||||
/**
|
||||
* Reloads the server, refreshing settings and plugin information.
|
||||
*/
|
||||
public void reload();
|
||||
|
||||
/**
|
||||
* Returns the primary logger associated with this server instance.
|
||||
*
|
||||
* @return Logger associated with this server
|
||||
*/
|
||||
public Logger getLogger();
|
||||
|
||||
/**
|
||||
* Gets a {@link PluginCommand} with the given name or alias.
|
||||
*
|
||||
* @param name the name of the command to retrieve
|
||||
* @return a plugin command if found, null otherwise
|
||||
*/
|
||||
public PluginCommand getPluginCommand(String name);
|
||||
|
||||
/**
|
||||
* Writes loaded players to disk.
|
||||
*/
|
||||
public void savePlayers();
|
||||
|
||||
/**
|
||||
* Dispatches a command on this server, and executes it if found.
|
||||
*
|
||||
* @param sender the apparent sender of the command
|
||||
* @param commandLine the command + arguments. Example: <code>test abc
|
||||
* 123</code>
|
||||
* @return returns false if no target is found
|
||||
* @throws CommandException thrown when the executor for the given command
|
||||
* fails with an unhandled exception
|
||||
*/
|
||||
public boolean dispatchCommand(CommandSender sender, String commandLine) throws CommandException;
|
||||
|
||||
/**
|
||||
* Populates a given {@link ServerConfig} with values attributes to this
|
||||
* server.
|
||||
*
|
||||
* @param config the server config to populate
|
||||
*/
|
||||
public void configureDbConfig(ServerConfig config);
|
||||
|
||||
/**
|
||||
* Adds a recipe to the crafting manager.
|
||||
*
|
||||
* @param recipe the recipe to add
|
||||
* @return true if the recipe was added, false if it wasn't for some
|
||||
* reason
|
||||
*/
|
||||
public boolean addRecipe(Recipe recipe);
|
||||
|
||||
/**
|
||||
* Get a list of all recipes for a given item. The stack size is ignored
|
||||
* in comparisons. If the durability is -1, it will match any data value.
|
||||
*
|
||||
* @param result the item to match against recipe results
|
||||
* @return a list of recipes with the given result
|
||||
*/
|
||||
public List<Recipe> getRecipesFor(ItemStack result);
|
||||
|
||||
/**
|
||||
* Get an iterator through the list of crafting recipes.
|
||||
*
|
||||
* @return an iterator
|
||||
*/
|
||||
public Iterator<Recipe> recipeIterator();
|
||||
|
||||
/**
|
||||
* Clears the list of crafting recipes.
|
||||
*/
|
||||
public void clearRecipes();
|
||||
|
||||
/**
|
||||
* Resets the list of crafting recipes to the default.
|
||||
*/
|
||||
public void resetRecipes();
|
||||
|
||||
/**
|
||||
* Gets a list of command aliases defined in the server properties.
|
||||
*
|
||||
* @return a map of aliases to command names
|
||||
*/
|
||||
public Map<String, String[]> getCommandAliases();
|
||||
|
||||
/**
|
||||
* Gets the radius, in blocks, around each worlds spawn point to protect.
|
||||
*
|
||||
* @return spawn radius, or 0 if none
|
||||
*/
|
||||
public int getSpawnRadius();
|
||||
|
||||
/**
|
||||
* Sets the radius, in blocks, around each worlds spawn point to protect.
|
||||
*
|
||||
* @param value new spawn radius, or 0 if none
|
||||
*/
|
||||
public void setSpawnRadius(int value);
|
||||
|
||||
/**
|
||||
* Gets whether the Server is in online mode or not.
|
||||
*
|
||||
* @return true if the server authenticates clients, false otherwise
|
||||
*/
|
||||
public boolean getOnlineMode();
|
||||
|
||||
/**
|
||||
* Gets whether this server allows flying or not.
|
||||
*
|
||||
* @return true if the server allows flight, false otherwise
|
||||
*/
|
||||
public boolean getAllowFlight();
|
||||
|
||||
/**
|
||||
* Gets whether the server is in hardcore mode or not.
|
||||
*
|
||||
* @return true if the server mode is hardcore, false otherwise
|
||||
*/
|
||||
public boolean isHardcore();
|
||||
|
||||
/**
|
||||
* Gets whether to use vanilla (false) or exact behaviour (true).
|
||||
*
|
||||
* <ul>
|
||||
* <li>Vanilla behaviour: check for collisions and move the player if
|
||||
* needed.
|
||||
* <li>Exact behaviour: spawn players exactly where they should be.
|
||||
* </ul>
|
||||
*
|
||||
* @return true if exact location locations are used for spawning, false
|
||||
* for vanilla collision detection or otherwise
|
||||
*/
|
||||
public boolean useExactLoginLocation();
|
||||
|
||||
/**
|
||||
* Shutdowns the server, stopping everything.
|
||||
*/
|
||||
public void shutdown();
|
||||
|
||||
/**
|
||||
* Broadcasts the specified message to every user with the given
|
||||
* permission name.
|
||||
*
|
||||
* @param message message to broadcast
|
||||
* @param permission the required permission {@link Permissible
|
||||
* permissibles} must have to receive the broadcast
|
||||
* @return number of message recipients
|
||||
*/
|
||||
public int broadcast(String message, String permission);
|
||||
|
||||
/**
|
||||
* Gets the player by the given name, regardless if they are offline or
|
||||
* online.
|
||||
* <p>
|
||||
* This method may involve a blocking web request to get the UUID for the
|
||||
* given name.
|
||||
* <p>
|
||||
* This will return an object even if the player does not exist. To this
|
||||
* method, all players will exist.
|
||||
*
|
||||
* @deprecated Persistent storage of users should be by UUID as names are no longer
|
||||
* unique past a single session.
|
||||
* @param name the name the player to retrieve
|
||||
* @return an offline player
|
||||
* @see #getOfflinePlayer(java.util.UUID)
|
||||
*/
|
||||
@Deprecated
|
||||
public OfflinePlayer getOfflinePlayer(String name);
|
||||
|
||||
/**
|
||||
* Gets the player by the given UUID, regardless if they are offline or
|
||||
* online.
|
||||
* <p>
|
||||
* This will return an object even if the player does not exist. To this
|
||||
* method, all players will exist.
|
||||
*
|
||||
* @param id the UUID of the player to retrieve
|
||||
* @return an offline player
|
||||
*/
|
||||
public OfflinePlayer getOfflinePlayer(UUID id);
|
||||
|
||||
/**
|
||||
* Gets a set containing all current IPs that are banned.
|
||||
*
|
||||
* @return a set containing banned IP addresses
|
||||
*/
|
||||
public Set<String> getIPBans();
|
||||
|
||||
/**
|
||||
* Bans the specified address from the server.
|
||||
*
|
||||
* @param address the IP address to ban
|
||||
*/
|
||||
public void banIP(String address);
|
||||
|
||||
/**
|
||||
* Unbans the specified address from the server.
|
||||
*
|
||||
* @param address the IP address to unban
|
||||
*/
|
||||
public void unbanIP(String address);
|
||||
|
||||
/**
|
||||
* Gets a set containing all banned players.
|
||||
*
|
||||
* @return a set containing banned players
|
||||
*/
|
||||
public Set<OfflinePlayer> getBannedPlayers();
|
||||
|
||||
/**
|
||||
* Gets a ban list for the supplied type.
|
||||
* <p>
|
||||
* Bans by name are no longer supported and this method will return
|
||||
* null when trying to request them. The replacement is bans by UUID.
|
||||
*
|
||||
* @param type the type of list to fetch, cannot be null
|
||||
* @return a ban list of the specified type
|
||||
*/
|
||||
public BanList getBanList(BanList.Type type);
|
||||
|
||||
/**
|
||||
* Gets a set containing all player operators.
|
||||
*
|
||||
* @return a set containing player operators
|
||||
*/
|
||||
public Set<OfflinePlayer> getOperators();
|
||||
|
||||
/**
|
||||
* Gets the default {@link GameMode} for new players.
|
||||
*
|
||||
* @return the default game mode
|
||||
*/
|
||||
public GameMode getDefaultGameMode();
|
||||
|
||||
/**
|
||||
* Sets the default {@link GameMode} for new players.
|
||||
*
|
||||
* @param mode the new game mode
|
||||
*/
|
||||
public void setDefaultGameMode(GameMode mode);
|
||||
|
||||
/**
|
||||
* Gets a {@link ConsoleCommandSender} that may be used as an input source
|
||||
* for this server.
|
||||
*
|
||||
* @return a console command sender
|
||||
*/
|
||||
public ConsoleCommandSender getConsoleSender();
|
||||
|
||||
/**
|
||||
* Gets the folder that contains all of the various {@link World}s.
|
||||
*
|
||||
* @return folder that contains all worlds
|
||||
*/
|
||||
public File getWorldContainer();
|
||||
|
||||
/**
|
||||
* Gets every player that has ever played on this server.
|
||||
*
|
||||
* @return an array containing all previous players
|
||||
*/
|
||||
public OfflinePlayer[] getOfflinePlayers();
|
||||
|
||||
/**
|
||||
* Gets the {@link Messenger} responsible for this server.
|
||||
*
|
||||
* @return messenger responsible for this server
|
||||
*/
|
||||
public Messenger getMessenger();
|
||||
|
||||
/**
|
||||
* Gets the {@link HelpMap} providing help topics for this server.
|
||||
*
|
||||
* @return a help map for this server
|
||||
*/
|
||||
public HelpMap getHelpMap();
|
||||
|
||||
/**
|
||||
* Creates an empty inventory of the specified type. If the type is {@link
|
||||
* InventoryType#CHEST}, the new inventory has a size of 27; otherwise the
|
||||
* new inventory has the normal size for its type.
|
||||
*
|
||||
* @param owner the holder of the inventory, or null to indicate no holder
|
||||
* @param type the type of inventory to create
|
||||
* @return a new inventory
|
||||
*/
|
||||
Inventory createInventory(InventoryHolder owner, InventoryType type);
|
||||
|
||||
/**
|
||||
* Creates an empty inventory with the specified type and title. If the type
|
||||
* is {@link InventoryType#CHEST}, the new inventory has a size of 27;
|
||||
* otherwise the new inventory has the normal size for its type.<br />
|
||||
* It should be noted that some inventory types do not support titles and
|
||||
* may not render with said titles on the Minecraft client.
|
||||
*
|
||||
* @param owner The holder of the inventory; can be null if there's no holder.
|
||||
* @param type The type of inventory to create.
|
||||
* @param title The title of the inventory, to be displayed when it is viewed.
|
||||
* @return The new inventory.
|
||||
*/
|
||||
Inventory createInventory(InventoryHolder owner, InventoryType type, String title);
|
||||
|
||||
/**
|
||||
* Creates an empty inventory of type {@link InventoryType#CHEST} with the
|
||||
* specified size.
|
||||
*
|
||||
* @param owner the holder of the inventory, or null to indicate no holder
|
||||
* @param size a multiple of 9 as the size of inventory to create
|
||||
* @return a new inventory
|
||||
* @throws IllegalArgumentException if the size is not a multiple of 9
|
||||
*/
|
||||
Inventory createInventory(InventoryHolder owner, int size) throws IllegalArgumentException;
|
||||
|
||||
/**
|
||||
* Creates an empty inventory of type {@link InventoryType#CHEST} with the
|
||||
* specified size and title.
|
||||
*
|
||||
* @param owner the holder of the inventory, or null to indicate no holder
|
||||
* @param size a multiple of 9 as the size of inventory to create
|
||||
* @param title the title of the inventory, displayed when inventory is
|
||||
* viewed
|
||||
* @return a new inventory
|
||||
* @throws IllegalArgumentException if the size is not a multiple of 9
|
||||
*/
|
||||
Inventory createInventory(InventoryHolder owner, int size, String title) throws IllegalArgumentException;
|
||||
|
||||
/**
|
||||
* Gets user-specified limit for number of monsters that can spawn in a
|
||||
* chunk.
|
||||
*
|
||||
* @return the monster spawn limit
|
||||
*/
|
||||
int getMonsterSpawnLimit();
|
||||
|
||||
/**
|
||||
* Gets user-specified limit for number of animals that can spawn in a
|
||||
* chunk.
|
||||
*
|
||||
* @return the animal spawn limit
|
||||
*/
|
||||
int getAnimalSpawnLimit();
|
||||
|
||||
/**
|
||||
* Gets user-specified limit for number of water animals that can spawn in
|
||||
* a chunk.
|
||||
*
|
||||
* @return the water animal spawn limit
|
||||
*/
|
||||
int getWaterAnimalSpawnLimit();
|
||||
|
||||
/**
|
||||
* Gets user-specified limit for number of ambient mobs that can spawn in
|
||||
* a chunk.
|
||||
*
|
||||
* @return the ambient spawn limit
|
||||
*/
|
||||
int getAmbientSpawnLimit();
|
||||
|
||||
/**
|
||||
* Checks the current thread against the expected primary thread for the
|
||||
* server.
|
||||
* <p>
|
||||
* <b>Note:</b> this method should not be used to indicate the current
|
||||
* synchronized state of the runtime. A current thread matching the main
|
||||
* thread indicates that it is synchronized, but a mismatch <b>does not
|
||||
* preclude</b> the same assumption.
|
||||
*
|
||||
* @return true if the current thread matches the expected primary thread,
|
||||
* false otherwise
|
||||
*/
|
||||
boolean isPrimaryThread();
|
||||
|
||||
/**
|
||||
* Gets the message that is displayed on the server list.
|
||||
*
|
||||
* @return the servers MOTD
|
||||
*/
|
||||
String getMotd();
|
||||
|
||||
/**
|
||||
* Gets the default message that is displayed when the server is stopped.
|
||||
*
|
||||
* @return the shutdown message
|
||||
*/
|
||||
String getShutdownMessage();
|
||||
|
||||
/**
|
||||
* Gets the current warning state for the server.
|
||||
*
|
||||
* @return the configured warning state
|
||||
*/
|
||||
public WarningState getWarningState();
|
||||
|
||||
/**
|
||||
* Gets the instance of the item factory (for {@link ItemMeta}).
|
||||
*
|
||||
* @return the item factory
|
||||
* @see ItemFactory
|
||||
*/
|
||||
ItemFactory getItemFactory();
|
||||
|
||||
/**
|
||||
* Gets the instance of the scoreboard manager.
|
||||
* <p>
|
||||
* This will only exist after the first world has loaded.
|
||||
*
|
||||
* @return the scoreboard manager or null if no worlds are loaded.
|
||||
*/
|
||||
ScoreboardManager getScoreboardManager();
|
||||
|
||||
/**
|
||||
* Gets an instance of the server's default server-icon.
|
||||
*
|
||||
* @return the default server-icon; null values may be used by the
|
||||
* implementation to indicate no defined icon, but this behavior is
|
||||
* not guaranteed
|
||||
*/
|
||||
CachedServerIcon getServerIcon();
|
||||
|
||||
/**
|
||||
* Loads an image from a file, and returns a cached image for the specific
|
||||
* server-icon.
|
||||
* <p>
|
||||
* Size and type are implementation defined. An incompatible file is
|
||||
* guaranteed to throw an implementation-defined {@link Exception}.
|
||||
*
|
||||
* @param file the file to load the from
|
||||
* @throws IllegalArgumentException if image is null
|
||||
* @throws Exception if the image does not meet current server server-icon
|
||||
* specifications
|
||||
* @return a cached server-icon that can be used for a {@link
|
||||
* ServerListPingEvent#setServerIcon(CachedServerIcon)}
|
||||
*/
|
||||
CachedServerIcon loadServerIcon(File file) throws IllegalArgumentException, Exception;
|
||||
|
||||
/**
|
||||
* Creates a cached server-icon for the specific image.
|
||||
* <p>
|
||||
* Size and type are implementation defined. An incompatible file is
|
||||
* guaranteed to throw an implementation-defined {@link Exception}.
|
||||
*
|
||||
* @param image the image to use
|
||||
* @throws IllegalArgumentException if image is null
|
||||
* @throws Exception if the image does not meet current server
|
||||
* server-icon specifications
|
||||
* @return a cached server-icon that can be used for a {@link
|
||||
* ServerListPingEvent#setServerIcon(CachedServerIcon)}
|
||||
*/
|
||||
CachedServerIcon loadServerIcon(BufferedImage image) throws IllegalArgumentException, Exception;
|
||||
|
||||
/**
|
||||
* Set the idle kick timeout. Any players idle for the specified amount of
|
||||
* time will be automatically kicked.
|
||||
* <p>
|
||||
* A value of 0 will disable the idle kick timeout.
|
||||
*
|
||||
* @param threshold the idle timeout in minutes
|
||||
*/
|
||||
public void setIdleTimeout(int threshold);
|
||||
|
||||
/**
|
||||
* Gets the idle kick timeout.
|
||||
*
|
||||
* @return the idle timeout in minutes
|
||||
*/
|
||||
public int getIdleTimeout();
|
||||
|
||||
/**
|
||||
* @see UnsafeValues
|
||||
*/
|
||||
@Deprecated
|
||||
UnsafeValues getUnsafe();
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
package org.bukkit;
|
||||
|
||||
/**
|
||||
* Represents the different types of skulls.
|
||||
*/
|
||||
public enum SkullType {
|
||||
SKELETON,
|
||||
WITHER,
|
||||
ZOMBIE,
|
||||
PLAYER,
|
||||
CREEPER;
|
||||
}
|
||||
@@ -0,0 +1,211 @@
|
||||
package org.bukkit;
|
||||
|
||||
/**
|
||||
* An Enum of Sounds the server is able to send to players.
|
||||
* <p>
|
||||
* WARNING: At any time, sounds may be added/removed from this Enum or even
|
||||
* MineCraft itself! There is no guarantee the sounds will play. There is no
|
||||
* guarantee values will not be removed from this Enum. As such, you should
|
||||
* not depend on the ordinal values of this class.
|
||||
*/
|
||||
public enum Sound {
|
||||
AMBIENCE_CAVE,
|
||||
AMBIENCE_RAIN,
|
||||
AMBIENCE_THUNDER,
|
||||
ANVIL_BREAK,
|
||||
ANVIL_LAND,
|
||||
ANVIL_USE,
|
||||
ARROW_HIT,
|
||||
BURP,
|
||||
CHEST_CLOSE,
|
||||
CHEST_OPEN,
|
||||
CLICK,
|
||||
DOOR_CLOSE,
|
||||
DOOR_OPEN,
|
||||
DRINK,
|
||||
EAT,
|
||||
EXPLODE,
|
||||
FALL_BIG,
|
||||
FALL_SMALL,
|
||||
FIRE,
|
||||
FIRE_IGNITE,
|
||||
FIZZ,
|
||||
FUSE,
|
||||
GLASS,
|
||||
HURT_FLESH,
|
||||
ITEM_BREAK,
|
||||
ITEM_PICKUP,
|
||||
LAVA,
|
||||
LAVA_POP,
|
||||
LEVEL_UP,
|
||||
MINECART_BASE,
|
||||
MINECART_INSIDE,
|
||||
NOTE_BASS,
|
||||
NOTE_PIANO,
|
||||
NOTE_BASS_DRUM,
|
||||
NOTE_STICKS,
|
||||
NOTE_BASS_GUITAR,
|
||||
NOTE_SNARE_DRUM,
|
||||
NOTE_PLING,
|
||||
ORB_PICKUP,
|
||||
PISTON_EXTEND,
|
||||
PISTON_RETRACT,
|
||||
PORTAL,
|
||||
PORTAL_TRAVEL,
|
||||
PORTAL_TRIGGER,
|
||||
SHOOT_ARROW,
|
||||
SPLASH,
|
||||
SPLASH2,
|
||||
STEP_GRASS,
|
||||
STEP_GRAVEL,
|
||||
STEP_LADDER,
|
||||
STEP_SAND,
|
||||
STEP_SNOW,
|
||||
STEP_STONE,
|
||||
STEP_WOOD,
|
||||
STEP_WOOL,
|
||||
SWIM,
|
||||
WATER,
|
||||
WOOD_CLICK,
|
||||
// Mob sounds
|
||||
BAT_DEATH,
|
||||
BAT_HURT,
|
||||
BAT_IDLE,
|
||||
BAT_LOOP,
|
||||
BAT_TAKEOFF,
|
||||
BLAZE_BREATH,
|
||||
BLAZE_DEATH,
|
||||
BLAZE_HIT,
|
||||
CAT_HISS,
|
||||
CAT_HIT,
|
||||
CAT_MEOW,
|
||||
CAT_PURR,
|
||||
CAT_PURREOW,
|
||||
CHICKEN_IDLE,
|
||||
CHICKEN_HURT,
|
||||
CHICKEN_EGG_POP,
|
||||
CHICKEN_WALK,
|
||||
COW_IDLE,
|
||||
COW_HURT,
|
||||
COW_WALK,
|
||||
CREEPER_HISS,
|
||||
CREEPER_DEATH,
|
||||
ENDERDRAGON_DEATH,
|
||||
ENDERDRAGON_GROWL,
|
||||
ENDERDRAGON_HIT,
|
||||
ENDERDRAGON_WINGS,
|
||||
ENDERMAN_DEATH,
|
||||
ENDERMAN_HIT,
|
||||
ENDERMAN_IDLE,
|
||||
ENDERMAN_TELEPORT,
|
||||
ENDERMAN_SCREAM,
|
||||
ENDERMAN_STARE,
|
||||
GHAST_SCREAM,
|
||||
GHAST_SCREAM2,
|
||||
GHAST_CHARGE,
|
||||
GHAST_DEATH,
|
||||
GHAST_FIREBALL,
|
||||
GHAST_MOAN,
|
||||
IRONGOLEM_DEATH,
|
||||
IRONGOLEM_HIT,
|
||||
IRONGOLEM_THROW,
|
||||
IRONGOLEM_WALK,
|
||||
MAGMACUBE_WALK,
|
||||
MAGMACUBE_WALK2,
|
||||
MAGMACUBE_JUMP,
|
||||
PIG_IDLE,
|
||||
PIG_DEATH,
|
||||
PIG_WALK,
|
||||
SHEEP_IDLE,
|
||||
SHEEP_SHEAR,
|
||||
SHEEP_WALK,
|
||||
SILVERFISH_HIT,
|
||||
SILVERFISH_KILL,
|
||||
SILVERFISH_IDLE,
|
||||
SILVERFISH_WALK,
|
||||
SKELETON_IDLE,
|
||||
SKELETON_DEATH,
|
||||
SKELETON_HURT,
|
||||
SKELETON_WALK,
|
||||
SLIME_ATTACK,
|
||||
SLIME_WALK,
|
||||
SLIME_WALK2,
|
||||
SPIDER_IDLE,
|
||||
SPIDER_DEATH,
|
||||
SPIDER_WALK,
|
||||
WITHER_DEATH,
|
||||
WITHER_HURT,
|
||||
WITHER_IDLE,
|
||||
WITHER_SHOOT,
|
||||
WITHER_SPAWN,
|
||||
WOLF_BARK,
|
||||
WOLF_DEATH,
|
||||
WOLF_GROWL,
|
||||
WOLF_HOWL,
|
||||
WOLF_HURT,
|
||||
WOLF_PANT,
|
||||
WOLF_SHAKE,
|
||||
WOLF_WALK,
|
||||
WOLF_WHINE,
|
||||
ZOMBIE_METAL,
|
||||
ZOMBIE_WOOD,
|
||||
ZOMBIE_WOODBREAK,
|
||||
ZOMBIE_IDLE,
|
||||
ZOMBIE_DEATH,
|
||||
ZOMBIE_HURT,
|
||||
ZOMBIE_INFECT,
|
||||
ZOMBIE_UNFECT,
|
||||
ZOMBIE_REMEDY,
|
||||
ZOMBIE_WALK,
|
||||
ZOMBIE_PIG_IDLE,
|
||||
ZOMBIE_PIG_ANGRY,
|
||||
ZOMBIE_PIG_DEATH,
|
||||
ZOMBIE_PIG_HURT,
|
||||
// Dig Sounds
|
||||
DIG_WOOL,
|
||||
DIG_GRASS,
|
||||
DIG_GRAVEL,
|
||||
DIG_SAND,
|
||||
DIG_SNOW,
|
||||
DIG_STONE,
|
||||
DIG_WOOD,
|
||||
// Fireworks
|
||||
FIREWORK_BLAST,
|
||||
FIREWORK_BLAST2,
|
||||
FIREWORK_LARGE_BLAST,
|
||||
FIREWORK_LARGE_BLAST2,
|
||||
FIREWORK_TWINKLE,
|
||||
FIREWORK_TWINKLE2,
|
||||
FIREWORK_LAUNCH,
|
||||
SUCCESSFUL_HIT,
|
||||
// Horses
|
||||
HORSE_ANGRY,
|
||||
HORSE_ARMOR,
|
||||
HORSE_BREATHE,
|
||||
HORSE_DEATH,
|
||||
HORSE_GALLOP,
|
||||
HORSE_HIT,
|
||||
HORSE_IDLE,
|
||||
HORSE_JUMP,
|
||||
HORSE_LAND,
|
||||
HORSE_SADDLE,
|
||||
HORSE_SOFT,
|
||||
HORSE_WOOD,
|
||||
DONKEY_ANGRY,
|
||||
DONKEY_DEATH,
|
||||
DONKEY_HIT,
|
||||
DONKEY_IDLE,
|
||||
HORSE_SKELETON_DEATH,
|
||||
HORSE_SKELETON_HIT,
|
||||
HORSE_SKELETON_IDLE,
|
||||
HORSE_ZOMBIE_DEATH,
|
||||
HORSE_ZOMBIE_HIT,
|
||||
HORSE_ZOMBIE_IDLE,
|
||||
// Villager
|
||||
VILLAGER_DEATH,
|
||||
VILLAGER_HAGGLE,
|
||||
VILLAGER_HIT,
|
||||
VILLAGER_IDLE,
|
||||
VILLAGER_NO,
|
||||
VILLAGER_YES,
|
||||
}
|
||||
@@ -0,0 +1,108 @@
|
||||
package org.bukkit;
|
||||
|
||||
/**
|
||||
* Represents a countable statistic, which is tracked by the server.
|
||||
*/
|
||||
public enum Statistic {
|
||||
DAMAGE_DEALT,
|
||||
DAMAGE_TAKEN,
|
||||
DEATHS,
|
||||
MOB_KILLS,
|
||||
PLAYER_KILLS,
|
||||
FISH_CAUGHT,
|
||||
ANIMALS_BRED,
|
||||
TREASURE_FISHED,
|
||||
JUNK_FISHED,
|
||||
LEAVE_GAME,
|
||||
JUMP,
|
||||
DROP,
|
||||
PLAY_ONE_TICK,
|
||||
WALK_ONE_CM,
|
||||
SWIM_ONE_CM,
|
||||
FALL_ONE_CM,
|
||||
CLIMB_ONE_CM,
|
||||
FLY_ONE_CM,
|
||||
DIVE_ONE_CM,
|
||||
MINECART_ONE_CM,
|
||||
BOAT_ONE_CM,
|
||||
PIG_ONE_CM,
|
||||
HORSE_ONE_CM,
|
||||
MINE_BLOCK(Type.BLOCK),
|
||||
USE_ITEM(Type.ITEM),
|
||||
BREAK_ITEM(Type.ITEM),
|
||||
CRAFT_ITEM(Type.ITEM),
|
||||
KILL_ENTITY(Type.ENTITY),
|
||||
ENTITY_KILLED_BY(Type.ENTITY);
|
||||
|
||||
private final Type type;
|
||||
|
||||
private Statistic() {
|
||||
this(Type.UNTYPED);
|
||||
}
|
||||
|
||||
private Statistic(Type type) {
|
||||
this.type = type;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the type of this statistic.
|
||||
*
|
||||
* @return the type of this statistic
|
||||
*/
|
||||
public Type getType() {
|
||||
return type;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if this is a substatistic.
|
||||
* <p>
|
||||
* A substatistic exists en masse for each block, item, or entitytype, depending on
|
||||
* {@link #getType()}.
|
||||
* <p>
|
||||
* This is a redundant method and equivalent to checking
|
||||
* <code>getType() != Type.UNTYPED</code>
|
||||
*
|
||||
* @return true if this is a substatistic
|
||||
*/
|
||||
public boolean isSubstatistic() {
|
||||
return type != Type.UNTYPED;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if this is a substatistic dealing with blocks.
|
||||
* <p>
|
||||
* This is a redundant method and equivalent to checking
|
||||
* <code>getType() == Type.BLOCK</code>
|
||||
*
|
||||
* @return true if this deals with blocks
|
||||
*/
|
||||
public boolean isBlock() {
|
||||
return type == Type.BLOCK;
|
||||
}
|
||||
|
||||
/**
|
||||
* The type of statistic.
|
||||
*
|
||||
*/
|
||||
public enum Type {
|
||||
/**
|
||||
* Statistics of this type do not require a qualifier.
|
||||
*/
|
||||
UNTYPED,
|
||||
|
||||
/**
|
||||
* Statistics of this type require an Item Material qualifier.
|
||||
*/
|
||||
ITEM,
|
||||
|
||||
/**
|
||||
* Statistics of this type require a Block Material qualifier.
|
||||
*/
|
||||
BLOCK,
|
||||
|
||||
/**
|
||||
* Statistics of this type require an EntityType qualifier.
|
||||
*/
|
||||
ENTITY;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,94 @@
|
||||
package org.bukkit;
|
||||
|
||||
/**
|
||||
* The Travel Agent handles the creation and the research of Nether and End
|
||||
* portals when Entities try to use one.
|
||||
* <p>
|
||||
* It is used in {@link org.bukkit.event.entity.EntityPortalEvent} and in
|
||||
* {@link org.bukkit.event.player.PlayerPortalEvent} to help developers
|
||||
* reproduce and/or modify Vanilla behaviour.
|
||||
*/
|
||||
public interface TravelAgent {
|
||||
|
||||
/**
|
||||
* Set the Block radius to search in for available portals.
|
||||
*
|
||||
* @param radius the radius in which to search for a portal from the
|
||||
* location
|
||||
* @return this travel agent
|
||||
*/
|
||||
public TravelAgent setSearchRadius(int radius);
|
||||
|
||||
/**
|
||||
* Gets the search radius value for finding an available portal.
|
||||
*
|
||||
* @return the currently set search radius
|
||||
*/
|
||||
public int getSearchRadius();
|
||||
|
||||
/**
|
||||
* Sets the maximum radius from the given location to create a portal.
|
||||
*
|
||||
* @param radius the radius in which to create a portal from the location
|
||||
* @return this travel agent
|
||||
*/
|
||||
public TravelAgent setCreationRadius(int radius);
|
||||
|
||||
/**
|
||||
* Gets the maximum radius from the given location to create a portal.
|
||||
*
|
||||
* @return the currently set creation radius
|
||||
*/
|
||||
public int getCreationRadius();
|
||||
|
||||
/**
|
||||
* Returns whether the TravelAgent will attempt to create a destination
|
||||
* portal or not.
|
||||
*
|
||||
* @return whether the TravelAgent should create a destination portal or
|
||||
* not
|
||||
*/
|
||||
public boolean getCanCreatePortal();
|
||||
|
||||
/**
|
||||
* Sets whether the TravelAgent should attempt to create a destination
|
||||
* portal or not.
|
||||
*
|
||||
* @param create Sets whether the TravelAgent should create a destination
|
||||
* portal or not
|
||||
*/
|
||||
public void setCanCreatePortal(boolean create);
|
||||
|
||||
/**
|
||||
* Attempt to find a portal near the given location, if a portal is not
|
||||
* found it will attempt to create one.
|
||||
*
|
||||
* @param location the location where the search for a portal should begin
|
||||
* @return the location of a portal which has been found or returns the
|
||||
* location passed to the method if unsuccessful
|
||||
* @see #createPortal(Location)
|
||||
*/
|
||||
public Location findOrCreate(Location location);
|
||||
|
||||
/**
|
||||
* Attempt to find a portal near the given location.
|
||||
*
|
||||
* @param location the desired location of the portal
|
||||
* @return the location of the nearest portal to the location
|
||||
*/
|
||||
public Location findPortal(Location location);
|
||||
|
||||
/**
|
||||
* Attempt to create a portal near the given location.
|
||||
* <p>
|
||||
* In the case of a Nether portal teleportation, this will attempt to
|
||||
* create a Nether portal.
|
||||
* <p>
|
||||
* In the case of an Ender portal teleportation, this will (re-)create the
|
||||
* obsidian platform and clean blocks above it.
|
||||
*
|
||||
* @param location the desired location of the portal
|
||||
* @return true if a portal was successfully created
|
||||
*/
|
||||
public boolean createPortal(Location location);
|
||||
}
|
||||
@@ -0,0 +1,74 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.util.Map;
|
||||
|
||||
import com.google.common.collect.Maps;
|
||||
|
||||
/**
|
||||
* Represents the different species of trees regardless of size.
|
||||
*/
|
||||
public enum TreeSpecies {
|
||||
|
||||
/**
|
||||
* Represents the common tree species.
|
||||
*/
|
||||
GENERIC(0x0),
|
||||
/**
|
||||
* Represents the darker barked/leaved tree species.
|
||||
*/
|
||||
REDWOOD(0x1),
|
||||
/**
|
||||
* Represents birches.
|
||||
*/
|
||||
BIRCH(0x2),
|
||||
/**
|
||||
* Represents jungle trees.
|
||||
*/
|
||||
JUNGLE(0x3),
|
||||
/**
|
||||
* Represents acacia trees.
|
||||
*/
|
||||
ACACIA(0x4),
|
||||
/**
|
||||
* Represents dark oak trees.
|
||||
*/
|
||||
DARK_OAK(0x5),
|
||||
;
|
||||
|
||||
private final byte data;
|
||||
private final static Map<Byte, TreeSpecies> BY_DATA = Maps.newHashMap();
|
||||
|
||||
private TreeSpecies(final int data) {
|
||||
this.data = (byte) data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the associated data value representing this species
|
||||
*
|
||||
* @return A byte containing the data value of this tree species
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public byte getData() {
|
||||
return data;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the TreeSpecies with the given data value
|
||||
*
|
||||
* @param data Data value to fetch
|
||||
* @return The {@link TreeSpecies} representing the given value, or null
|
||||
* if it doesn't exist
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public static TreeSpecies getByData(final byte data) {
|
||||
return BY_DATA.get(data);
|
||||
}
|
||||
|
||||
static {
|
||||
for (TreeSpecies species : values()) {
|
||||
BY_DATA.put(species.data, species);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
package org.bukkit;
|
||||
|
||||
/**
|
||||
* Tree and organic structure types.
|
||||
*/
|
||||
public enum TreeType {
|
||||
|
||||
/**
|
||||
* Regular tree, no branches
|
||||
*/
|
||||
TREE,
|
||||
/**
|
||||
* Regular tree, extra tall with branches
|
||||
*/
|
||||
BIG_TREE,
|
||||
/**
|
||||
* Redwood tree, shaped like a pine tree
|
||||
*/
|
||||
REDWOOD,
|
||||
/**
|
||||
* Tall redwood tree with just a few leaves at the top
|
||||
*/
|
||||
TALL_REDWOOD,
|
||||
/**
|
||||
* Birch tree
|
||||
*/
|
||||
BIRCH,
|
||||
/**
|
||||
* Standard jungle tree; 4 blocks wide and tall
|
||||
*/
|
||||
JUNGLE,
|
||||
/**
|
||||
* Smaller jungle tree; 1 block wide
|
||||
*/
|
||||
SMALL_JUNGLE,
|
||||
/**
|
||||
* Jungle tree with cocoa plants; 1 block wide
|
||||
*/
|
||||
COCOA_TREE,
|
||||
/**
|
||||
* Small bush that grows in the jungle
|
||||
*/
|
||||
JUNGLE_BUSH,
|
||||
/**
|
||||
* Big red mushroom; short and fat
|
||||
*/
|
||||
RED_MUSHROOM,
|
||||
/**
|
||||
* Big brown mushroom; tall and umbrella-like
|
||||
*/
|
||||
BROWN_MUSHROOM,
|
||||
/**
|
||||
* Swamp tree (regular with vines on the side)
|
||||
*/
|
||||
SWAMP,
|
||||
/**
|
||||
* Acacia tree.
|
||||
*/
|
||||
ACACIA,
|
||||
/**
|
||||
* Dark Oak tree.
|
||||
*/
|
||||
DARK_OAK,
|
||||
/**
|
||||
* Mega redwood tree; 4 blocks wide and tall
|
||||
*/
|
||||
MEGA_REDWOOD,
|
||||
/**
|
||||
* Tall birch tree
|
||||
*/
|
||||
TALL_BIRCH,
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
|
||||
/**
|
||||
* This interface provides value conversions that may be specific to a
|
||||
* runtime, or have arbitrary meaning (read: magic values).
|
||||
* <p>
|
||||
* Their existence and behavior is not guaranteed across future versions. They
|
||||
* may be poorly named, throw exceptions, have misleading parameters, or any
|
||||
* other bad programming practice.
|
||||
* <p>
|
||||
* This interface is unsupported and only for internal use.
|
||||
*
|
||||
* @deprecated Unsupported & internal use only
|
||||
*/
|
||||
@Deprecated
|
||||
public interface UnsafeValues {
|
||||
|
||||
Material getMaterialFromInternalName(String name);
|
||||
|
||||
List<String> tabCompleteInternalMaterialName(String token, List<String> completions);
|
||||
|
||||
ItemStack modifyItemStack(ItemStack stack, String arguments);
|
||||
|
||||
Statistic getStatisticFromInternalName(String name);
|
||||
|
||||
Achievement getAchievementFromInternalName(String name);
|
||||
|
||||
List<String> tabCompleteInternalStatisticOrAchievementName(String token, List<String> completions);
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
|
||||
/**
|
||||
* This annotation indicates a method (and sometimes constructor) will chain
|
||||
* its internal operations.
|
||||
* <p>
|
||||
* This is solely meant for identifying methods that don't need to be
|
||||
* overridden / handled manually.
|
||||
*/
|
||||
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD})
|
||||
@Retention(RetentionPolicy.SOURCE)
|
||||
public @interface Utility {
|
||||
}
|
||||
@@ -0,0 +1,109 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.lang.annotation.ElementType;
|
||||
import java.lang.annotation.Retention;
|
||||
import java.lang.annotation.RetentionPolicy;
|
||||
import java.lang.annotation.Target;
|
||||
import java.util.Map;
|
||||
|
||||
import com.google.common.collect.ImmutableMap;
|
||||
|
||||
/**
|
||||
* This designates the warning state for a specific item.
|
||||
* <p>
|
||||
* When the server settings dictate 'default' warnings, warnings are printed
|
||||
* if the {@link #value()} is true.
|
||||
*/
|
||||
@Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.TYPE})
|
||||
@Retention(RetentionPolicy.RUNTIME)
|
||||
public @interface Warning {
|
||||
|
||||
/**
|
||||
* This represents the states that server verbose for warnings may be.
|
||||
*/
|
||||
public enum WarningState {
|
||||
|
||||
/**
|
||||
* Indicates all warnings should be printed for deprecated items.
|
||||
*/
|
||||
ON,
|
||||
/**
|
||||
* Indicates no warnings should be printed for deprecated items.
|
||||
*/
|
||||
OFF,
|
||||
/**
|
||||
* Indicates each warning would default to the configured {@link
|
||||
* Warning} annotation, or always if annotation not found.
|
||||
*/
|
||||
DEFAULT;
|
||||
|
||||
private static final Map<String, WarningState> values = ImmutableMap.<String,WarningState>builder()
|
||||
.put("off", OFF)
|
||||
.put("false", OFF)
|
||||
.put("f", OFF)
|
||||
.put("no", OFF)
|
||||
.put("n", OFF)
|
||||
.put("on", ON)
|
||||
.put("true", ON)
|
||||
.put("t", ON)
|
||||
.put("yes", ON)
|
||||
.put("y", ON)
|
||||
.put("", DEFAULT)
|
||||
.put("d", DEFAULT)
|
||||
.put("default", DEFAULT)
|
||||
.build();
|
||||
|
||||
/**
|
||||
* This method checks the provided warning should be printed for this
|
||||
* state
|
||||
*
|
||||
* @param warning The warning annotation added to a deprecated item
|
||||
* @return <ul>
|
||||
* <li>ON is always True
|
||||
* <li>OFF is always false
|
||||
* <li>DEFAULT is false if and only if annotation is not null and
|
||||
* specifies false for {@link Warning#value()}, true otherwise.
|
||||
* </ul>
|
||||
*/
|
||||
public boolean printFor(Warning warning) {
|
||||
if (this == DEFAULT) {
|
||||
return warning == null || warning.value();
|
||||
}
|
||||
return this == ON;
|
||||
}
|
||||
|
||||
/**
|
||||
* This method returns the corresponding warning state for the given
|
||||
* string value.
|
||||
*
|
||||
* @param value The string value to check
|
||||
* @return {@link #DEFAULT} if not found, or the respective
|
||||
* WarningState
|
||||
*/
|
||||
public static WarningState value(final String value) {
|
||||
if (value == null) {
|
||||
return DEFAULT;
|
||||
}
|
||||
WarningState state = values.get(value.toLowerCase());
|
||||
if (state == null) {
|
||||
return DEFAULT;
|
||||
}
|
||||
return state;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This sets if the deprecation warnings when registering events gets
|
||||
* printed when the setting is in the default state.
|
||||
*
|
||||
* @return false normally, or true to encourage warning printout
|
||||
*/
|
||||
boolean value() default false;
|
||||
|
||||
/**
|
||||
* This can provide detailed information on why the event is deprecated.
|
||||
*
|
||||
* @return The reason an event is deprecated
|
||||
*/
|
||||
String reason() default "";
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
package org.bukkit;
|
||||
|
||||
/**
|
||||
* An enum of all current weather types
|
||||
*/
|
||||
public enum WeatherType {
|
||||
|
||||
/**
|
||||
* Raining or snowing depending on biome.
|
||||
*/
|
||||
DOWNFALL,
|
||||
/**
|
||||
* Clear weather, clouds but no rain.
|
||||
*/
|
||||
CLEAR,
|
||||
;
|
||||
}
|
||||
File diff suppressed because it is too large.
Load diff
@@ -0,0 +1,295 @@
|
||||
package org.bukkit;
|
||||
|
||||
import java.util.Random;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.generator.ChunkGenerator;
|
||||
import org.bukkit.plugin.Plugin;
|
||||
|
||||
/**
|
||||
* Represents various types of options that may be used to create a world.
|
||||
*/
|
||||
public class WorldCreator {
|
||||
private final String name;
|
||||
private long seed;
|
||||
private World.Environment environment = World.Environment.NORMAL;
|
||||
private ChunkGenerator generator = null;
|
||||
private WorldType type = WorldType.NORMAL;
|
||||
private boolean generateStructures = true;
|
||||
|
||||
/**
|
||||
* Creates an empty WorldCreationOptions for the given world name
|
||||
*
|
||||
* @param name Name of the world that will be created
|
||||
*/
|
||||
public WorldCreator(String name) {
|
||||
if (name == null) {
|
||||
throw new IllegalArgumentException("World name cannot be null");
|
||||
}
|
||||
|
||||
this.name = name;
|
||||
this.seed = (new Random()).nextLong();
|
||||
}
|
||||
|
||||
/**
|
||||
* Copies the options from the specified world
|
||||
*
|
||||
* @param world World to copy options from
|
||||
* @return This object, for chaining
|
||||
*/
|
||||
public WorldCreator copy(World world) {
|
||||
if (world == null) {
|
||||
throw new IllegalArgumentException("World cannot be null");
|
||||
}
|
||||
|
||||
seed = world.getSeed();
|
||||
environment = world.getEnvironment();
|
||||
generator = world.getGenerator();
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Copies the options from the specified {@link WorldCreator}
|
||||
*
|
||||
* @param creator World creator to copy options from
|
||||
* @return This object, for chaining
|
||||
*/
|
||||
public WorldCreator copy(WorldCreator creator) {
|
||||
if (creator == null) {
|
||||
throw new IllegalArgumentException("Creator cannot be null");
|
||||
}
|
||||
|
||||
seed = creator.seed();
|
||||
environment = creator.environment();
|
||||
generator = creator.generator();
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the name of the world that is to be loaded or created.
|
||||
*
|
||||
* @return World name
|
||||
*/
|
||||
public String name() {
|
||||
return name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the seed that will be used to create this world
|
||||
*
|
||||
* @return World seed
|
||||
*/
|
||||
public long seed() {
|
||||
return seed;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the seed that will be used to create this world
|
||||
*
|
||||
* @param seed World seed
|
||||
* @return This object, for chaining
|
||||
*/
|
||||
public WorldCreator seed(long seed) {
|
||||
this.seed = seed;
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the environment that will be used to create or load the world
|
||||
*
|
||||
* @return World environment
|
||||
*/
|
||||
public World.Environment environment() {
|
||||
return environment;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the environment that will be used to create or load the world
|
||||
*
|
||||
* @param env World environment
|
||||
* @return This object, for chaining
|
||||
*/
|
||||
public WorldCreator environment(World.Environment env) {
|
||||
this.environment = env;
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the type of the world that will be created or loaded
|
||||
*
|
||||
* @return World type
|
||||
*/
|
||||
public WorldType type() {
|
||||
return type;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the type of the world that will be created or loaded
|
||||
*
|
||||
* @param type World type
|
||||
* @return This object, for chaining
|
||||
*/
|
||||
public WorldCreator type(WorldType type) {
|
||||
this.type = type;
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the generator that will be used to create or load the world.
|
||||
* <p>
|
||||
* This may be null, in which case the "natural" generator for this
|
||||
* environment will be used.
|
||||
*
|
||||
* @return Chunk generator
|
||||
*/
|
||||
public ChunkGenerator generator() {
|
||||
return generator;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the generator that will be used to create or load the world.
|
||||
* <p>
|
||||
* This may be null, in which case the "natural" generator for this
|
||||
* environment will be used.
|
||||
*
|
||||
* @param generator Chunk generator
|
||||
* @return This object, for chaining
|
||||
*/
|
||||
public WorldCreator generator(ChunkGenerator generator) {
|
||||
this.generator = generator;
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the generator that will be used to create or load the world.
|
||||
* <p>
|
||||
* This may be null, in which case the "natural" generator for this
|
||||
* environment will be used.
|
||||
* <p>
|
||||
* If the generator cannot be found for the given name, the natural
|
||||
* environment generator will be used instead and a warning will be
|
||||
* printed to the console.
|
||||
*
|
||||
* @param generator Name of the generator to use, in "plugin:id" notation
|
||||
* @return This object, for chaining
|
||||
*/
|
||||
public WorldCreator generator(String generator) {
|
||||
this.generator = getGeneratorForName(name, generator, Bukkit.getConsoleSender());
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the generator that will be used to create or load the world.
|
||||
* <p>
|
||||
* This may be null, in which case the "natural" generator for this
|
||||
* environment will be used.
|
||||
* <p>
|
||||
* If the generator cannot be found for the given name, the natural
|
||||
* environment generator will be used instead and a warning will be
|
||||
* printed to the specified output
|
||||
*
|
||||
* @param generator Name of the generator to use, in "plugin:id" notation
|
||||
* @param output {@link CommandSender} that will receive any error
|
||||
* messages
|
||||
* @return This object, for chaining
|
||||
*/
|
||||
public WorldCreator generator(String generator, CommandSender output) {
|
||||
this.generator = getGeneratorForName(name, generator, output);
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets whether or not worlds created or loaded with this creator will
|
||||
* have structures.
|
||||
*
|
||||
* @param generate Whether to generate structures
|
||||
* @return This object, for chaining
|
||||
*/
|
||||
public WorldCreator generateStructures(boolean generate) {
|
||||
this.generateStructures = generate;
|
||||
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets whether or not structures will be generated in the world.
|
||||
*
|
||||
* @return True if structures will be generated
|
||||
*/
|
||||
public boolean generateStructures() {
|
||||
return generateStructures;
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a world with the specified options.
|
||||
* <p>
|
||||
* If the world already exists, it will be loaded from disk and some
|
||||
* options may be ignored.
|
||||
*
|
||||
* @return Newly created or loaded world
|
||||
*/
|
||||
public World createWorld() {
|
||||
return Bukkit.createWorld(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new {@link WorldCreator} for the given world name
|
||||
*
|
||||
* @param name Name of the world to load or create
|
||||
* @return Resulting WorldCreator
|
||||
*/
|
||||
public static WorldCreator name(String name) {
|
||||
return new WorldCreator(name);
|
||||
}
|
||||
|
||||
/**
|
||||
* Attempts to get the {@link ChunkGenerator} with the given name.
|
||||
* <p>
|
||||
* If the generator is not found, null will be returned and a message will
|
||||
* be printed to the specified {@link CommandSender} explaining why.
|
||||
* <p>
|
||||
* The name must be in the "plugin:id" notation, or optionally just
|
||||
* "plugin", where "plugin" is the safe-name of a plugin and "id" is an
|
||||
* optional unique identifier for the generator you wish to request from
|
||||
* the plugin.
|
||||
*
|
||||
* @param world Name of the world this will be used for
|
||||
* @param name Name of the generator to retrieve
|
||||
* @param output Where to output if errors are present
|
||||
* @return Resulting generator, or null
|
||||
*/
|
||||
public static ChunkGenerator getGeneratorForName(String world, String name, CommandSender output) {
|
||||
ChunkGenerator result = null;
|
||||
|
||||
if (world == null) {
|
||||
throw new IllegalArgumentException("World name must be specified");
|
||||
}
|
||||
|
||||
if (output == null) {
|
||||
output = Bukkit.getConsoleSender();
|
||||
}
|
||||
|
||||
if (name != null) {
|
||||
String[] split = name.split(":", 2);
|
||||
String id = (split.length > 1) ? split[1] : null;
|
||||
Plugin plugin = Bukkit.getPluginManager().getPlugin(split[0]);
|
||||
|
||||
if (plugin == null) {
|
||||
output.sendMessage("Could not set generator for world '" + world + "': Plugin '" + split[0] + "' does not exist");
|
||||
} else if (!plugin.isEnabled()) {
|
||||
output.sendMessage("Could not set generator for world '" + world + "': Plugin '" + plugin.getDescription().getFullName() + "' is not enabled");
|
||||
} else {
|
||||
result = plugin.getDefaultWorldGenerator(world, id);
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
package org.bukkit;
|
||||
|
||||
import com.google.common.collect.Maps;
|
||||
import java.util.Map;
|
||||
|
||||
/**
|
||||
* Represents various types of worlds that may exist
|
||||
*/
|
||||
public enum WorldType {
|
||||
NORMAL("DEFAULT"),
|
||||
FLAT("FLAT"),
|
||||
VERSION_1_1("DEFAULT_1_1"),
|
||||
LARGE_BIOMES("LARGEBIOMES"),
|
||||
AMPLIFIED("AMPLIFIED");
|
||||
|
||||
private final static Map<String, WorldType> BY_NAME = Maps.newHashMap();
|
||||
private final String name;
|
||||
|
||||
private WorldType(String name) {
|
||||
this.name = name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the name of this WorldType
|
||||
*
|
||||
* @return Name of this type
|
||||
*/
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a Worldtype by its name
|
||||
*
|
||||
* @param name Name of the WorldType to get
|
||||
* @return Requested WorldType, or null if not found
|
||||
*/
|
||||
public static WorldType getByName(String name) {
|
||||
return BY_NAME.get(name.toUpperCase());
|
||||
}
|
||||
|
||||
static {
|
||||
for (WorldType type : values()) {
|
||||
BY_NAME.put(type.name, type);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
package org.bukkit.block;
|
||||
|
||||
import org.bukkit.inventory.InventoryHolder;
|
||||
|
||||
/**
|
||||
* Represents a beacon.
|
||||
*/
|
||||
public interface Beacon extends BlockState, InventoryHolder {
|
||||
}
|
||||
@@ -0,0 +1,68 @@
|
||||
package org.bukkit.block;
|
||||
|
||||
/**
|
||||
* Holds all accepted Biomes in the default server
|
||||
*/
|
||||
public enum Biome {
|
||||
SWAMPLAND,
|
||||
FOREST,
|
||||
TAIGA,
|
||||
DESERT,
|
||||
PLAINS,
|
||||
HELL,
|
||||
SKY,
|
||||
OCEAN,
|
||||
RIVER,
|
||||
EXTREME_HILLS,
|
||||
FROZEN_OCEAN,
|
||||
FROZEN_RIVER,
|
||||
ICE_PLAINS,
|
||||
ICE_MOUNTAINS,
|
||||
MUSHROOM_ISLAND,
|
||||
MUSHROOM_SHORE,
|
||||
BEACH,
|
||||
DESERT_HILLS,
|
||||
FOREST_HILLS,
|
||||
TAIGA_HILLS,
|
||||
SMALL_MOUNTAINS,
|
||||
JUNGLE,
|
||||
JUNGLE_HILLS,
|
||||
JUNGLE_EDGE,
|
||||
DEEP_OCEAN,
|
||||
STONE_BEACH,
|
||||
COLD_BEACH,
|
||||
BIRCH_FOREST,
|
||||
BIRCH_FOREST_HILLS,
|
||||
ROOFED_FOREST,
|
||||
COLD_TAIGA,
|
||||
COLD_TAIGA_HILLS,
|
||||
MEGA_TAIGA,
|
||||
MEGA_TAIGA_HILLS,
|
||||
EXTREME_HILLS_PLUS,
|
||||
SAVANNA,
|
||||
SAVANNA_PLATEAU,
|
||||
MESA,
|
||||
MESA_PLATEAU_FOREST,
|
||||
MESA_PLATEAU,
|
||||
SUNFLOWER_PLAINS,
|
||||
DESERT_MOUNTAINS,
|
||||
FLOWER_FOREST,
|
||||
TAIGA_MOUNTAINS,
|
||||
SWAMPLAND_MOUNTAINS,
|
||||
ICE_PLAINS_SPIKES,
|
||||
JUNGLE_MOUNTAINS,
|
||||
JUNGLE_EDGE_MOUNTAINS,
|
||||
COLD_TAIGA_MOUNTAINS,
|
||||
SAVANNA_MOUNTAINS,
|
||||
SAVANNA_PLATEAU_MOUNTAINS,
|
||||
MESA_BRYCE,
|
||||
MESA_PLATEAU_FOREST_MOUNTAINS,
|
||||
MESA_PLATEAU_MOUNTAINS,
|
||||
BIRCH_FOREST_MOUNTAINS,
|
||||
BIRCH_FOREST_HILLS_MOUNTAINS,
|
||||
ROOFED_FOREST_MOUNTAINS,
|
||||
MEGA_SPRUCE_TAIGA,
|
||||
EXTREME_HILLS_MOUNTAINS,
|
||||
EXTREME_HILLS_PLUS_MOUNTAINS,
|
||||
MEGA_SPRUCE_TAIGA_HILLS,
|
||||
}
|
||||
@@ -0,0 +1,384 @@
|
||||
package org.bukkit.block;
|
||||
|
||||
import java.util.Collection;
|
||||
|
||||
import org.bukkit.Chunk;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.World;
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
import org.bukkit.metadata.Metadatable;
|
||||
|
||||
/**
|
||||
* Represents a block. This is a live object, and only one Block may exist for
|
||||
* any given location in a world. The state of the block may change
|
||||
* concurrently to your own handling of it; use block.getState() to get a
|
||||
* snapshot state of a block which will not be modified.
|
||||
*/
|
||||
public interface Block extends Metadatable {
|
||||
|
||||
/**
|
||||
* Gets the metadata for this block
|
||||
*
|
||||
* @return block specific metadata
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
byte getData();
|
||||
|
||||
/**
|
||||
* Gets the block at the given offsets
|
||||
*
|
||||
* @param modX X-coordinate offset
|
||||
* @param modY Y-coordinate offset
|
||||
* @param modZ Z-coordinate offset
|
||||
* @return Block at the given offsets
|
||||
*/
|
||||
Block getRelative(int modX, int modY, int modZ);
|
||||
|
||||
/**
|
||||
* Gets the block at the given face
|
||||
* <p>
|
||||
* This method is equal to getRelative(face, 1)
|
||||
*
|
||||
* @param face Face of this block to return
|
||||
* @return Block at the given face
|
||||
* @see #getRelative(BlockFace, int)
|
||||
*/
|
||||
Block getRelative(BlockFace face);
|
||||
|
||||
/**
|
||||
* Gets the block at the given distance of the given face
|
||||
* <p>
|
||||
* For example, the following method places water at 100,102,100; two
|
||||
* blocks above 100,100,100.
|
||||
*
|
||||
* <pre>
|
||||
* Block block = world.getBlockAt(100, 100, 100);
|
||||
* Block shower = block.getRelative(BlockFace.UP, 2);
|
||||
* shower.setType(Material.WATER);
|
||||
* </pre>
|
||||
*
|
||||
* @param face Face of this block to return
|
||||
* @param distance Distance to get the block at
|
||||
* @return Block at the given face
|
||||
*/
|
||||
Block getRelative(BlockFace face, int distance);
|
||||
|
||||
/**
|
||||
* Gets the type of this block
|
||||
*
|
||||
* @return block type
|
||||
*/
|
||||
Material getType();
|
||||
|
||||
/**
|
||||
* Gets the type-id of this block
|
||||
*
|
||||
* @return block type-id
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
int getTypeId();
|
||||
|
||||
/**
|
||||
* Gets the light level between 0-15
|
||||
*
|
||||
* @return light level
|
||||
*/
|
||||
byte getLightLevel();
|
||||
|
||||
/**
|
||||
* Get the amount of light at this block from the sky.
|
||||
* <p>
|
||||
* Any light given from other sources (such as blocks like torches) will
|
||||
* be ignored.
|
||||
*
|
||||
* @return Sky light level
|
||||
*/
|
||||
byte getLightFromSky();
|
||||
|
||||
/**
|
||||
* Get the amount of light at this block from nearby blocks.
|
||||
* <p>
|
||||
* Any light given from other sources (such as the sun) will be ignored.
|
||||
*
|
||||
* @return Block light level
|
||||
*/
|
||||
byte getLightFromBlocks();
|
||||
|
||||
/**
|
||||
* Gets the world which contains this Block
|
||||
*
|
||||
* @return World containing this block
|
||||
*/
|
||||
World getWorld();
|
||||
|
||||
/**
|
||||
* Gets the x-coordinate of this block
|
||||
*
|
||||
* @return x-coordinate
|
||||
*/
|
||||
int getX();
|
||||
|
||||
/**
|
||||
* Gets the y-coordinate of this block
|
||||
*
|
||||
* @return y-coordinate
|
||||
*/
|
||||
int getY();
|
||||
|
||||
/**
|
||||
* Gets the z-coordinate of this block
|
||||
*
|
||||
* @return z-coordinate
|
||||
*/
|
||||
int getZ();
|
||||
|
||||
/**
|
||||
* Gets the Location of the block
|
||||
*
|
||||
* @return Location of block
|
||||
*/
|
||||
Location getLocation();
|
||||
|
||||
/**
|
||||
* Stores the location of the block in the provided Location object.
|
||||
* <p>
|
||||
* If the provided Location is null this method does nothing and returns
|
||||
* null.
|
||||
*
|
||||
* @return The Location object provided or null
|
||||
*/
|
||||
Location getLocation(Location loc);
|
||||
|
||||
/**
|
||||
* Gets the chunk which contains this block
|
||||
*
|
||||
* @return Containing Chunk
|
||||
*/
|
||||
Chunk getChunk();
|
||||
|
||||
/**
|
||||
* Sets the metadata for this block
|
||||
*
|
||||
* @param data New block specific metadata
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
void setData(byte data);
|
||||
|
||||
/**
|
||||
* Sets the metadata for this block
|
||||
*
|
||||
* @param data New block specific metadata
|
||||
* @param applyPhysics False to cancel physics from the changed block.
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
void setData(byte data, boolean applyPhysics);
|
||||
|
||||
/**
|
||||
* Sets the type of this block
|
||||
*
|
||||
* @param type Material to change this block to
|
||||
*/
|
||||
void setType(Material type);
|
||||
|
||||
/**
|
||||
* Sets the type-id of this block
|
||||
*
|
||||
* @param type Type-Id to change this block to
|
||||
* @return whether the block was changed
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
boolean setTypeId(int type);
|
||||
|
||||
/**
|
||||
* Sets the type-id of this block
|
||||
*
|
||||
* @param type Type-Id to change this block to
|
||||
* @param applyPhysics False to cancel physics on the changed block.
|
||||
* @return whether the block was changed
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
boolean setTypeId(int type, boolean applyPhysics);
|
||||
|
||||
/**
|
||||
* Sets the type-id of this block
|
||||
*
|
||||
* @param type Type-Id to change this block to
|
||||
* @param data The data value to change this block to
|
||||
* @param applyPhysics False to cancel physics on the changed block
|
||||
* @return whether the block was changed
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
boolean setTypeIdAndData(int type, byte data, boolean applyPhysics);
|
||||
|
||||
/**
|
||||
* Gets the face relation of this block compared to the given block
|
||||
* <p>
|
||||
* For example:
|
||||
* <pre>
|
||||
* Block current = world.getBlockAt(100, 100, 100);
|
||||
* Block target = world.getBlockAt(100, 101, 100);
|
||||
*
|
||||
* current.getFace(target) == BlockFace.Up;
|
||||
* </pre>
|
||||
* <br />
|
||||
* If the given block is not connected to this block, null may be returned
|
||||
*
|
||||
* @param block Block to compare against this block
|
||||
* @return BlockFace of this block which has the requested block, or null
|
||||
*/
|
||||
BlockFace getFace(Block block);
|
||||
|
||||
/**
|
||||
* Captures the current state of this block. You may then cast that state
|
||||
* into any accepted type, such as Furnace or Sign.
|
||||
* <p>
|
||||
* The returned object will never be updated, and you are not guaranteed
|
||||
* that (for example) a sign is still a sign after you capture its state.
|
||||
*
|
||||
* @return BlockState with the current state of this block.
|
||||
*/
|
||||
BlockState getState();
|
||||
|
||||
/**
|
||||
* Returns the biome that this block resides in
|
||||
*
|
||||
* @return Biome type containing this block
|
||||
*/
|
||||
Biome getBiome();
|
||||
|
||||
/**
|
||||
* Sets the biome that this block resides in
|
||||
*
|
||||
* @param bio new Biome type for this block
|
||||
*/
|
||||
void setBiome(Biome bio);
|
||||
|
||||
/**
|
||||
* Returns true if the block is being powered by Redstone.
|
||||
*
|
||||
* @return True if the block is powered.
|
||||
*/
|
||||
boolean isBlockPowered();
|
||||
|
||||
/**
|
||||
* Returns true if the block is being indirectly powered by Redstone.
|
||||
*
|
||||
* @return True if the block is indirectly powered.
|
||||
*/
|
||||
boolean isBlockIndirectlyPowered();
|
||||
|
||||
/**
|
||||
* Returns true if the block face is being powered by Redstone.
|
||||
*
|
||||
* @param face The block face
|
||||
* @return True if the block face is powered.
|
||||
*/
|
||||
boolean isBlockFacePowered(BlockFace face);
|
||||
|
||||
/**
|
||||
* Returns true if the block face is being indirectly powered by Redstone.
|
||||
*
|
||||
* @param face The block face
|
||||
* @return True if the block face is indirectly powered.
|
||||
*/
|
||||
boolean isBlockFaceIndirectlyPowered(BlockFace face);
|
||||
|
||||
/**
|
||||
* Returns the redstone power being provided to this block face
|
||||
*
|
||||
* @param face the face of the block to query or BlockFace.SELF for the
|
||||
* block itself
|
||||
* @return The power level.
|
||||
*/
|
||||
int getBlockPower(BlockFace face);
|
||||
|
||||
/**
|
||||
* Returns the redstone power being provided to this block
|
||||
*
|
||||
* @return The power level.
|
||||
*/
|
||||
int getBlockPower();
|
||||
|
||||
/**
|
||||
* Checks if this block is empty.
|
||||
* <p>
|
||||
* A block is considered empty when {@link #getType()} returns {@link
|
||||
* Material#AIR}.
|
||||
*
|
||||
* @return true if this block is empty
|
||||
*/
|
||||
boolean isEmpty();
|
||||
|
||||
/**
|
||||
* Checks if this block is liquid.
|
||||
* <p>
|
||||
* A block is considered liquid when {@link #getType()} returns {@link
|
||||
* Material#WATER}, {@link Material#STATIONARY_WATER}, {@link
|
||||
* Material#LAVA} or {@link Material#STATIONARY_LAVA}.
|
||||
*
|
||||
* @return true if this block is liquid
|
||||
*/
|
||||
boolean isLiquid();
|
||||
|
||||
/**
|
||||
* Gets the temperature of the biome of this block
|
||||
*
|
||||
* @return Temperature of this block
|
||||
*/
|
||||
double getTemperature();
|
||||
|
||||
/**
|
||||
* Gets the humidity of the biome of this block
|
||||
*
|
||||
* @return Humidity of this block
|
||||
*/
|
||||
double getHumidity();
|
||||
|
||||
/**
|
||||
* Returns the reaction of the block when moved by a piston
|
||||
*
|
||||
* @return reaction
|
||||
*/
|
||||
PistonMoveReaction getPistonMoveReaction();
|
||||
|
||||
/**
|
||||
* Breaks the block and spawns items as if a player had digged it
|
||||
*
|
||||
* @return true if the block was destroyed
|
||||
*/
|
||||
boolean breakNaturally();
|
||||
|
||||
/**
|
||||
* Breaks the block and spawns items as if a player had digged it with a
|
||||
* specific tool
|
||||
*
|
||||
* @param tool The tool or item in hand used for digging
|
||||
* @return true if the block was destroyed
|
||||
*/
|
||||
boolean breakNaturally(ItemStack tool);
|
||||
|
||||
/**
|
||||
* Returns a list of items which would drop by destroying this block
|
||||
*
|
||||
* @return a list of dropped items for this type of block
|
||||
*/
|
||||
Collection<ItemStack> getDrops();
|
||||
|
||||
/**
|
||||
* Returns a list of items which would drop by destroying this block with
|
||||
* a specific tool
|
||||
*
|
||||
* @param tool The tool or item in hand used for digging
|
||||
* @return a list of dropped items for this type of block
|
||||
*/
|
||||
Collection<ItemStack> getDrops(ItemStack tool);
|
||||
|
||||
}
|
||||
@@ -0,0 +1,132 @@
|
||||
package org.bukkit.block;
|
||||
|
||||
/**
|
||||
* Represents the face of a block
|
||||
*/
|
||||
public enum BlockFace {
|
||||
NORTH(0, 0, -1),
|
||||
EAST(1, 0, 0),
|
||||
SOUTH(0, 0, 1),
|
||||
WEST(-1, 0, 0),
|
||||
UP(0, 1, 0),
|
||||
DOWN(0, -1, 0),
|
||||
NORTH_EAST(NORTH, EAST),
|
||||
NORTH_WEST(NORTH, WEST),
|
||||
SOUTH_EAST(SOUTH, EAST),
|
||||
SOUTH_WEST(SOUTH, WEST),
|
||||
WEST_NORTH_WEST(WEST, NORTH_WEST),
|
||||
NORTH_NORTH_WEST(NORTH, NORTH_WEST),
|
||||
NORTH_NORTH_EAST(NORTH, NORTH_EAST),
|
||||
EAST_NORTH_EAST(EAST, NORTH_EAST),
|
||||
EAST_SOUTH_EAST(EAST, SOUTH_EAST),
|
||||
SOUTH_SOUTH_EAST(SOUTH, SOUTH_EAST),
|
||||
SOUTH_SOUTH_WEST(SOUTH, SOUTH_WEST),
|
||||
WEST_SOUTH_WEST(WEST, SOUTH_WEST),
|
||||
SELF(0, 0, 0);
|
||||
|
||||
private final int modX;
|
||||
private final int modY;
|
||||
private final int modZ;
|
||||
|
||||
private BlockFace(final int modX, final int modY, final int modZ) {
|
||||
this.modX = modX;
|
||||
this.modY = modY;
|
||||
this.modZ = modZ;
|
||||
}
|
||||
|
||||
private BlockFace(final BlockFace face1, final BlockFace face2) {
|
||||
this.modX = face1.getModX() + face2.getModX();
|
||||
this.modY = face1.getModY() + face2.getModY();
|
||||
this.modZ = face1.getModZ() + face2.getModZ();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the amount of X-coordinates to modify to get the represented block
|
||||
*
|
||||
* @return Amount of X-coordinates to modify
|
||||
*/
|
||||
public int getModX() {
|
||||
return modX;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the amount of Y-coordinates to modify to get the represented block
|
||||
*
|
||||
* @return Amount of Y-coordinates to modify
|
||||
*/
|
||||
public int getModY() {
|
||||
return modY;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the amount of Z-coordinates to modify to get the represented block
|
||||
*
|
||||
* @return Amount of Z-coordinates to modify
|
||||
*/
|
||||
public int getModZ() {
|
||||
return modZ;
|
||||
}
|
||||
|
||||
public BlockFace getOppositeFace() {
|
||||
switch (this) {
|
||||
case NORTH:
|
||||
return BlockFace.SOUTH;
|
||||
|
||||
case SOUTH:
|
||||
return BlockFace.NORTH;
|
||||
|
||||
case EAST:
|
||||
return BlockFace.WEST;
|
||||
|
||||
case WEST:
|
||||
return BlockFace.EAST;
|
||||
|
||||
case UP:
|
||||
return BlockFace.DOWN;
|
||||
|
||||
case DOWN:
|
||||
return BlockFace.UP;
|
||||
|
||||
case NORTH_EAST:
|
||||
return BlockFace.SOUTH_WEST;
|
||||
|
||||
case NORTH_WEST:
|
||||
return BlockFace.SOUTH_EAST;
|
||||
|
||||
case SOUTH_EAST:
|
||||
return BlockFace.NORTH_WEST;
|
||||
|
||||
case SOUTH_WEST:
|
||||
return BlockFace.NORTH_EAST;
|
||||
|
||||
case WEST_NORTH_WEST:
|
||||
return BlockFace.EAST_SOUTH_EAST;
|
||||
|
||||
case NORTH_NORTH_WEST:
|
||||
return BlockFace.SOUTH_SOUTH_EAST;
|
||||
|
||||
case NORTH_NORTH_EAST:
|
||||
return BlockFace.SOUTH_SOUTH_WEST;
|
||||
|
||||
case EAST_NORTH_EAST:
|
||||
return BlockFace.WEST_SOUTH_WEST;
|
||||
|
||||
case EAST_SOUTH_EAST:
|
||||
return BlockFace.WEST_NORTH_WEST;
|
||||
|
||||
case SOUTH_SOUTH_EAST:
|
||||
return BlockFace.NORTH_NORTH_WEST;
|
||||
|
||||
case SOUTH_SOUTH_WEST:
|
||||
return BlockFace.NORTH_NORTH_EAST;
|
||||
|
||||
case WEST_SOUTH_WEST:
|
||||
return BlockFace.EAST_NORTH_EAST;
|
||||
|
||||
case SELF:
|
||||
return BlockFace.SELF;
|
||||
}
|
||||
|
||||
return BlockFace.SELF;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,194 @@
|
||||
package org.bukkit.block;
|
||||
|
||||
import org.bukkit.Chunk;
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.World;
|
||||
import org.bukkit.material.MaterialData;
|
||||
import org.bukkit.metadata.Metadatable;
|
||||
|
||||
/**
|
||||
* Represents a captured state of a block, which will not change
|
||||
* automatically.
|
||||
* <p>
|
||||
* Unlike Block, which only one object can exist per coordinate, BlockState
|
||||
* can exist multiple times for any given Block. Note that another plugin may
|
||||
* change the state of the block and you will not know, or they may change the
|
||||
* block to another type entirely, causing your BlockState to become invalid.
|
||||
*/
|
||||
public interface BlockState extends Metadatable {
|
||||
|
||||
/**
|
||||
* Gets the block represented by this BlockState
|
||||
*
|
||||
* @return Block that this BlockState represents
|
||||
*/
|
||||
Block getBlock();
|
||||
|
||||
/**
|
||||
* Gets the metadata for this block
|
||||
*
|
||||
* @return block specific metadata
|
||||
*/
|
||||
MaterialData getData();
|
||||
|
||||
/**
|
||||
* Gets the type of this block
|
||||
*
|
||||
* @return block type
|
||||
*/
|
||||
Material getType();
|
||||
|
||||
/**
|
||||
* Gets the type-id of this block
|
||||
*
|
||||
* @return block type-id
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
int getTypeId();
|
||||
|
||||
/**
|
||||
* Gets the light level between 0-15
|
||||
*
|
||||
* @return light level
|
||||
*/
|
||||
byte getLightLevel();
|
||||
|
||||
/**
|
||||
* Gets the world which contains this Block
|
||||
*
|
||||
* @return World containing this block
|
||||
*/
|
||||
World getWorld();
|
||||
|
||||
/**
|
||||
* Gets the x-coordinate of this block
|
||||
*
|
||||
* @return x-coordinate
|
||||
*/
|
||||
int getX();
|
||||
|
||||
/**
|
||||
* Gets the y-coordinate of this block
|
||||
*
|
||||
* @return y-coordinate
|
||||
*/
|
||||
int getY();
|
||||
|
||||
/**
|
||||
* Gets the z-coordinate of this block
|
||||
*
|
||||
* @return z-coordinate
|
||||
*/
|
||||
int getZ();
|
||||
|
||||
/**
|
||||
* Gets the location of this block
|
||||
*
|
||||
* @return location
|
||||
*/
|
||||
Location getLocation();
|
||||
|
||||
/**
|
||||
* Stores the location of this block in the provided Location object.
|
||||
* <p>
|
||||
* If the provided Location is null this method does nothing and returns
|
||||
* null.
|
||||
*
|
||||
* @return The Location object provided or null
|
||||
*/
|
||||
Location getLocation(Location loc);
|
||||
|
||||
/**
|
||||
* Gets the chunk which contains this block
|
||||
*
|
||||
* @return Containing Chunk
|
||||
*/
|
||||
Chunk getChunk();
|
||||
|
||||
/**
|
||||
* Sets the metadata for this block
|
||||
*
|
||||
* @param data New block specific metadata
|
||||
*/
|
||||
void setData(MaterialData data);
|
||||
|
||||
/**
|
||||
* Sets the type of this block
|
||||
*
|
||||
* @param type Material to change this block to
|
||||
*/
|
||||
void setType(Material type);
|
||||
|
||||
/**
|
||||
* Sets the type-id of this block
|
||||
*
|
||||
* @param type Type-Id to change this block to
|
||||
* @return Whether it worked?
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
boolean setTypeId(int type);
|
||||
|
||||
/**
|
||||
* Attempts to update the block represented by this state, setting it to
|
||||
* the new values as defined by this state.
|
||||
* <p>
|
||||
* This has the same effect as calling update(false). That is to say,
|
||||
* this will not modify the state of a block if it is no longer the same
|
||||
* type as it was when this state was taken. It will return false in this
|
||||
* eventuality.
|
||||
*
|
||||
* @return true if the update was successful, otherwise false
|
||||
* @see #update(boolean)
|
||||
*/
|
||||
boolean update();
|
||||
|
||||
/**
|
||||
* Attempts to update the block represented by this state, setting it to
|
||||
* the new values as defined by this state.
|
||||
* <p>
|
||||
* This has the same effect as calling update(force, true). That is to
|
||||
* say, this will trigger a physics update to surrounding blocks.
|
||||
*
|
||||
* @param force true to forcefully set the state
|
||||
* @return true if the update was successful, otherwise false
|
||||
*/
|
||||
boolean update(boolean force);
|
||||
|
||||
/**
|
||||
* Attempts to update the block represented by this state, setting it to
|
||||
* the new values as defined by this state.
|
||||
* <p>
|
||||
* Unless force is true, this will not modify the state of a block if it
|
||||
* is no longer the same type as it was when this state was taken. It will
|
||||
* return false in this eventuality.
|
||||
* <p>
|
||||
* If force is true, it will set the type of the block to match the new
|
||||
* state, set the state data and then return true.
|
||||
* <p>
|
||||
* If applyPhysics is true, it will trigger a physics update on
|
||||
* surrounding blocks which could cause them to update or disappear.
|
||||
*
|
||||
* @param force true to forcefully set the state
|
||||
* @param applyPhysics false to cancel updating physics on surrounding
|
||||
* blocks
|
||||
* @return true if the update was successful, otherwise false
|
||||
*/
|
||||
boolean update(boolean force, boolean applyPhysics);
|
||||
|
||||
/**
|
||||
* @return The data as a raw byte.
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public byte getRawData();
|
||||
|
||||
/**
|
||||
* @param data The new data value for the block.
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public void setRawData(byte data);
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
package org.bukkit.block;
|
||||
|
||||
import org.bukkit.inventory.BrewerInventory;
|
||||
|
||||
/**
|
||||
* Represents a brewing stand.
|
||||
*/
|
||||
public interface BrewingStand extends BlockState, ContainerBlock {
|
||||
|
||||
/**
|
||||
* How much time is left in the brewing cycle
|
||||
*
|
||||
* @return Brew Time
|
||||
*/
|
||||
int getBrewingTime();
|
||||
|
||||
/**
|
||||
* Set the time left before brewing completes.
|
||||
*
|
||||
* @param brewTime Brewing time
|
||||
*/
|
||||
void setBrewingTime(int brewTime);
|
||||
|
||||
public BrewerInventory getInventory();
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
package org.bukkit.block;
|
||||
|
||||
import org.bukkit.inventory.Inventory;
|
||||
|
||||
/**
|
||||
* Represents a chest.
|
||||
*/
|
||||
public interface Chest extends BlockState, ContainerBlock {
|
||||
|
||||
/**
|
||||
* Returns the chest's inventory. If this is a double chest, it returns
|
||||
* just the portion of the inventory linked to this half of the chest.
|
||||
*
|
||||
* @return The inventory.
|
||||
*/
|
||||
Inventory getBlockInventory();
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
package org.bukkit.block;
|
||||
|
||||
public interface CommandBlock extends BlockState {
|
||||
|
||||
/**
|
||||
* Gets the command that this CommandBlock will run when powered.
|
||||
* This will never return null. If the CommandBlock does not have a
|
||||
* command, an empty String will be returned instead.
|
||||
*
|
||||
* @return Command that this CommandBlock will run when powered.
|
||||
*/
|
||||
public String getCommand();
|
||||
|
||||
/**
|
||||
* Sets the command that this CommandBlock will run when powered.
|
||||
* Setting the command to null is the same as setting it to an empty
|
||||
* String.
|
||||
*
|
||||
* @param command Command that this CommandBlock will run when powered.
|
||||
*/
|
||||
public void setCommand(String command);
|
||||
|
||||
/**
|
||||
* Gets the name of this CommandBlock. The name is used with commands
|
||||
* that this CommandBlock executes. This name will never be null, and
|
||||
* by default is "@".
|
||||
*
|
||||
* @return Name of this CommandBlock.
|
||||
*/
|
||||
public String getName();
|
||||
|
||||
/**
|
||||
* Sets the name of this CommandBlock. The name is used with commands
|
||||
* that this CommandBlock executes. Setting the name to null is the
|
||||
* same as setting it to "@".
|
||||
*
|
||||
* @param name New name for this CommandBlock.
|
||||
*/
|
||||
public void setName(String name);
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
package org.bukkit.block;
|
||||
|
||||
import org.bukkit.inventory.InventoryHolder;
|
||||
|
||||
/**
|
||||
* Indicates a block type that has inventory.
|
||||
*
|
||||
* @deprecated in favour of {@link InventoryHolder}
|
||||
*/
|
||||
@Deprecated
|
||||
public interface ContainerBlock extends InventoryHolder {}
|
||||
@@ -0,0 +1,88 @@
|
||||
package org.bukkit.block;
|
||||
|
||||
import org.bukkit.entity.CreatureType;
|
||||
import org.bukkit.entity.EntityType;
|
||||
|
||||
/**
|
||||
* Represents a creature spawner.
|
||||
*/
|
||||
public interface CreatureSpawner extends BlockState {
|
||||
|
||||
/**
|
||||
* Get the spawner's creature type.
|
||||
*
|
||||
* @return The creature type.
|
||||
* @deprecated In favour of {@link #getSpawnedType()}.
|
||||
*/
|
||||
@Deprecated
|
||||
public CreatureType getCreatureType();
|
||||
|
||||
/**
|
||||
* Get the spawner's creature type.
|
||||
*
|
||||
* @return The creature type.
|
||||
*/
|
||||
public EntityType getSpawnedType();
|
||||
|
||||
/**
|
||||
* Set the spawner's creature type.
|
||||
*
|
||||
* @param creatureType The creature type.
|
||||
*/
|
||||
public void setSpawnedType(EntityType creatureType);
|
||||
|
||||
/**
|
||||
* Set the spawner creature type.
|
||||
*
|
||||
* @param creatureType The creature type.
|
||||
* @deprecated In favour of {@link #setSpawnedType(EntityType)}.
|
||||
*/
|
||||
@Deprecated
|
||||
public void setCreatureType(CreatureType creatureType);
|
||||
|
||||
/**
|
||||
* Get the spawner's creature type.
|
||||
*
|
||||
* @return The creature type's name.
|
||||
* @deprecated Use {@link #getCreatureTypeName()}.
|
||||
*/
|
||||
@Deprecated
|
||||
public String getCreatureTypeId();
|
||||
|
||||
/**
|
||||
* Set the spawner mob type.
|
||||
*
|
||||
* @param creatureType The creature type's name.
|
||||
*/
|
||||
public void setCreatureTypeByName(String creatureType);
|
||||
|
||||
/**
|
||||
* Get the spawner's creature type.
|
||||
*
|
||||
* @return The creature type's name.
|
||||
*/
|
||||
public String getCreatureTypeName();
|
||||
|
||||
/**
|
||||
* Set the spawner mob type.
|
||||
*
|
||||
* @param creatureType The creature type's name.
|
||||
* @deprecated Use {@link #setCreatureTypeByName(String)}.
|
||||
*/
|
||||
@Deprecated
|
||||
public void setCreatureTypeId(String creatureType);
|
||||
|
||||
/**
|
||||
* Get the spawner's delay.
|
||||
*
|
||||
* @return The delay.
|
||||
*/
|
||||
public int getDelay();
|
||||
|
||||
/**
|
||||
* Set the spawner's delay.
|
||||
*
|
||||
* @param delay The delay.
|
||||
*/
|
||||
public void setDelay(int delay);
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
package org.bukkit.block;
|
||||
|
||||
import org.bukkit.projectiles.BlockProjectileSource;
|
||||
|
||||
/**
|
||||
* Represents a dispenser.
|
||||
*/
|
||||
public interface Dispenser extends BlockState, ContainerBlock {
|
||||
|
||||
/**
|
||||
* Gets the BlockProjectileSource object for this dispenser.
|
||||
* <p>
|
||||
* If the block is no longer a dispenser, this will return null.
|
||||
*
|
||||
* @return a BlockProjectileSource if valid, otherwise null
|
||||
*/
|
||||
public BlockProjectileSource getBlockProjectileSource();
|
||||
|
||||
/**
|
||||
* Attempts to dispense the contents of this block.
|
||||
* <p>
|
||||
* If the block is no longer a dispenser, this will return false.
|
||||
*
|
||||
* @return true if successful, otherwise false
|
||||
*/
|
||||
public boolean dispense();
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
package org.bukkit.block;
|
||||
|
||||
import org.bukkit.Location;
|
||||
import org.bukkit.World;
|
||||
import org.bukkit.inventory.DoubleChestInventory;
|
||||
import org.bukkit.inventory.Inventory;
|
||||
import org.bukkit.inventory.InventoryHolder;
|
||||
|
||||
/**
|
||||
* Represents a double chest.
|
||||
*/
|
||||
public class DoubleChest implements InventoryHolder {
|
||||
private DoubleChestInventory inventory;
|
||||
|
||||
public DoubleChest(DoubleChestInventory chest) {
|
||||
inventory = chest;
|
||||
}
|
||||
|
||||
public Inventory getInventory() {
|
||||
return inventory;
|
||||
}
|
||||
|
||||
public InventoryHolder getLeftSide() {
|
||||
return inventory.getLeftSide().getHolder();
|
||||
}
|
||||
|
||||
public InventoryHolder getRightSide() {
|
||||
return inventory.getRightSide().getHolder();
|
||||
}
|
||||
|
||||
public Location getLocation() {
|
||||
return new Location(getWorld(), getX(), getY(), getZ());
|
||||
}
|
||||
|
||||
public World getWorld() {
|
||||
return ((Chest)getLeftSide()).getWorld();
|
||||
}
|
||||
|
||||
public double getX() {
|
||||
return 0.5 * (((Chest)getLeftSide()).getX() + ((Chest)getRightSide()).getX());
|
||||
}
|
||||
|
||||
public double getY() {
|
||||
return 0.5 * (((Chest)getLeftSide()).getY() + ((Chest)getRightSide()).getY());
|
||||
}
|
||||
|
||||
public double getZ() {
|
||||
return 0.5 * (((Chest)getLeftSide()).getZ() + ((Chest)getRightSide()).getZ());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
package org.bukkit.block;
|
||||
|
||||
import org.bukkit.inventory.InventoryHolder;
|
||||
|
||||
/**
|
||||
* Represents a dropper.
|
||||
*/
|
||||
public interface Dropper extends BlockState, InventoryHolder {
|
||||
/**
|
||||
* Tries to drop a randomly selected item from the Dropper's inventory,
|
||||
* following the normal behavior of a Dropper.
|
||||
* <p>
|
||||
* Normal behavior of a Dropper is as follows:
|
||||
* <p>
|
||||
* If the block that the Dropper is facing is an InventoryHolder or
|
||||
* ContainerBlock the randomly selected ItemStack is placed within that
|
||||
* Inventory in the first slot that's available, starting with 0 and
|
||||
* counting up. If the inventory is full, nothing happens.
|
||||
* <p>
|
||||
* If the block that the Dropper is facing is not an InventoryHolder or
|
||||
* ContainerBlock, the randomly selected ItemStack is dropped on
|
||||
* the ground in the form of an {@link org.bukkit.entity.Item Item}.
|
||||
*/
|
||||
public void drop();
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
package org.bukkit.block;
|
||||
|
||||
import org.bukkit.inventory.FurnaceInventory;
|
||||
|
||||
/**
|
||||
* Represents a furnace.
|
||||
*/
|
||||
public interface Furnace extends BlockState, ContainerBlock {
|
||||
|
||||
/**
|
||||
* Get burn time.
|
||||
*
|
||||
* @return Burn time
|
||||
*/
|
||||
public short getBurnTime();
|
||||
|
||||
/**
|
||||
* Set burn time.
|
||||
*
|
||||
* @param burnTime Burn time
|
||||
*/
|
||||
public void setBurnTime(short burnTime);
|
||||
|
||||
/**
|
||||
* Get cook time.
|
||||
*
|
||||
* @return Cook time
|
||||
*/
|
||||
public short getCookTime();
|
||||
|
||||
/**
|
||||
* Set cook time.
|
||||
*
|
||||
* @param cookTime Cook time
|
||||
*/
|
||||
public void setCookTime(short cookTime);
|
||||
|
||||
public FurnaceInventory getInventory();
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
package org.bukkit.block;
|
||||
|
||||
import org.bukkit.inventory.InventoryHolder;
|
||||
|
||||
/**
|
||||
* Represents a hopper.
|
||||
*/
|
||||
public interface Hopper extends BlockState, InventoryHolder {
|
||||
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
package org.bukkit.block;
|
||||
|
||||
import org.bukkit.Material;
|
||||
|
||||
/**
|
||||
* Represents a Jukebox
|
||||
*/
|
||||
public interface Jukebox extends BlockState {
|
||||
/**
|
||||
* Get the record currently playing
|
||||
*
|
||||
* @return The record Material, or AIR if none is playing
|
||||
*/
|
||||
public Material getPlaying();
|
||||
|
||||
/**
|
||||
* Set the record currently playing
|
||||
*
|
||||
* @param record The record Material, or null/AIR to stop playing
|
||||
*/
|
||||
public void setPlaying(Material record);
|
||||
|
||||
/**
|
||||
* Check if the jukebox is currently playing a record
|
||||
*
|
||||
* @return True if there is a record playing
|
||||
*/
|
||||
public boolean isPlaying();
|
||||
|
||||
/**
|
||||
* Stop the jukebox playing and eject the current record
|
||||
*
|
||||
* @return True if a record was ejected; false if there was none playing
|
||||
*/
|
||||
public boolean eject();
|
||||
}
|
||||
@@ -0,0 +1,72 @@
|
||||
package org.bukkit.block;
|
||||
|
||||
import org.bukkit.Instrument;
|
||||
import org.bukkit.Note;
|
||||
|
||||
/**
|
||||
* Represents a note.
|
||||
*/
|
||||
public interface NoteBlock extends BlockState {
|
||||
|
||||
/**
|
||||
* Gets the note.
|
||||
*
|
||||
* @return The note.
|
||||
*/
|
||||
public Note getNote();
|
||||
|
||||
/**
|
||||
* Gets the note.
|
||||
*
|
||||
* @return The note ID.
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public byte getRawNote();
|
||||
|
||||
/**
|
||||
* Set the note.
|
||||
*
|
||||
* @param note The note.
|
||||
*/
|
||||
public void setNote(Note note);
|
||||
|
||||
/**
|
||||
* Set the note.
|
||||
*
|
||||
* @param note The note ID.
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public void setRawNote(byte note);
|
||||
|
||||
/**
|
||||
* Attempts to play the note at block
|
||||
* <p>
|
||||
* If the block is no longer a note block, this will return false
|
||||
*
|
||||
* @return true if successful, otherwise false
|
||||
*/
|
||||
public boolean play();
|
||||
|
||||
/**
|
||||
* Plays an arbitrary note with an arbitrary instrument
|
||||
*
|
||||
* @param instrument Instrument ID
|
||||
* @param note Note ID
|
||||
* @return true if successful, otherwise false
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public boolean play(byte instrument, byte note);
|
||||
|
||||
/**
|
||||
* Plays an arbitrary note with an arbitrary instrument
|
||||
*
|
||||
* @param instrument The instrument
|
||||
* @param note The note
|
||||
* @return true if successful, otherwise false
|
||||
* @see Instrument Note
|
||||
*/
|
||||
public boolean play(Instrument instrument, Note note);
|
||||
}
|
||||
@@ -0,0 +1,51 @@
|
||||
package org.bukkit.block;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
public enum PistonMoveReaction {
|
||||
|
||||
/**
|
||||
* Indicates that the block can be pushed or pulled.
|
||||
*/
|
||||
MOVE(0),
|
||||
/**
|
||||
* Indicates the block is fragile and will break if pushed on.
|
||||
*/
|
||||
BREAK(1),
|
||||
/**
|
||||
* Indicates that the block will resist being pushed or pulled.
|
||||
*/
|
||||
BLOCK(2);
|
||||
|
||||
private int id;
|
||||
private static Map<Integer, PistonMoveReaction> byId = new HashMap<Integer, PistonMoveReaction>();
|
||||
static {
|
||||
for (PistonMoveReaction reaction : PistonMoveReaction.values()) {
|
||||
byId.put(reaction.id, reaction);
|
||||
}
|
||||
}
|
||||
|
||||
private PistonMoveReaction(int id) {
|
||||
this.id = id;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return The ID of the move reaction
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public int getId() {
|
||||
return this.id;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param id An ID
|
||||
* @return The move reaction with that ID
|
||||
* @deprecated Magic value
|
||||
*/
|
||||
@Deprecated
|
||||
public static PistonMoveReaction getById(int id) {
|
||||
return byId.get(id);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
package org.bukkit.block;
|
||||
|
||||
/**
|
||||
* Represents either a SignPost or a WallSign
|
||||
*/
|
||||
public interface Sign extends BlockState {
|
||||
|
||||
/**
|
||||
* Gets all the lines of text currently on this sign.
|
||||
*
|
||||
* @return Array of Strings containing each line of text
|
||||
*/
|
||||
public String[] getLines();
|
||||
|
||||
/**
|
||||
* Gets the line of text at the specified index.
|
||||
* <p>
|
||||
* For example, getLine(0) will return the first line of text.
|
||||
*
|
||||
* @param index Line number to get the text from, starting at 0
|
||||
* @throws IndexOutOfBoundsException Thrown when the line does not exist
|
||||
* @return Text on the given line
|
||||
*/
|
||||
public String getLine(int index) throws IndexOutOfBoundsException;
|
||||
|
||||
/**
|
||||
* Sets the line of text at the specified index.
|
||||
* <p>
|
||||
* For example, setLine(0, "Line One") will set the first line of text to
|
||||
* "Line One".
|
||||
*
|
||||
* @param index Line number to set the text at, starting from 0
|
||||
* @param line New text to set at the specified index
|
||||
* @throws IndexOutOfBoundsException If the index is out of the range 0..3
|
||||
*/
|
||||
public void setLine(int index, String line) throws IndexOutOfBoundsException;
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
package org.bukkit.block;
|
||||
|
||||
import org.bukkit.SkullType;
|
||||
|
||||
/**
|
||||
* Represents a Skull
|
||||
*/
|
||||
public interface Skull extends BlockState {
|
||||
|
||||
/**
|
||||
* Checks to see if the skull has an owner
|
||||
*
|
||||
* @return true if the skull has an owner
|
||||
*/
|
||||
public boolean hasOwner();
|
||||
|
||||
/**
|
||||
* Gets the owner of the skull, if one exists
|
||||
*
|
||||
* @return the owner of the skull or null if the skull does not have an owner
|
||||
*/
|
||||
public String getOwner();
|
||||
|
||||
/**
|
||||
* Sets the owner of the skull
|
||||
* <p>
|
||||
* Involves a potentially blocking web request to acquire the profile data for
|
||||
* the provided name.
|
||||
*
|
||||
* @param name the new owner of the skull
|
||||
* @return true if the owner was successfully set
|
||||
*/
|
||||
public boolean setOwner(String name);
|
||||
|
||||
/**
|
||||
* Gets the rotation of the skull in the world
|
||||
*
|
||||
* @return the rotation of the skull
|
||||
*/
|
||||
public BlockFace getRotation();
|
||||
|
||||
/**
|
||||
* Sets the rotation of the skull in the world
|
||||
*
|
||||
* @param rotation the rotation of the skull
|
||||
*/
|
||||
public void setRotation(BlockFace rotation);
|
||||
|
||||
/**
|
||||
* Gets the type of skull
|
||||
*
|
||||
* @return the type of skull
|
||||
*/
|
||||
public SkullType getSkullType();
|
||||
|
||||
/**
|
||||
* Sets the type of skull
|
||||
*
|
||||
* @param skullType the type of skull
|
||||
*/
|
||||
public void setSkullType(SkullType skullType);
|
||||
}
|
||||
@@ -0,0 +1,13 @@
|
||||
package org.bukkit.command;
|
||||
|
||||
import org.bukkit.block.Block;
|
||||
|
||||
public interface BlockCommandSender extends CommandSender {
|
||||
|
||||
/**
|
||||
* Returns the block this command sender belongs to
|
||||
*
|
||||
* @return Block for the command sender
|
||||
*/
|
||||
public Block getBlock();
|
||||
}
|
||||
@@ -0,0 +1,396 @@
|
||||
package org.bukkit.command;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.Set;
|
||||
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.Server;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.entity.minecart.CommandMinecart;
|
||||
import org.bukkit.permissions.Permissible;
|
||||
import org.bukkit.plugin.PluginDescriptionFile;
|
||||
import org.bukkit.util.StringUtil;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
|
||||
/**
|
||||
* Represents a Command, which executes various tasks upon user input
|
||||
*/
|
||||
public abstract class Command {
|
||||
private final String name;
|
||||
private String nextLabel;
|
||||
private String label;
|
||||
private List<String> aliases;
|
||||
private List<String> activeAliases;
|
||||
private CommandMap commandMap = null;
|
||||
protected String description = "";
|
||||
protected String usageMessage;
|
||||
private String permission;
|
||||
private String permissionMessage;
|
||||
|
||||
protected Command(String name) {
|
||||
this(name, "", "/" + name, new ArrayList<String>());
|
||||
}
|
||||
|
||||
protected Command(String name, String description, String usageMessage, List<String> aliases) {
|
||||
this.name = name;
|
||||
this.nextLabel = name;
|
||||
this.label = name;
|
||||
this.description = description;
|
||||
this.usageMessage = usageMessage;
|
||||
this.aliases = aliases;
|
||||
this.activeAliases = new ArrayList<String>(aliases);
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes the command, returning its success
|
||||
*
|
||||
* @param sender Source object which is executing this command
|
||||
* @param commandLabel The alias of the command used
|
||||
* @param args All arguments passed to the command, split via ' '
|
||||
* @return true if the command was successful, otherwise false
|
||||
*/
|
||||
public abstract boolean execute(CommandSender sender, String commandLabel, String[] args);
|
||||
|
||||
/**
|
||||
* @deprecated This method is not supported and returns null
|
||||
*/
|
||||
@Deprecated
|
||||
public List<String> tabComplete(CommandSender sender, String[] args) {
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Executed on tab completion for this command, returning a list of
|
||||
* options the player can tab through.
|
||||
*
|
||||
* @param sender Source object which is executing this command
|
||||
* @param alias the alias being used
|
||||
* @param args All arguments passed to the command, split via ' '
|
||||
* @return a list of tab-completions for the specified arguments. This
|
||||
* will never be null. List may be immutable.
|
||||
* @throws IllegalArgumentException if sender, alias, or args is null
|
||||
*/
|
||||
public List<String> tabComplete(CommandSender sender, String alias, String[] args) throws IllegalArgumentException {
|
||||
Validate.notNull(sender, "Sender cannot be null");
|
||||
Validate.notNull(args, "Arguments cannot be null");
|
||||
Validate.notNull(alias, "Alias cannot be null");
|
||||
|
||||
if (args.length == 0) {
|
||||
return ImmutableList.of();
|
||||
}
|
||||
|
||||
String lastWord = args[args.length - 1];
|
||||
|
||||
Player senderPlayer = sender instanceof Player ? (Player) sender : null;
|
||||
|
||||
ArrayList<String> matchedPlayers = new ArrayList<String>();
|
||||
for (Player player : sender.getServer().getOnlinePlayers()) {
|
||||
String name = player.getName();
|
||||
if ((senderPlayer == null || senderPlayer.canSee(player)) && StringUtil.startsWithIgnoreCase(name, lastWord)) {
|
||||
matchedPlayers.add(name);
|
||||
}
|
||||
}
|
||||
|
||||
Collections.sort(matchedPlayers, String.CASE_INSENSITIVE_ORDER);
|
||||
return matchedPlayers;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the name of this command
|
||||
*
|
||||
* @return Name of this command
|
||||
*/
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the permission required by users to be able to perform this
|
||||
* command
|
||||
*
|
||||
* @return Permission name, or null if none
|
||||
*/
|
||||
public String getPermission() {
|
||||
return permission;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the permission required by users to be able to perform this
|
||||
* command
|
||||
*
|
||||
* @param permission Permission name or null
|
||||
*/
|
||||
public void setPermission(String permission) {
|
||||
this.permission = permission;
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the given {@link CommandSender} to see if they can perform this
|
||||
* command.
|
||||
* <p>
|
||||
* If they do not have permission, they will be informed that they cannot
|
||||
* do this.
|
||||
*
|
||||
* @param target User to test
|
||||
* @return true if they can use it, otherwise false
|
||||
*/
|
||||
public boolean testPermission(CommandSender target) {
|
||||
if (testPermissionSilent(target)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (permissionMessage == null) {
|
||||
target.sendMessage(ChatColor.RED + "I'm sorry, but you do not have permission to perform this command. Please contact the server administrators if you believe that this is in error.");
|
||||
} else if (permissionMessage.length() != 0) {
|
||||
for (String line : permissionMessage.replace("<permission>", permission).split("\n")) {
|
||||
target.sendMessage(line);
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests the given {@link CommandSender} to see if they can perform this
|
||||
* command.
|
||||
* <p>
|
||||
* No error is sent to the sender.
|
||||
*
|
||||
* @param target User to test
|
||||
* @return true if they can use it, otherwise false
|
||||
*/
|
||||
public boolean testPermissionSilent(CommandSender target) {
|
||||
if ((permission == null) || (permission.length() == 0)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
for (String p : permission.split(";")) {
|
||||
if (target.hasPermission(p)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the current label for this command
|
||||
*
|
||||
* @return Label of this command or null if not registered
|
||||
*/
|
||||
public String getLabel() {
|
||||
return label;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the label of this command.
|
||||
* <p>
|
||||
* If the command is currently registered the label change will only take
|
||||
* effect after its been re-registered e.g. after a /reload
|
||||
*
|
||||
* @param name The command's name
|
||||
* @return returns true if the name change happened instantly or false if
|
||||
* it was scheduled for re-registration
|
||||
*/
|
||||
public boolean setLabel(String name) {
|
||||
this.nextLabel = name;
|
||||
if (!isRegistered()) {
|
||||
this.label = name;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Registers this command to a CommandMap.
|
||||
* Once called it only allows changes the registered CommandMap
|
||||
*
|
||||
* @param commandMap the CommandMap to register this command to
|
||||
* @return true if the registration was successful (the current registered
|
||||
* CommandMap was the passed CommandMap or null) false otherwise
|
||||
*/
|
||||
public boolean register(CommandMap commandMap) {
|
||||
if (allowChangesFrom(commandMap)) {
|
||||
this.commandMap = commandMap;
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Unregisters this command from the passed CommandMap applying any
|
||||
* outstanding changes
|
||||
*
|
||||
* @param commandMap the CommandMap to unregister
|
||||
* @return true if the unregistration was successfull (the current
|
||||
* registered CommandMap was the passed CommandMap or null) false
|
||||
* otherwise
|
||||
*/
|
||||
public boolean unregister(CommandMap commandMap) {
|
||||
if (allowChangesFrom(commandMap)) {
|
||||
this.commandMap = null;
|
||||
this.activeAliases = new ArrayList<String>(this.aliases);
|
||||
this.label = this.nextLabel;
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
private boolean allowChangesFrom(CommandMap commandMap) {
|
||||
return (null == this.commandMap || this.commandMap == commandMap);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the current registered state of this command
|
||||
*
|
||||
* @return true if this command is currently registered false otherwise
|
||||
*/
|
||||
public boolean isRegistered() {
|
||||
return (null != this.commandMap);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a list of active aliases of this command
|
||||
*
|
||||
* @return List of aliases
|
||||
*/
|
||||
public List<String> getAliases() {
|
||||
return activeAliases;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a message to be displayed on a failed permission check for this
|
||||
* command
|
||||
*
|
||||
* @return Permission check failed message
|
||||
*/
|
||||
public String getPermissionMessage() {
|
||||
return permissionMessage;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets a brief description of this command
|
||||
*
|
||||
* @return Description of this command
|
||||
*/
|
||||
public String getDescription() {
|
||||
return description;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets an example usage of this command
|
||||
*
|
||||
* @return One or more example usages
|
||||
*/
|
||||
public String getUsage() {
|
||||
return usageMessage;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the list of aliases to request on registration for this command.
|
||||
* This is not effective outside of defining aliases in the {@link
|
||||
* PluginDescriptionFile#getCommands()} (under the
|
||||
* `<code>aliases</code>' node) is equivalent to this method.
|
||||
*
|
||||
* @param aliases aliases to register to this command
|
||||
* @return this command object, for chaining
|
||||
*/
|
||||
public Command setAliases(List<String> aliases) {
|
||||
this.aliases = aliases;
|
||||
if (!isRegistered()) {
|
||||
this.activeAliases = new ArrayList<String>(aliases);
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets a brief description of this command. Defining a description in the
|
||||
* {@link PluginDescriptionFile#getCommands()} (under the
|
||||
* `<code>description</code>' node) is equivalent to this method.
|
||||
*
|
||||
* @param description new command description
|
||||
* @return this command object, for chaining
|
||||
*/
|
||||
public Command setDescription(String description) {
|
||||
this.description = description;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the message sent when a permission check fails
|
||||
*
|
||||
* @param permissionMessage new permission message, null to indicate
|
||||
* default message, or an empty string to indicate no message
|
||||
* @return this command object, for chaining
|
||||
*/
|
||||
public Command setPermissionMessage(String permissionMessage) {
|
||||
this.permissionMessage = permissionMessage;
|
||||
return this;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the example usage of this command
|
||||
*
|
||||
* @param usage new example usage
|
||||
* @return this command object, for chaining
|
||||
*/
|
||||
public Command setUsage(String usage) {
|
||||
this.usageMessage = usage;
|
||||
return this;
|
||||
}
|
||||
|
||||
public static void broadcastCommandMessage(CommandSender source, String message) {
|
||||
broadcastCommandMessage(source, message, true);
|
||||
}
|
||||
|
||||
public static void broadcastCommandMessage(CommandSender source, String message, boolean sendToSource) {
|
||||
String result = source.getName() + ": " + message;
|
||||
|
||||
if (source instanceof BlockCommandSender) {
|
||||
BlockCommandSender blockCommandSender = (BlockCommandSender) source;
|
||||
|
||||
if (blockCommandSender.getBlock().getWorld().getGameRuleValue("commandBlockOutput").equalsIgnoreCase("false")) {
|
||||
Bukkit.getConsoleSender().sendMessage(result);
|
||||
return;
|
||||
}
|
||||
} else if (source instanceof CommandMinecart) {
|
||||
CommandMinecart commandMinecart = (CommandMinecart) source;
|
||||
|
||||
if (commandMinecart.getWorld().getGameRuleValue("commandBlockOutput").equalsIgnoreCase("false")) {
|
||||
Bukkit.getConsoleSender().sendMessage(result);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
Set<Permissible> users = Bukkit.getPluginManager().getPermissionSubscriptions(Server.BROADCAST_CHANNEL_ADMINISTRATIVE);
|
||||
String colored = ChatColor.GRAY + "" + ChatColor.ITALIC + "[" + result + ChatColor.GRAY + ChatColor.ITALIC + "]";
|
||||
|
||||
if (sendToSource && !(source instanceof ConsoleCommandSender)) {
|
||||
source.sendMessage(message);
|
||||
}
|
||||
|
||||
for (Permissible user : users) {
|
||||
if (user instanceof CommandSender) {
|
||||
CommandSender target = (CommandSender) user;
|
||||
|
||||
if (target instanceof ConsoleCommandSender) {
|
||||
target.sendMessage(result);
|
||||
} else if (target != source) {
|
||||
target.sendMessage(colored);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return getClass().getName() + '(' + name + ')';
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
package org.bukkit.command;
|
||||
|
||||
/**
|
||||
* Thrown when an unhandled exception occurs during the execution of a Command
|
||||
*/
|
||||
@SuppressWarnings("serial")
|
||||
public class CommandException extends RuntimeException {
|
||||
|
||||
/**
|
||||
* Creates a new instance of <code>CommandException</code> without detail
|
||||
* message.
|
||||
*/
|
||||
public CommandException() {}
|
||||
|
||||
/**
|
||||
* Constructs an instance of <code>CommandException</code> with the
|
||||
* specified detail message.
|
||||
*
|
||||
* @param msg the detail message.
|
||||
*/
|
||||
public CommandException(String msg) {
|
||||
super(msg);
|
||||
}
|
||||
|
||||
public CommandException(String msg, Throwable cause) {
|
||||
super(msg, cause);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
package org.bukkit.command;
|
||||
|
||||
/**
|
||||
* Represents a class which contains a single method for executing commands
|
||||
*/
|
||||
public interface CommandExecutor {
|
||||
|
||||
/**
|
||||
* Executes the given command, returning its success
|
||||
*
|
||||
* @param sender Source of the command
|
||||
* @param command Command which was executed
|
||||
* @param label Alias of the command which was used
|
||||
* @param args Passed command arguments
|
||||
* @return true if a valid command, otherwise false
|
||||
*/
|
||||
public boolean onCommand(CommandSender sender, Command command, String label, String[] args);
|
||||
}
|
||||
@@ -0,0 +1,109 @@
|
||||
package org.bukkit.command;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public interface CommandMap {
|
||||
|
||||
/**
|
||||
* Registers all the commands belonging to a certain plugin.
|
||||
* <p>
|
||||
* Caller can use:-
|
||||
* <ul>
|
||||
* <li>command.getName() to determine the label registered for this
|
||||
* command
|
||||
* <li>command.getAliases() to determine the aliases which where
|
||||
* registered
|
||||
* </ul>
|
||||
*
|
||||
* @param fallbackPrefix a prefix which is prepended to each command with
|
||||
* a ':' one or more times to make the command unique
|
||||
* @param commands a list of commands to register
|
||||
*/
|
||||
public void registerAll(String fallbackPrefix, List<Command> commands);
|
||||
|
||||
/**
|
||||
* Registers a command. Returns true on success; false if name is already
|
||||
* taken and fallback had to be used.
|
||||
* <p>
|
||||
* Caller can use:-
|
||||
* <ul>
|
||||
* <li>command.getName() to determine the label registered for this
|
||||
* command
|
||||
* <li>command.getAliases() to determine the aliases which where
|
||||
* registered
|
||||
* </ul>
|
||||
*
|
||||
* @param label the label of the command, without the '/'-prefix.
|
||||
* @param fallbackPrefix a prefix which is prepended to the command with a
|
||||
* ':' one or more times to make the command unique
|
||||
* @param command the command to register
|
||||
* @return true if command was registered with the passed in label, false
|
||||
* otherwise, which indicates the fallbackPrefix was used one or more
|
||||
* times
|
||||
*/
|
||||
public boolean register(String label, String fallbackPrefix, Command command);
|
||||
|
||||
/**
|
||||
* Registers a command. Returns true on success; false if name is already
|
||||
* taken and fallback had to be used.
|
||||
* <p>
|
||||
* Caller can use:-
|
||||
* <ul>
|
||||
* <li>command.getName() to determine the label registered for this
|
||||
* command
|
||||
* <li>command.getAliases() to determine the aliases which where
|
||||
* registered
|
||||
* </ul>
|
||||
*
|
||||
* @param fallbackPrefix a prefix which is prepended to the command with a
|
||||
* ':' one or more times to make the command unique
|
||||
* @param command the command to register, from which label is determined
|
||||
* from the command name
|
||||
* @return true if command was registered with the passed in label, false
|
||||
* otherwise, which indicates the fallbackPrefix was used one or more
|
||||
* times
|
||||
*/
|
||||
public boolean register(String fallbackPrefix, Command command);
|
||||
|
||||
/**
|
||||
* Looks for the requested command and executes it if found.
|
||||
*
|
||||
* @param sender The command's sender
|
||||
* @param cmdLine command + arguments. Example: "/test abc 123"
|
||||
* @return returns false if no target is found, true otherwise.
|
||||
* @throws CommandException Thrown when the executor for the given command
|
||||
* fails with an unhandled exception
|
||||
*/
|
||||
public boolean dispatch(CommandSender sender, String cmdLine) throws CommandException;
|
||||
|
||||
/**
|
||||
* Clears all registered commands.
|
||||
*/
|
||||
public void clearCommands();
|
||||
|
||||
/**
|
||||
* Gets the command registered to the specified name
|
||||
*
|
||||
* @param name Name of the command to retrieve
|
||||
* @return Command with the specified name or null if a command with that
|
||||
* label doesn't exist
|
||||
*/
|
||||
public Command getCommand(String name);
|
||||
|
||||
|
||||
/**
|
||||
* Looks for the requested command and executes an appropriate
|
||||
* tab-completer if found. This method will also tab-complete partial
|
||||
* commands.
|
||||
*
|
||||
* @param sender The command's sender.
|
||||
* @param cmdLine The entire command string to tab-complete, excluding
|
||||
* initial slash.
|
||||
* @return a list of possible tab-completions. This list may be immutable.
|
||||
* Will be null if no matching command of which sender has permission.
|
||||
* @throws CommandException Thrown when the tab-completer for the given
|
||||
* command fails with an unhandled exception
|
||||
* @throws IllegalArgumentException if either sender or cmdLine are null
|
||||
*/
|
||||
public List<String> tabComplete(CommandSender sender, String cmdLine) throws IllegalArgumentException;
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
package org.bukkit.command;
|
||||
|
||||
import org.bukkit.Server;
|
||||
import org.bukkit.permissions.Permissible;
|
||||
|
||||
public interface CommandSender extends Permissible {
|
||||
|
||||
/**
|
||||
* Sends this sender a message
|
||||
*
|
||||
* @param message Message to be displayed
|
||||
*/
|
||||
public void sendMessage(String message);
|
||||
|
||||
/**
|
||||
* Sends this sender multiple messages
|
||||
*
|
||||
* @param messages An array of messages to be displayed
|
||||
*/
|
||||
public void sendMessage(String[] messages);
|
||||
|
||||
/**
|
||||
* Returns the server instance that this command is running on
|
||||
*
|
||||
* @return Server instance
|
||||
*/
|
||||
public Server getServer();
|
||||
|
||||
/**
|
||||
* Gets the name of this command sender
|
||||
*
|
||||
* @return Name of the sender
|
||||
*/
|
||||
public String getName();
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
package org.bukkit.command;
|
||||
|
||||
import org.bukkit.conversations.Conversable;
|
||||
|
||||
public interface ConsoleCommandSender extends CommandSender, Conversable {
|
||||
}
|
||||
@@ -0,0 +1,124 @@
|
||||
package org.bukkit.command;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.logging.Level;
|
||||
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.event.player.PlayerCommandPreprocessEvent;
|
||||
import org.bukkit.event.server.RemoteServerCommandEvent;
|
||||
import org.bukkit.event.server.ServerCommandEvent;
|
||||
|
||||
public class FormattedCommandAlias extends Command {
|
||||
private final String[] formatStrings;
|
||||
|
||||
public FormattedCommandAlias(String alias, String[] formatStrings) {
|
||||
super(alias);
|
||||
this.formatStrings = formatStrings;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String commandLabel, String[] args) {
|
||||
boolean result = false;
|
||||
ArrayList<String> commands = new ArrayList<String>();
|
||||
for (String formatString : formatStrings) {
|
||||
try {
|
||||
commands.add(buildCommand(formatString, args));
|
||||
} catch (Throwable throwable) {
|
||||
if (throwable instanceof IllegalArgumentException) {
|
||||
sender.sendMessage(throwable.getMessage());
|
||||
} else {
|
||||
sender.sendMessage(org.bukkit.ChatColor.RED + "An internal error occurred while attempting to perform this command");
|
||||
}
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
for (String command : commands) {
|
||||
result |= Bukkit.dispatchCommand(sender, command);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
private String buildCommand(String formatString, String[] args) {
|
||||
int index = formatString.indexOf("$");
|
||||
while (index != -1) {
|
||||
int start = index;
|
||||
|
||||
if (index > 0 && formatString.charAt(start - 1) == '\\') {
|
||||
formatString = formatString.substring(0, start - 1) + formatString.substring(start);
|
||||
index = formatString.indexOf("$", index);
|
||||
continue;
|
||||
}
|
||||
|
||||
boolean required = false;
|
||||
if (formatString.charAt(index + 1) == '$') {
|
||||
required = true;
|
||||
// Move index past the second $
|
||||
index++;
|
||||
}
|
||||
|
||||
// Move index past the $
|
||||
index++;
|
||||
int argStart = index;
|
||||
while (index < formatString.length() && inRange(((int) formatString.charAt(index)) - 48, 0, 9)) {
|
||||
// Move index past current digit
|
||||
index++;
|
||||
}
|
||||
|
||||
// No numbers found
|
||||
if (argStart == index) {
|
||||
throw new IllegalArgumentException("Invalid replacement token");
|
||||
}
|
||||
|
||||
int position = Integer.valueOf(formatString.substring(argStart, index));
|
||||
|
||||
// Arguments are not 0 indexed
|
||||
if (position == 0) {
|
||||
throw new IllegalArgumentException("Invalid replacement token");
|
||||
}
|
||||
|
||||
// Convert position to 0 index
|
||||
position--;
|
||||
|
||||
boolean rest = false;
|
||||
if (index < formatString.length() && formatString.charAt(index) == '-') {
|
||||
rest = true;
|
||||
// Move index past the -
|
||||
index++;
|
||||
}
|
||||
|
||||
int end = index;
|
||||
|
||||
if (required && position >= args.length) {
|
||||
throw new IllegalArgumentException("Missing required argument " + (position + 1));
|
||||
}
|
||||
|
||||
StringBuilder replacement = new StringBuilder();
|
||||
if (rest && position < args.length) {
|
||||
for (int i = position; i < args.length; i++) {
|
||||
if (i != position) {
|
||||
replacement.append(' ');
|
||||
}
|
||||
replacement.append(args[i]);
|
||||
}
|
||||
} else if (position < args.length) {
|
||||
replacement.append(args[position]);
|
||||
}
|
||||
|
||||
formatString = formatString.substring(0, start) + replacement.toString() + formatString.substring(end);
|
||||
// Move index past the replaced data so we don't process it again
|
||||
index = start + replacement.length();
|
||||
|
||||
// Move to the next replacement token
|
||||
index = formatString.indexOf("$", index);
|
||||
}
|
||||
|
||||
return formatString;
|
||||
}
|
||||
|
||||
private static boolean inRange(int i, int j, int k) {
|
||||
return i >= j && i <= k;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
package org.bukkit.command;
|
||||
|
||||
/**
|
||||
* Represents a command that delegates to one or more other commands
|
||||
*/
|
||||
public class MultipleCommandAlias extends Command {
|
||||
private Command[] commands;
|
||||
|
||||
public MultipleCommandAlias(String name, Command[] commands) {
|
||||
super(name);
|
||||
this.commands = commands;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the commands associated with the multi-command alias.
|
||||
*
|
||||
* @return commands associated with alias
|
||||
*/
|
||||
public Command[] getCommands() {
|
||||
return commands;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String commandLabel, String[] args) {
|
||||
boolean result = false;
|
||||
|
||||
for (Command command : commands) {
|
||||
result |= command.execute(sender, commandLabel, args);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,160 @@
|
||||
package org.bukkit.command;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.plugin.Plugin;
|
||||
|
||||
/**
|
||||
* Represents a {@link Command} belonging to a plugin
|
||||
*/
|
||||
public final class PluginCommand extends Command implements PluginIdentifiableCommand {
|
||||
private final Plugin owningPlugin;
|
||||
private CommandExecutor executor;
|
||||
private TabCompleter completer;
|
||||
|
||||
protected PluginCommand(String name, Plugin owner) {
|
||||
super(name);
|
||||
this.executor = owner;
|
||||
this.owningPlugin = owner;
|
||||
this.usageMessage = "";
|
||||
}
|
||||
|
||||
/**
|
||||
* Executes the command, returning its success
|
||||
*
|
||||
* @param sender Source object which is executing this command
|
||||
* @param commandLabel The alias of the command used
|
||||
* @param args All arguments passed to the command, split via ' '
|
||||
* @return true if the command was successful, otherwise false
|
||||
*/
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String commandLabel, String[] args) {
|
||||
boolean success = false;
|
||||
|
||||
if (!owningPlugin.isEnabled()) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!testPermission(sender)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
try {
|
||||
success = executor.onCommand(sender, this, commandLabel, args);
|
||||
} catch (Throwable ex) {
|
||||
throw new CommandException("Unhandled exception executing command '" + commandLabel + "' in plugin " + owningPlugin.getDescription().getFullName(), ex);
|
||||
}
|
||||
|
||||
if (!success && usageMessage.length() > 0) {
|
||||
for (String line : usageMessage.replace("<command>", commandLabel).split("\n")) {
|
||||
sender.sendMessage(line);
|
||||
}
|
||||
}
|
||||
|
||||
return success;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the {@link CommandExecutor} to run when parsing this command
|
||||
*
|
||||
* @param executor New executor to run
|
||||
*/
|
||||
public void setExecutor(CommandExecutor executor) {
|
||||
this.executor = executor == null ? owningPlugin : executor;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the {@link CommandExecutor} associated with this command
|
||||
*
|
||||
* @return CommandExecutor object linked to this command
|
||||
*/
|
||||
public CommandExecutor getExecutor() {
|
||||
return executor;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the {@link TabCompleter} to run when tab-completing this command.
|
||||
* <p>
|
||||
* If no TabCompleter is specified, and the command's executor implements
|
||||
* TabCompleter, then the executor will be used for tab completion.
|
||||
*
|
||||
* @param completer New tab completer
|
||||
*/
|
||||
public void setTabCompleter(TabCompleter completer) {
|
||||
this.completer = completer;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the {@link TabCompleter} associated with this command.
|
||||
*
|
||||
* @return TabCompleter object linked to this command
|
||||
*/
|
||||
public TabCompleter getTabCompleter() {
|
||||
return completer;
|
||||
}
|
||||
|
||||
/**
|
||||
* Gets the owner of this PluginCommand
|
||||
*
|
||||
* @return Plugin that owns this command
|
||||
*/
|
||||
public Plugin getPlugin() {
|
||||
return owningPlugin;
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
* <p>
|
||||
* Delegates to the tab completer if present.
|
||||
* <p>
|
||||
* If it is not present or returns null, will delegate to the current
|
||||
* command executor if it implements {@link TabCompleter}. If a non-null
|
||||
* list has not been found, will default to standard player name
|
||||
* completion in {@link
|
||||
* Command#tabComplete(CommandSender, String, String[])}.
|
||||
* <p>
|
||||
* This method does not consider permissions.
|
||||
*
|
||||
* @throws CommandException if the completer or executor throw an
|
||||
* exception during the process of tab-completing.
|
||||
* @throws IllegalArgumentException if sender, alias, or args is null
|
||||
*/
|
||||
@Override
|
||||
public java.util.List<String> tabComplete(CommandSender sender, String alias, String[] args) throws CommandException, IllegalArgumentException {
|
||||
Validate.notNull(sender, "Sender cannot be null");
|
||||
Validate.notNull(args, "Arguments cannot be null");
|
||||
Validate.notNull(alias, "Alias cannot be null");
|
||||
|
||||
List<String> completions = null;
|
||||
try {
|
||||
if (completer != null) {
|
||||
completions = completer.onTabComplete(sender, this, alias, args);
|
||||
}
|
||||
if (completions == null && executor instanceof TabCompleter) {
|
||||
completions = ((TabCompleter) executor).onTabComplete(sender, this, alias, args);
|
||||
}
|
||||
} catch (Throwable ex) {
|
||||
StringBuilder message = new StringBuilder();
|
||||
message.append("Unhandled exception during tab completion for command '/").append(alias).append(' ');
|
||||
for (String arg : args) {
|
||||
message.append(arg).append(' ');
|
||||
}
|
||||
message.deleteCharAt(message.length() - 1).append("' in plugin ").append(owningPlugin.getDescription().getFullName());
|
||||
throw new CommandException(message.toString(), ex);
|
||||
}
|
||||
|
||||
if (completions == null) {
|
||||
return super.tabComplete(sender, alias, args);
|
||||
}
|
||||
return completions;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
StringBuilder stringBuilder = new StringBuilder(super.toString());
|
||||
stringBuilder.deleteCharAt(stringBuilder.length() - 1);
|
||||
stringBuilder.append(", ").append(owningPlugin.getDescription().getFullName()).append(')');
|
||||
return stringBuilder.toString();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
package org.bukkit.command;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Map.Entry;
|
||||
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.plugin.Plugin;
|
||||
|
||||
public class PluginCommandYamlParser {
|
||||
|
||||
public static List<Command> parse(Plugin plugin) {
|
||||
List<Command> pluginCmds = new ArrayList<Command>();
|
||||
|
||||
Map<String, Map<String, Object>> map = plugin.getDescription().getCommands();
|
||||
|
||||
if (map == null) {
|
||||
return pluginCmds;
|
||||
}
|
||||
|
||||
for (Entry<String, Map<String, Object>> entry : map.entrySet()) {
|
||||
if (entry.getKey().contains(":")) {
|
||||
Bukkit.getServer().getLogger().severe("Could not load command " + entry.getKey() + " for plugin " + plugin.getName() + ": Illegal Characters");
|
||||
continue;
|
||||
}
|
||||
Command newCmd = new PluginCommand(entry.getKey(), plugin);
|
||||
Object description = entry.getValue().get("description");
|
||||
Object usage = entry.getValue().get("usage");
|
||||
Object aliases = entry.getValue().get("aliases");
|
||||
Object permission = entry.getValue().get("permission");
|
||||
Object permissionMessage = entry.getValue().get("permission-message");
|
||||
|
||||
if (description != null) {
|
||||
newCmd.setDescription(description.toString());
|
||||
}
|
||||
|
||||
if (usage != null) {
|
||||
newCmd.setUsage(usage.toString());
|
||||
}
|
||||
|
||||
if (aliases != null) {
|
||||
List<String> aliasList = new ArrayList<String>();
|
||||
|
||||
if (aliases instanceof List) {
|
||||
for (Object o : (List<?>) aliases) {
|
||||
if (o.toString().contains(":")) {
|
||||
Bukkit.getServer().getLogger().severe("Could not load alias " + o.toString() + " for plugin " + plugin.getName() + ": Illegal Characters");
|
||||
continue;
|
||||
}
|
||||
aliasList.add(o.toString());
|
||||
}
|
||||
} else {
|
||||
if (aliases.toString().contains(":")) {
|
||||
Bukkit.getServer().getLogger().severe("Could not load alias " + aliases.toString() + " for plugin " + plugin.getName() + ": Illegal Characters");
|
||||
} else {
|
||||
aliasList.add(aliases.toString());
|
||||
}
|
||||
}
|
||||
|
||||
newCmd.setAliases(aliasList);
|
||||
}
|
||||
|
||||
if (permission != null) {
|
||||
newCmd.setPermission(permission.toString());
|
||||
}
|
||||
|
||||
if (permissionMessage != null) {
|
||||
newCmd.setPermissionMessage(permissionMessage.toString());
|
||||
}
|
||||
|
||||
pluginCmds.add(newCmd);
|
||||
}
|
||||
return pluginCmds;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
package org.bukkit.command;
|
||||
|
||||
import org.bukkit.plugin.Plugin;
|
||||
|
||||
/**
|
||||
* This interface is used by the help system to group commands into
|
||||
* sub-indexes based on the {@link Plugin} they are a part of. Custom command
|
||||
* implementations will need to implement this interface to have a sub-index
|
||||
* automatically generated on the plugin's behalf.
|
||||
*/
|
||||
public interface PluginIdentifiableCommand {
|
||||
|
||||
/**
|
||||
* Gets the owner of this PluginIdentifiableCommand.
|
||||
*
|
||||
* @return Plugin that owns this PluginIdentifiableCommand.
|
||||
*/
|
||||
public Plugin getPlugin();
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
package org.bukkit.command;
|
||||
|
||||
public interface RemoteConsoleCommandSender extends CommandSender {
|
||||
}
|
||||
@@ -0,0 +1,301 @@
|
||||
package org.bukkit.command;
|
||||
|
||||
import static org.bukkit.util.Java15Compat.Arrays_copyOfRange;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collection;
|
||||
import java.util.Collections;
|
||||
import java.util.HashMap;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.Server;
|
||||
import org.bukkit.command.defaults.*;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.util.StringUtil;
|
||||
|
||||
public class SimpleCommandMap implements CommandMap {
|
||||
private static final Pattern PATTERN_ON_SPACE = Pattern.compile(" ", Pattern.LITERAL);
|
||||
protected final Map<String, Command> knownCommands = new HashMap<String, Command>();
|
||||
private final Server server;
|
||||
|
||||
public SimpleCommandMap(final Server server) {
|
||||
this.server = server;
|
||||
setDefaultCommands();
|
||||
}
|
||||
|
||||
private void setDefaultCommands() {
|
||||
register("bukkit", new SaveCommand());
|
||||
register("bukkit", new SaveOnCommand());
|
||||
register("bukkit", new SaveOffCommand());
|
||||
register("bukkit", new StopCommand());
|
||||
register("bukkit", new VersionCommand("version"));
|
||||
register("bukkit", new ReloadCommand("reload"));
|
||||
register("bukkit", new PluginsCommand("plugins"));
|
||||
register("bukkit", new TimingsCommand("timings"));
|
||||
}
|
||||
|
||||
public void setFallbackCommands() {
|
||||
register("bukkit", new ListCommand());
|
||||
register("bukkit", new OpCommand());
|
||||
register("bukkit", new DeopCommand());
|
||||
register("bukkit", new BanIpCommand());
|
||||
register("bukkit", new PardonIpCommand());
|
||||
register("bukkit", new BanCommand());
|
||||
register("bukkit", new PardonCommand());
|
||||
register("bukkit", new KickCommand());
|
||||
register("bukkit", new TeleportCommand());
|
||||
register("bukkit", new GiveCommand());
|
||||
register("bukkit", new TimeCommand());
|
||||
register("bukkit", new SayCommand());
|
||||
register("bukkit", new WhitelistCommand());
|
||||
register("bukkit", new TellCommand());
|
||||
register("bukkit", new MeCommand());
|
||||
register("bukkit", new KillCommand());
|
||||
register("bukkit", new GameModeCommand());
|
||||
register("bukkit", new HelpCommand());
|
||||
register("bukkit", new ExpCommand());
|
||||
register("bukkit", new ToggleDownfallCommand());
|
||||
register("bukkit", new BanListCommand());
|
||||
register("bukkit", new DefaultGameModeCommand());
|
||||
register("bukkit", new SeedCommand());
|
||||
register("bukkit", new DifficultyCommand());
|
||||
register("bukkit", new WeatherCommand());
|
||||
register("bukkit", new SpawnpointCommand());
|
||||
register("bukkit", new ClearCommand());
|
||||
register("bukkit", new GameRuleCommand());
|
||||
register("bukkit", new EnchantCommand());
|
||||
register("bukkit", new TestForCommand());
|
||||
register("bukkit", new EffectCommand());
|
||||
register("bukkit", new ScoreboardCommand());
|
||||
register("bukkit", new PlaySoundCommand());
|
||||
register("bukkit", new SpreadPlayersCommand());
|
||||
register("bukkit", new SetWorldSpawnCommand());
|
||||
register("bukkit", new SetIdleTimeoutCommand());
|
||||
register("bukkit", new AchievementCommand());
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public void registerAll(String fallbackPrefix, List<Command> commands) {
|
||||
if (commands != null) {
|
||||
for (Command c : commands) {
|
||||
register(fallbackPrefix, c);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public boolean register(String fallbackPrefix, Command command) {
|
||||
return register(command.getName(), fallbackPrefix, command);
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public boolean register(String label, String fallbackPrefix, Command command) {
|
||||
label = label.toLowerCase().trim();
|
||||
fallbackPrefix = fallbackPrefix.toLowerCase().trim();
|
||||
boolean registered = register(label, command, false, fallbackPrefix);
|
||||
|
||||
Iterator<String> iterator = command.getAliases().iterator();
|
||||
while (iterator.hasNext()) {
|
||||
if (!register(iterator.next(), command, true, fallbackPrefix)) {
|
||||
iterator.remove();
|
||||
}
|
||||
}
|
||||
|
||||
// If we failed to register under the real name, we need to set the command label to the direct address
|
||||
if (!registered) {
|
||||
command.setLabel(fallbackPrefix + ":" + label);
|
||||
}
|
||||
|
||||
// Register to us so further updates of the commands label and aliases are postponed until its reregistered
|
||||
command.register(this);
|
||||
|
||||
return registered;
|
||||
}
|
||||
|
||||
/**
|
||||
* Registers a command with the given name is possible. Also uses
|
||||
* fallbackPrefix to create a unique name.
|
||||
*
|
||||
* @param label the name of the command, without the '/'-prefix.
|
||||
* @param command the command to register
|
||||
* @param isAlias whether the command is an alias
|
||||
* @param fallbackPrefix a prefix which is prepended to the command for a
|
||||
* unique address
|
||||
* @return true if command was registered, false otherwise.
|
||||
*/
|
||||
private synchronized boolean register(String label, Command command, boolean isAlias, String fallbackPrefix) {
|
||||
knownCommands.put(fallbackPrefix + ":" + label, command);
|
||||
if ((command instanceof VanillaCommand || isAlias) && knownCommands.containsKey(label)) {
|
||||
// Request is for an alias/fallback command and it conflicts with
|
||||
// a existing command or previous alias ignore it
|
||||
// Note: This will mean it gets removed from the commands list of active aliases
|
||||
return false;
|
||||
}
|
||||
|
||||
boolean registered = true;
|
||||
|
||||
// If the command exists but is an alias we overwrite it, otherwise we return
|
||||
Command conflict = knownCommands.get(label);
|
||||
if (conflict != null && conflict.getLabel().equals(label)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!isAlias) {
|
||||
command.setLabel(label);
|
||||
}
|
||||
knownCommands.put(label, command);
|
||||
|
||||
return registered;
|
||||
}
|
||||
|
||||
/**
|
||||
* {@inheritDoc}
|
||||
*/
|
||||
public boolean dispatch(CommandSender sender, String commandLine) throws CommandException {
|
||||
String[] args = PATTERN_ON_SPACE.split(commandLine);
|
||||
|
||||
if (args.length == 0) {
|
||||
return false;
|
||||
}
|
||||
|
||||
String sentCommandLabel = args[0].toLowerCase();
|
||||
Command target = getCommand(sentCommandLabel);
|
||||
|
||||
if (target == null) {
|
||||
return false;
|
||||
}
|
||||
|
||||
try {
|
||||
// Note: we don't return the result of target.execute as thats success / failure, we return handled (true) or not handled (false)
|
||||
target.execute(sender, sentCommandLabel, Arrays_copyOfRange(args, 1, args.length));
|
||||
} catch (CommandException ex) {
|
||||
throw ex;
|
||||
} catch (Throwable ex) {
|
||||
throw new CommandException("Unhandled exception executing '" + commandLine + "' in " + target, ex);
|
||||
}
|
||||
|
||||
// return true as command was handled
|
||||
return true;
|
||||
}
|
||||
|
||||
public synchronized void clearCommands() {
|
||||
for (Map.Entry<String, Command> entry : knownCommands.entrySet()) {
|
||||
entry.getValue().unregister(this);
|
||||
}
|
||||
knownCommands.clear();
|
||||
setDefaultCommands();
|
||||
}
|
||||
|
||||
public Command getCommand(String name) {
|
||||
Command target = knownCommands.get(name.toLowerCase());
|
||||
return target;
|
||||
}
|
||||
|
||||
public List<String> tabComplete(CommandSender sender, String cmdLine) {
|
||||
Validate.notNull(sender, "Sender cannot be null");
|
||||
Validate.notNull(cmdLine, "Command line cannot null");
|
||||
|
||||
int spaceIndex = cmdLine.indexOf(' ');
|
||||
|
||||
if (spaceIndex == -1) {
|
||||
ArrayList<String> completions = new ArrayList<String>();
|
||||
Map<String, Command> knownCommands = this.knownCommands;
|
||||
|
||||
final String prefix = (sender instanceof Player ? "/" : "");
|
||||
|
||||
for (Map.Entry<String, Command> commandEntry : knownCommands.entrySet()) {
|
||||
Command command = commandEntry.getValue();
|
||||
|
||||
if (!command.testPermissionSilent(sender)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
String name = commandEntry.getKey(); // Use the alias, not command name
|
||||
|
||||
if (StringUtil.startsWithIgnoreCase(name, cmdLine)) {
|
||||
completions.add(prefix + name);
|
||||
}
|
||||
}
|
||||
|
||||
Collections.sort(completions, String.CASE_INSENSITIVE_ORDER);
|
||||
return completions;
|
||||
}
|
||||
|
||||
String commandName = cmdLine.substring(0, spaceIndex);
|
||||
Command target = getCommand(commandName);
|
||||
|
||||
if (target == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
if (!target.testPermissionSilent(sender)) {
|
||||
return null;
|
||||
}
|
||||
|
||||
String argLine = cmdLine.substring(spaceIndex + 1, cmdLine.length());
|
||||
String[] args = PATTERN_ON_SPACE.split(argLine, -1);
|
||||
|
||||
try {
|
||||
return target.tabComplete(sender, commandName, args);
|
||||
} catch (CommandException ex) {
|
||||
throw ex;
|
||||
} catch (Throwable ex) {
|
||||
throw new CommandException("Unhandled exception executing tab-completer for '" + cmdLine + "' in " + target, ex);
|
||||
}
|
||||
}
|
||||
|
||||
public Collection<Command> getCommands() {
|
||||
return Collections.unmodifiableCollection(knownCommands.values());
|
||||
}
|
||||
|
||||
public void registerServerAliases() {
|
||||
Map<String, String[]> values = server.getCommandAliases();
|
||||
|
||||
for (String alias : values.keySet()) {
|
||||
if (alias.contains(":") || alias.contains(" ")) {
|
||||
server.getLogger().warning("Could not register alias " + alias + " because it contains illegal characters");
|
||||
continue;
|
||||
}
|
||||
|
||||
String[] commandStrings = values.get(alias);
|
||||
List<String> targets = new ArrayList<String>();
|
||||
StringBuilder bad = new StringBuilder();
|
||||
|
||||
for (String commandString : commandStrings) {
|
||||
String[] commandArgs = commandString.split(" ");
|
||||
Command command = getCommand(commandArgs[0]);
|
||||
|
||||
if (command == null) {
|
||||
if (bad.length() > 0) {
|
||||
bad.append(", ");
|
||||
}
|
||||
bad.append(commandString);
|
||||
} else {
|
||||
targets.add(commandString);
|
||||
}
|
||||
}
|
||||
|
||||
if (bad.length() > 0) {
|
||||
server.getLogger().warning("Could not register alias " + alias + " because it contains commands that do not exist: " + bad);
|
||||
continue;
|
||||
}
|
||||
|
||||
// We register these as commands so they have absolute priority.
|
||||
if (targets.size() > 0) {
|
||||
knownCommands.put(alias.toLowerCase(), new FormattedCommandAlias(alias.toLowerCase(), targets.toArray(new String[targets.size()])));
|
||||
} else {
|
||||
knownCommands.remove(alias.toLowerCase());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,16 @@
|
||||
package org.bukkit.command;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Represents a class which can handle command tab completion and commands
|
||||
*
|
||||
* @deprecated Remains for plugins that would have implemented it even without
|
||||
* functionality
|
||||
* @see TabExecutor
|
||||
*/
|
||||
@Deprecated
|
||||
public interface TabCommandExecutor extends CommandExecutor {
|
||||
public List<String> onTabComplete();
|
||||
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
package org.bukkit.command;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Represents a class which can suggest tab completions for commands.
|
||||
*/
|
||||
public interface TabCompleter {
|
||||
|
||||
/**
|
||||
* Requests a list of possible completions for a command argument.
|
||||
*
|
||||
* @param sender Source of the command
|
||||
* @param command Command which was executed
|
||||
* @param alias The alias used
|
||||
* @param args The arguments passed to the command, including final
|
||||
* partial argument to be completed and command label
|
||||
* @return A List of possible completions for the final argument, or null
|
||||
* to default to the command executor
|
||||
*/
|
||||
public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args);
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
package org.bukkit.command;
|
||||
|
||||
/**
|
||||
* This class is provided as a convenience to implement both TabCompleter and
|
||||
* CommandExecutor.
|
||||
*/
|
||||
public interface TabExecutor extends TabCompleter, CommandExecutor {
|
||||
}
|
||||
@@ -0,0 +1,187 @@
|
||||
package org.bukkit.command.defaults;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.Achievement;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.Statistic;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.Statistic.Type;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.EntityType;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.event.player.PlayerAchievementAwardedEvent;
|
||||
import org.bukkit.event.player.PlayerStatisticIncrementEvent;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
|
||||
public class AchievementCommand extends VanillaCommand {
|
||||
public AchievementCommand() {
|
||||
super("achievement");
|
||||
this.description = "Gives the specified player an achievement or changes a statistic value. Use '*' to give all achievements.";
|
||||
this.usageMessage = "/achievement give <stat_name> [player]";
|
||||
this.setPermission("bukkit.command.achievement");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String currentAlias, String[] args) {
|
||||
if (!testPermission(sender)) return true;
|
||||
|
||||
if (args.length < 2) {
|
||||
sender.sendMessage(ChatColor.RED + "Usage: " + usageMessage);
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!args[0].equalsIgnoreCase("give")) {
|
||||
sender.sendMessage(ChatColor.RED + "Usage: " + usageMessage);
|
||||
return false;
|
||||
}
|
||||
|
||||
String statisticString = args[1];
|
||||
Player player = null;
|
||||
|
||||
if (args.length > 2) {
|
||||
player = Bukkit.getPlayer(args[1]);
|
||||
} else if (sender instanceof Player) {
|
||||
player = (Player) sender;
|
||||
}
|
||||
|
||||
if (player == null) {
|
||||
sender.sendMessage("You must specify which player you wish to perform this action on.");
|
||||
return true;
|
||||
}
|
||||
|
||||
if (statisticString.equals("*")) {
|
||||
for (Achievement achievement : Achievement.values()) {
|
||||
if (player.hasAchievement(achievement)) {
|
||||
continue;
|
||||
}
|
||||
PlayerAchievementAwardedEvent event = new PlayerAchievementAwardedEvent(player, achievement);
|
||||
Bukkit.getServer().getPluginManager().callEvent(event);
|
||||
if (!event.isCancelled()) {
|
||||
player.awardAchievement(achievement);
|
||||
}
|
||||
}
|
||||
Command.broadcastCommandMessage(sender, String.format("Successfully given all achievements to %s", player.getName()));
|
||||
return true;
|
||||
}
|
||||
|
||||
Achievement achievement = Bukkit.getUnsafe().getAchievementFromInternalName(statisticString);
|
||||
Statistic statistic = Bukkit.getUnsafe().getStatisticFromInternalName(statisticString);
|
||||
|
||||
if (achievement != null) {
|
||||
if (player.hasAchievement(achievement)) {
|
||||
sender.sendMessage(String.format("%s already has achievement %s", player.getName(), statisticString));
|
||||
return true;
|
||||
}
|
||||
|
||||
PlayerAchievementAwardedEvent event = new PlayerAchievementAwardedEvent(player, achievement);
|
||||
Bukkit.getServer().getPluginManager().callEvent(event);
|
||||
if (event.isCancelled()) {
|
||||
sender.sendMessage(String.format("Unable to award %s the achievement %s", player.getName(), statisticString));
|
||||
return true;
|
||||
}
|
||||
player.awardAchievement(achievement);
|
||||
|
||||
Command.broadcastCommandMessage(sender, String.format("Successfully given %s the stat %s", player.getName(), statisticString));
|
||||
return true;
|
||||
}
|
||||
|
||||
if (statistic == null) {
|
||||
sender.sendMessage(String.format("Unknown achievement or statistic '%s'", statisticString));
|
||||
return true;
|
||||
}
|
||||
|
||||
if (statistic.getType() == Type.UNTYPED) {
|
||||
PlayerStatisticIncrementEvent event = new PlayerStatisticIncrementEvent(player, statistic, player.getStatistic(statistic), player.getStatistic(statistic) + 1);
|
||||
Bukkit.getServer().getPluginManager().callEvent(event);
|
||||
if (event.isCancelled()) {
|
||||
sender.sendMessage(String.format("Unable to increment %s for %s", statisticString, player.getName()));
|
||||
return true;
|
||||
}
|
||||
player.incrementStatistic(statistic);
|
||||
Command.broadcastCommandMessage(sender, String.format("Successfully given %s the stat %s", player.getName(), statisticString));
|
||||
return true;
|
||||
}
|
||||
|
||||
if (statistic.getType() == Type.ENTITY) {
|
||||
EntityType entityType = EntityType.fromName(statisticString.substring(statisticString.lastIndexOf(".") + 1));
|
||||
|
||||
if (entityType == null) {
|
||||
sender.sendMessage(String.format("Unknown achievement or statistic '%s'", statisticString));
|
||||
return true;
|
||||
}
|
||||
|
||||
PlayerStatisticIncrementEvent event = new PlayerStatisticIncrementEvent(player, statistic, player.getStatistic(statistic), player.getStatistic(statistic) + 1, entityType);
|
||||
Bukkit.getServer().getPluginManager().callEvent(event);
|
||||
if (event.isCancelled()) {
|
||||
sender.sendMessage(String.format("Unable to increment %s for %s", statisticString, player.getName()));
|
||||
return true;
|
||||
}
|
||||
|
||||
try {
|
||||
player.incrementStatistic(statistic, entityType);
|
||||
} catch (IllegalArgumentException e) {
|
||||
sender.sendMessage(String.format("Unknown achievement or statistic '%s'", statisticString));
|
||||
return true;
|
||||
}
|
||||
} else {
|
||||
int id;
|
||||
try {
|
||||
id = getInteger(sender, statisticString.substring(statisticString.lastIndexOf(".") + 1), 0, Integer.MAX_VALUE, true);
|
||||
} catch (NumberFormatException e) {
|
||||
sender.sendMessage(e.getMessage());
|
||||
return true;
|
||||
}
|
||||
|
||||
Material material = Material.getMaterial(id);
|
||||
|
||||
if (material == null) {
|
||||
sender.sendMessage(String.format("Unknown achievement or statistic '%s'", statisticString));
|
||||
return true;
|
||||
}
|
||||
|
||||
PlayerStatisticIncrementEvent event = new PlayerStatisticIncrementEvent(player, statistic, player.getStatistic(statistic), player.getStatistic(statistic) + 1, material);
|
||||
Bukkit.getServer().getPluginManager().callEvent(event);
|
||||
if (event.isCancelled()) {
|
||||
sender.sendMessage(String.format("Unable to increment %s for %s", statisticString, player.getName()));
|
||||
return true;
|
||||
}
|
||||
|
||||
try {
|
||||
player.incrementStatistic(statistic, material);
|
||||
} catch (IllegalArgumentException e) {
|
||||
sender.sendMessage(String.format("Unknown achievement or statistic '%s'", statisticString));
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
Command.broadcastCommandMessage(sender, String.format("Successfully given %s the stat %s", player.getName(), statisticString));
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> tabComplete(CommandSender sender, String alias, String[] args) throws IllegalArgumentException {
|
||||
Validate.notNull(sender, "Sender cannot be null");
|
||||
Validate.notNull(args, "Arguments cannot be null");
|
||||
Validate.notNull(alias, "Alias cannot be null");
|
||||
|
||||
if (args.length == 1) {
|
||||
return Arrays.asList("give");
|
||||
}
|
||||
|
||||
if (args.length == 2) {
|
||||
return Bukkit.getUnsafe().tabCompleteInternalStatisticOrAchievementName(args[1], new ArrayList<String>());
|
||||
}
|
||||
|
||||
if (args.length == 3) {
|
||||
return super.tabComplete(sender, alias, args);
|
||||
}
|
||||
return ImmutableList.of();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
package org.bukkit.command.defaults;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.apache.commons.lang.StringUtils;
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.BanList;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
|
||||
public class BanCommand extends VanillaCommand {
|
||||
public BanCommand() {
|
||||
super("ban");
|
||||
this.description = "Prevents the specified player from using this server";
|
||||
this.usageMessage = "/ban <player> [reason ...]";
|
||||
this.setPermission("bukkit.command.ban.player");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String currentAlias, String[] args) {
|
||||
if (!testPermission(sender)) return true;
|
||||
if (args.length == 0) {
|
||||
sender.sendMessage(ChatColor.RED + "Usage: " + usageMessage);
|
||||
return false;
|
||||
}
|
||||
|
||||
String reason = args.length > 0 ? StringUtils.join(args, ' ', 1, args.length) : null;
|
||||
Bukkit.getBanList(BanList.Type.NAME).addBan(args[0], reason, null, sender.getName());
|
||||
|
||||
Player player = Bukkit.getPlayer(args[0]);
|
||||
if (player != null) {
|
||||
player.kickPlayer("Banned by admin.");
|
||||
}
|
||||
|
||||
Command.broadcastCommandMessage(sender, "Banned player " + args[0]);
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> tabComplete(CommandSender sender, String alias, String[] args) throws IllegalArgumentException {
|
||||
Validate.notNull(sender, "Sender cannot be null");
|
||||
Validate.notNull(args, "Arguments cannot be null");
|
||||
Validate.notNull(alias, "Alias cannot be null");
|
||||
|
||||
if (args.length >= 1) {
|
||||
return super.tabComplete(sender, alias, args);
|
||||
}
|
||||
return ImmutableList.of();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
package org.bukkit.command.defaults;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
import org.apache.commons.lang.StringUtils;
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.BanList;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
|
||||
public class BanIpCommand extends VanillaCommand {
|
||||
public static final Pattern ipValidity = Pattern.compile("^([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])\\.([01]?\\d\\d?|2[0-4]\\d|25[0-5])$");
|
||||
|
||||
public BanIpCommand() {
|
||||
super("ban-ip");
|
||||
this.description = "Prevents the specified IP address from using this server";
|
||||
this.usageMessage = "/ban-ip <address|player> [reason ...]";
|
||||
this.setPermission("bukkit.command.ban.ip");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String currentAlias, String[] args) {
|
||||
if (!testPermission(sender)) return true;
|
||||
if (args.length < 1) {
|
||||
sender.sendMessage(ChatColor.RED + "Usage: " + usageMessage);
|
||||
return false;
|
||||
}
|
||||
|
||||
String reason = args.length > 0 ? StringUtils.join(args, ' ', 1, args.length) : null;
|
||||
|
||||
if (ipValidity.matcher(args[0]).matches()) {
|
||||
processIPBan(args[0], sender, reason);
|
||||
} else {
|
||||
Player player = Bukkit.getPlayer(args[0]);
|
||||
|
||||
if (player == null) {
|
||||
sender.sendMessage(ChatColor.RED + "Usage: " + usageMessage);
|
||||
return false;
|
||||
}
|
||||
|
||||
processIPBan(player.getAddress().getAddress().getHostAddress(), sender, reason);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
private void processIPBan(String ip, CommandSender sender, String reason) {
|
||||
Bukkit.getBanList(BanList.Type.IP).addBan(ip, reason, null, sender.getName());
|
||||
|
||||
// Find all matching players and kick
|
||||
for (Player player : Bukkit.getOnlinePlayers()) {
|
||||
if (player.getAddress().getAddress().getHostAddress().equals(ip)) {
|
||||
player.kickPlayer("You have been IP banned.");
|
||||
}
|
||||
}
|
||||
|
||||
Command.broadcastCommandMessage(sender, "Banned IP Address " + ip);
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> tabComplete(CommandSender sender, String alias, String[] args) throws IllegalArgumentException {
|
||||
Validate.notNull(sender, "Sender cannot be null");
|
||||
Validate.notNull(args, "Arguments cannot be null");
|
||||
Validate.notNull(alias, "Alias cannot be null");
|
||||
|
||||
if (args.length == 1) {
|
||||
return super.tabComplete(sender, alias, args);
|
||||
}
|
||||
return ImmutableList.of();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,73 @@
|
||||
package org.bukkit.command.defaults;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.BanEntry;
|
||||
import org.bukkit.BanList;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.OfflinePlayer;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.util.StringUtil;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
|
||||
public class BanListCommand extends VanillaCommand {
|
||||
private static final List<String> BANLIST_TYPES = ImmutableList.of("ips", "players");
|
||||
|
||||
public BanListCommand() {
|
||||
super("banlist");
|
||||
this.description = "View all players banned from this server";
|
||||
this.usageMessage = "/banlist [ips|players]";
|
||||
this.setPermission("bukkit.command.ban.list");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String currentAlias, String[] args) {
|
||||
if (!testPermission(sender)) return true;
|
||||
|
||||
BanList.Type banType = BanList.Type.NAME;
|
||||
if (args.length > 0) {
|
||||
if (args[0].equalsIgnoreCase("ips")) {
|
||||
banType = BanList.Type.IP;
|
||||
} else if (!args[0].equalsIgnoreCase("players")) {
|
||||
sender.sendMessage(ChatColor.RED + "Usage: " + usageMessage);
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
StringBuilder message = new StringBuilder();
|
||||
BanEntry[] banlist = Bukkit.getBanList(banType).getBanEntries().toArray(new BanEntry[0]);
|
||||
|
||||
for (int x = 0; x < banlist.length; x++) {
|
||||
if (x != 0) {
|
||||
if (x == banlist.length - 1) {
|
||||
message.append(" and ");
|
||||
} else {
|
||||
message.append(", ");
|
||||
}
|
||||
}
|
||||
|
||||
message.append(banlist[x].getTarget());
|
||||
}
|
||||
|
||||
sender.sendMessage("There are " + banlist.length + " total banned players:");
|
||||
sender.sendMessage(message.toString());
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> tabComplete(CommandSender sender, String alias, String[] args) {
|
||||
Validate.notNull(sender, "Sender cannot be null");
|
||||
Validate.notNull(args, "Arguments cannot be null");
|
||||
Validate.notNull(alias, "Alias cannot be null");
|
||||
|
||||
if (args.length == 1) {
|
||||
return StringUtil.copyPartialMatches(args[0], BANLIST_TYPES, new ArrayList<String>(BANLIST_TYPES.size()));
|
||||
}
|
||||
return ImmutableList.of();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
package org.bukkit.command.defaults;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.bukkit.command.Command;
|
||||
|
||||
public abstract class BukkitCommand extends Command {
|
||||
protected BukkitCommand(String name) {
|
||||
super(name);
|
||||
}
|
||||
|
||||
protected BukkitCommand(String name, String description, String usageMessage, List<String> aliases) {
|
||||
super(name, description, usageMessage, aliases);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,114 @@
|
||||
package org.bukkit.command.defaults;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.util.StringUtil;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
|
||||
public class ClearCommand extends VanillaCommand {
|
||||
private static List<String> materials;
|
||||
static {
|
||||
ArrayList<String> materialList = new ArrayList<String>();
|
||||
for (Material material : Material.values()) {
|
||||
materialList.add(material.name());
|
||||
}
|
||||
Collections.sort(materialList);
|
||||
materials = ImmutableList.copyOf(materialList);
|
||||
}
|
||||
|
||||
public ClearCommand() {
|
||||
super("clear");
|
||||
this.description = "Clears the player's inventory. Can specify item and data filters too.";
|
||||
this.usageMessage = "/clear <player> [item] [data]";
|
||||
this.setPermission("bukkit.command.clear");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String currentAlias, String[] args) {
|
||||
if (!testPermission(sender)) return true;
|
||||
|
||||
Player player = null;
|
||||
if (args.length > 0) {
|
||||
player = Bukkit.getPlayer(args[0]);
|
||||
} else if (sender instanceof Player) {
|
||||
player = (Player) sender;
|
||||
}
|
||||
|
||||
if (player != null) {
|
||||
int id;
|
||||
|
||||
if (args.length > 1 && !(args[1].equals("-1"))) {
|
||||
Material material = Material.matchMaterial(args[1]);
|
||||
if (material == null) {
|
||||
sender.sendMessage(ChatColor.RED + "There's no item called " + args[1]);
|
||||
return false;
|
||||
}
|
||||
|
||||
id = material.getId();
|
||||
} else {
|
||||
id = -1;
|
||||
}
|
||||
|
||||
int data = args.length >= 3 ? getInteger(sender, args[2], 0) : -1;
|
||||
int count = player.getInventory().clear(id, data);
|
||||
|
||||
Command.broadcastCommandMessage(sender, "Cleared the inventory of " + player.getDisplayName() + ", removing " + count + " items");
|
||||
} else if (args.length == 0) {
|
||||
sender.sendMessage(ChatColor.RED + "Please provide a player!");
|
||||
} else {
|
||||
sender.sendMessage(ChatColor.RED + "Can't find player " + args[0]);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> tabComplete(CommandSender sender, String alias, String[] args) throws IllegalArgumentException {
|
||||
Validate.notNull(sender, "Sender cannot be null");
|
||||
Validate.notNull(args, "Arguments cannot be null");
|
||||
Validate.notNull(alias, "Alias cannot be null");
|
||||
|
||||
if (args.length == 1) {
|
||||
return super.tabComplete(sender, alias, args);
|
||||
}
|
||||
if (args.length == 2) {
|
||||
final String arg = args[1];
|
||||
final List<String> materials = ClearCommand.materials;
|
||||
List<String> completion = null;
|
||||
|
||||
final int size = materials.size();
|
||||
int i = Collections.binarySearch(materials, arg, String.CASE_INSENSITIVE_ORDER);
|
||||
|
||||
if (i < 0) {
|
||||
// Insertion (start) index
|
||||
i = -1 - i;
|
||||
}
|
||||
|
||||
for ( ; i < size; i++) {
|
||||
String material = materials.get(i);
|
||||
if (StringUtil.startsWithIgnoreCase(material, arg)) {
|
||||
if (completion == null) {
|
||||
completion = new ArrayList<String>();
|
||||
}
|
||||
completion.add(material);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (completion != null) {
|
||||
return completion;
|
||||
}
|
||||
}
|
||||
return ImmutableList.of();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,70 @@
|
||||
package org.bukkit.command.defaults;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.GameMode;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.util.StringUtil;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
|
||||
public class DefaultGameModeCommand extends VanillaCommand {
|
||||
private static final List<String> GAMEMODE_NAMES = ImmutableList.of("adventure", "creative", "survival");
|
||||
|
||||
public DefaultGameModeCommand() {
|
||||
super("defaultgamemode");
|
||||
this.description = "Set the default gamemode";
|
||||
this.usageMessage = "/defaultgamemode <mode>";
|
||||
this.setPermission("bukkit.command.defaultgamemode");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String commandLabel, String[] args) {
|
||||
if (!testPermission(sender)) return true;
|
||||
if (args.length == 0) {
|
||||
sender.sendMessage("Usage: " + usageMessage);
|
||||
return false;
|
||||
}
|
||||
|
||||
String modeArg = args[0];
|
||||
int value = -1;
|
||||
|
||||
try {
|
||||
value = Integer.parseInt(modeArg);
|
||||
} catch (NumberFormatException ex) {}
|
||||
|
||||
GameMode mode = GameMode.getByValue(value);
|
||||
|
||||
if (mode == null) {
|
||||
if (modeArg.equalsIgnoreCase("creative") || modeArg.equalsIgnoreCase("c")) {
|
||||
mode = GameMode.CREATIVE;
|
||||
} else if (modeArg.equalsIgnoreCase("adventure") || modeArg.equalsIgnoreCase("a")) {
|
||||
mode = GameMode.ADVENTURE;
|
||||
} else {
|
||||
mode = GameMode.SURVIVAL;
|
||||
}
|
||||
}
|
||||
|
||||
Bukkit.getServer().setDefaultGameMode(mode);
|
||||
Command.broadcastCommandMessage(sender, "Default game mode set to " + mode.toString().toLowerCase());
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> tabComplete(CommandSender sender, String alias, String[] args) {
|
||||
Validate.notNull(sender, "Sender cannot be null");
|
||||
Validate.notNull(args, "Arguments cannot be null");
|
||||
Validate.notNull(alias, "Alias cannot be null");
|
||||
|
||||
if (args.length == 1) {
|
||||
return StringUtil.copyPartialMatches(args[0], GAMEMODE_NAMES, new ArrayList<String>(GAMEMODE_NAMES.size()));
|
||||
}
|
||||
|
||||
return ImmutableList.of();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,62 @@
|
||||
package org.bukkit.command.defaults;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.OfflinePlayer;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.util.StringUtil;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
|
||||
public class DeopCommand extends VanillaCommand {
|
||||
public DeopCommand() {
|
||||
super("deop");
|
||||
this.description = "Takes the specified player's operator status";
|
||||
this.usageMessage = "/deop <player>";
|
||||
this.setPermission("bukkit.command.op.take");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String currentAlias, String[] args) {
|
||||
if (!testPermission(sender)) return true;
|
||||
if (args.length != 1 || args[0].length() == 0) {
|
||||
sender.sendMessage(ChatColor.RED + "Usage: " + usageMessage);
|
||||
return false;
|
||||
}
|
||||
|
||||
OfflinePlayer player = Bukkit.getOfflinePlayer(args[0]);
|
||||
player.setOp(false);
|
||||
|
||||
if (player instanceof Player) {
|
||||
((Player) player).sendMessage(ChatColor.YELLOW + "You are no longer op!");
|
||||
}
|
||||
|
||||
Command.broadcastCommandMessage(sender, "De-opped " + args[0]);
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> tabComplete(CommandSender sender, String alias, String[] args) throws IllegalArgumentException {
|
||||
Validate.notNull(sender, "Sender cannot be null");
|
||||
Validate.notNull(args, "Arguments cannot be null");
|
||||
Validate.notNull(alias, "Alias cannot be null");
|
||||
|
||||
if (args.length == 1) {
|
||||
List<String> completions = new ArrayList<String>();
|
||||
for (OfflinePlayer player : Bukkit.getOfflinePlayers()) {
|
||||
String playerName = player.getName();
|
||||
if (player.isOp() && StringUtil.startsWithIgnoreCase(playerName, args[0])) {
|
||||
completions.add(playerName);
|
||||
}
|
||||
}
|
||||
return completions;
|
||||
}
|
||||
return ImmutableList.of();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
package org.bukkit.command.defaults;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.util.StringUtil;
|
||||
import org.bukkit.Difficulty;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
public class DifficultyCommand extends VanillaCommand {
|
||||
private static final List<String> DIFFICULTY_NAMES = ImmutableList.of("peaceful", "easy", "normal", "hard");
|
||||
|
||||
public DifficultyCommand() {
|
||||
super("difficulty");
|
||||
this.description = "Sets the game difficulty";
|
||||
this.usageMessage = "/difficulty <new difficulty> ";
|
||||
this.setPermission("bukkit.command.difficulty");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String currentAlias, String[] args) {
|
||||
if (!testPermission(sender)) return true;
|
||||
if (args.length != 1 || args[0].length() == 0) {
|
||||
sender.sendMessage(ChatColor.RED + "Usage: " + usageMessage);
|
||||
return false;
|
||||
}
|
||||
|
||||
Difficulty difficulty = Difficulty.getByValue(getDifficultyForString(sender, args[0]));
|
||||
|
||||
if (Bukkit.isHardcore()) {
|
||||
difficulty = Difficulty.HARD;
|
||||
}
|
||||
|
||||
Bukkit.getWorlds().get(0).setDifficulty(difficulty);
|
||||
|
||||
int levelCount = 1;
|
||||
if (Bukkit.getAllowNether()) {
|
||||
Bukkit.getWorlds().get(levelCount).setDifficulty(difficulty);
|
||||
levelCount++;
|
||||
}
|
||||
|
||||
if (Bukkit.getAllowEnd()) {
|
||||
Bukkit.getWorlds().get(levelCount).setDifficulty(difficulty);
|
||||
}
|
||||
|
||||
Command.broadcastCommandMessage(sender, "Set difficulty to " + difficulty.toString());
|
||||
return true;
|
||||
}
|
||||
|
||||
protected int getDifficultyForString(CommandSender sender, String name) {
|
||||
if (name.equalsIgnoreCase("peaceful") || name.equalsIgnoreCase("p")) {
|
||||
return 0;
|
||||
} else if (name.equalsIgnoreCase("easy") || name.equalsIgnoreCase("e")) {
|
||||
return 1;
|
||||
} else if (name.equalsIgnoreCase("normal") || name.equalsIgnoreCase("n")) {
|
||||
return 2;
|
||||
} else if (name.equalsIgnoreCase("hard") || name.equalsIgnoreCase("h")) {
|
||||
return 3;
|
||||
} else {
|
||||
return getInteger(sender, name, 0, 3);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> tabComplete(CommandSender sender, String alias, String[] args) {
|
||||
Validate.notNull(sender, "Sender cannot be null");
|
||||
Validate.notNull(args, "Arguments cannot be null");
|
||||
Validate.notNull(alias, "Alias cannot be null");
|
||||
|
||||
if (args.length == 1) {
|
||||
return StringUtil.copyPartialMatches(args[0], DIFFICULTY_NAMES, new ArrayList<String>(DIFFICULTY_NAMES.size()));
|
||||
}
|
||||
|
||||
return ImmutableList.of();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,119 @@
|
||||
package org.bukkit.command.defaults;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.potion.PotionEffect;
|
||||
import org.bukkit.potion.PotionEffectType;
|
||||
import org.bukkit.util.StringUtil;
|
||||
|
||||
public class EffectCommand extends VanillaCommand {
|
||||
private static final List<String> effects;
|
||||
|
||||
public EffectCommand() {
|
||||
super("effect");
|
||||
this.description = "Adds/Removes effects on players";
|
||||
this.usageMessage = "/effect <player> <effect|clear> [seconds] [amplifier]";
|
||||
this.setPermission("bukkit.command.effect");
|
||||
}
|
||||
|
||||
static {
|
||||
ImmutableList.Builder<String> builder = ImmutableList.<String>builder();
|
||||
|
||||
for (PotionEffectType type : PotionEffectType.values()) {
|
||||
if (type != null) {
|
||||
builder.add(type.getName());
|
||||
}
|
||||
}
|
||||
|
||||
effects = builder.build();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String commandLabel, String[] args) {
|
||||
if (!testPermission(sender)) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (args.length < 2) {
|
||||
sender.sendMessage(getUsage());
|
||||
return true;
|
||||
}
|
||||
|
||||
final Player player = sender.getServer().getPlayer(args[0]);
|
||||
|
||||
if (player == null) {
|
||||
sender.sendMessage(ChatColor.RED + String.format("Player, %s, not found", args[0]));
|
||||
return true;
|
||||
}
|
||||
|
||||
if ("clear".equalsIgnoreCase(args[1])) {
|
||||
for (PotionEffect effect : player.getActivePotionEffects()) {
|
||||
player.removePotionEffect(effect.getType());
|
||||
}
|
||||
sender.sendMessage(String.format("Took all effects from %s", args[0]));
|
||||
return true;
|
||||
}
|
||||
|
||||
PotionEffectType effect = PotionEffectType.getByName(args[1]);
|
||||
|
||||
if (effect == null) {
|
||||
effect = PotionEffectType.getById(getInteger(sender, args[1], 0));
|
||||
}
|
||||
|
||||
if (effect == null) {
|
||||
sender.sendMessage(ChatColor.RED + String.format("Effect, %s, not found", args[1]));
|
||||
return true;
|
||||
}
|
||||
|
||||
int duration = 600;
|
||||
int duration_temp = 30;
|
||||
int amplification = 0;
|
||||
|
||||
if (args.length >= 3) {
|
||||
duration_temp = getInteger(sender, args[2], 0, 1000000);
|
||||
if (effect.isInstant()) {
|
||||
duration = duration_temp;
|
||||
} else {
|
||||
duration = duration_temp * 20;
|
||||
}
|
||||
} else if (effect.isInstant()) {
|
||||
duration = 1;
|
||||
}
|
||||
|
||||
if (args.length >= 4) {
|
||||
amplification = getInteger(sender, args[3], 0, 255);
|
||||
}
|
||||
|
||||
if (duration_temp == 0) {
|
||||
if (!player.hasPotionEffect(effect)) {
|
||||
sender.sendMessage(String.format("Couldn't take %s from %s as they do not have the effect", effect.getName(), args[0]));
|
||||
return true;
|
||||
}
|
||||
|
||||
player.removePotionEffect(effect);
|
||||
broadcastCommandMessage(sender, String.format("Took %s from %s", effect.getName(), args[0]));
|
||||
} else {
|
||||
final PotionEffect applyEffect = new PotionEffect(effect, duration, amplification);
|
||||
|
||||
player.addPotionEffect(applyEffect, true);
|
||||
broadcastCommandMessage(sender, String.format("Given %s (ID %d) * %d to %s for %d seconds", effect.getName(), effect.getId(), amplification, args[0], duration_temp));
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> tabComplete(CommandSender sender, String commandLabel, String[] args) {
|
||||
if (args.length == 1) {
|
||||
return super.tabComplete(sender, commandLabel, args);
|
||||
} else if (args.length == 2) {
|
||||
return StringUtil.copyPartialMatches(args[1], effects, new ArrayList<String>(effects.size()));
|
||||
}
|
||||
|
||||
return ImmutableList.of();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,169 @@
|
||||
package org.bukkit.command.defaults;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.apache.commons.lang.WordUtils;
|
||||
import com.google.common.collect.ImmutableList;
|
||||
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.enchantments.Enchantment;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
import org.bukkit.util.StringUtil;
|
||||
|
||||
public class EnchantCommand extends VanillaCommand {
|
||||
private static final List<String> ENCHANTMENT_NAMES = new ArrayList<String>();
|
||||
|
||||
public EnchantCommand() {
|
||||
super("enchant");
|
||||
this.description = "Adds enchantments to the item the player is currently holding. Specify 0 for the level to remove an enchantment. Specify force to ignore normal enchantment restrictions";
|
||||
this.usageMessage = "/enchant <player> <enchantment> [level|max|0] [force]";
|
||||
this.setPermission("bukkit.command.enchant");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String commandLabel, String[] args) {
|
||||
if (!testPermission(sender)) return true;
|
||||
if (args.length < 2) {
|
||||
sender.sendMessage(ChatColor.RED + "Usage: " + usageMessage);
|
||||
return false;
|
||||
}
|
||||
|
||||
boolean force = false;
|
||||
if (args.length > 2) {
|
||||
force = args[args.length > 3 ? 3 : 2].equalsIgnoreCase("force");
|
||||
}
|
||||
|
||||
Player player = Bukkit.getPlayerExact(args[0]);
|
||||
if (player == null) {
|
||||
sender.sendMessage("Can't find player " + args[0]);
|
||||
} else {
|
||||
ItemStack item = player.getItemInHand();
|
||||
if (item.getType() == Material.AIR) {
|
||||
sender.sendMessage("The player isn't holding an item");
|
||||
} else {
|
||||
String itemName = item.getType().toString().replaceAll("_", " ");
|
||||
itemName = WordUtils.capitalizeFully(itemName);
|
||||
|
||||
Enchantment enchantment = getEnchantment(args[1].toUpperCase());
|
||||
if (enchantment == null) {
|
||||
sender.sendMessage(String.format("Enchantment does not exist: %s", args[1]));
|
||||
} else {
|
||||
String enchantmentName = enchantment.getName().replaceAll("_", " ");
|
||||
enchantmentName = WordUtils.capitalizeFully(enchantmentName);
|
||||
|
||||
if (!force && !enchantment.canEnchantItem(item)) {
|
||||
sender.sendMessage(String.format("%s cannot be applied to %s", enchantmentName, itemName));
|
||||
} else {
|
||||
int level = 1;
|
||||
if (args.length > 2) {
|
||||
Integer integer = getInteger(args[2]);
|
||||
int minLevel = enchantment.getStartLevel();
|
||||
int maxLevel = force ? Short.MAX_VALUE : enchantment.getMaxLevel();
|
||||
|
||||
if (integer != null) {
|
||||
if (integer == 0) {
|
||||
item.removeEnchantment(enchantment);
|
||||
Command.broadcastCommandMessage(sender, String.format("Removed %s on %s's %s", enchantmentName, player.getName(), itemName));
|
||||
return true;
|
||||
}
|
||||
|
||||
if (integer < minLevel || integer > maxLevel) {
|
||||
sender.sendMessage(String.format("Level for enchantment %s must be between %d and %d", enchantmentName, minLevel, maxLevel));
|
||||
sender.sendMessage("Specify 0 for level to remove an enchantment");
|
||||
return true;
|
||||
}
|
||||
|
||||
level = integer;
|
||||
}
|
||||
|
||||
if ("max".equals(args[2])) {
|
||||
level = maxLevel;
|
||||
}
|
||||
}
|
||||
|
||||
Map<Enchantment, Integer> enchantments = item.getEnchantments();
|
||||
boolean conflicts = false;
|
||||
|
||||
if (!force && !enchantments.isEmpty()) { // TODO: Improve this to use a "hasEnchantments" call
|
||||
for (Map.Entry<Enchantment, Integer> entry : enchantments.entrySet()) {
|
||||
Enchantment enchant = entry.getKey();
|
||||
|
||||
if (enchant.equals(enchantment)) continue;
|
||||
if (enchant.conflictsWith(enchantment)) {
|
||||
sender.sendMessage(String.format("Can't apply the enchantment %s on an item with the enchantment %s", enchantmentName, WordUtils.capitalizeFully(enchant.getName().replaceAll("_", " "))));
|
||||
conflicts = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!conflicts) {
|
||||
item.addUnsafeEnchantment(enchantment, level);
|
||||
|
||||
Command.broadcastCommandMessage(sender, String.format("Applied %s (Lvl %d) on %s's %s", enchantmentName, level, player.getName(), itemName), false);
|
||||
sender.sendMessage(String.format("Enchanting succeeded, applied %s (Lvl %d) onto your %s", enchantmentName, level, itemName));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> tabComplete(CommandSender sender, String alias, String[] args) throws IllegalArgumentException {
|
||||
Validate.notNull(sender, "Sender cannot be null");
|
||||
Validate.notNull(args, "Arguments cannot be null");
|
||||
Validate.notNull(alias, "Alias cannot be null");
|
||||
|
||||
if (args.length == 1) {
|
||||
return super.tabComplete(sender, alias, args);
|
||||
}
|
||||
|
||||
if (args.length == 2) {
|
||||
return StringUtil.copyPartialMatches(args[1], ENCHANTMENT_NAMES, new ArrayList<String>(ENCHANTMENT_NAMES.size()));
|
||||
}
|
||||
|
||||
if (args.length == 3 || args.length == 4) {
|
||||
if (!args[args.length - 2].equalsIgnoreCase("force")) {
|
||||
return ImmutableList.of("force");
|
||||
}
|
||||
}
|
||||
|
||||
return ImmutableList.of();
|
||||
}
|
||||
|
||||
private Enchantment getEnchantment(String lookup) {
|
||||
Enchantment enchantment = Enchantment.getByName(lookup);
|
||||
|
||||
if (enchantment == null) {
|
||||
Integer id = getInteger(lookup);
|
||||
if (id != null) {
|
||||
enchantment = Enchantment.getById(id);
|
||||
}
|
||||
}
|
||||
|
||||
return enchantment;
|
||||
}
|
||||
|
||||
public static void buildEnchantments() {
|
||||
if (!ENCHANTMENT_NAMES.isEmpty()) {
|
||||
throw new IllegalStateException("Enchantments have already been built!");
|
||||
}
|
||||
|
||||
for (Enchantment enchantment : Enchantment.values()) {
|
||||
ENCHANTMENT_NAMES.add(enchantment.getName());
|
||||
}
|
||||
|
||||
Collections.sort(ENCHANTMENT_NAMES);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,89 @@
|
||||
package org.bukkit.command.defaults;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
|
||||
public class ExpCommand extends VanillaCommand {
|
||||
public ExpCommand() {
|
||||
super("xp");
|
||||
this.description = "Gives the specified player a certain amount of experience. Specify <amount>L to give levels instead, with a negative amount resulting in taking levels.";
|
||||
this.usageMessage = "/xp <amount> [player] OR /xp <amount>L [player]";
|
||||
this.setPermission("bukkit.command.xp");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String currentAlias, String[] args) {
|
||||
if (!testPermission(sender)) return true;
|
||||
|
||||
if (args.length > 0) {
|
||||
String inputAmount = args[0];
|
||||
Player player = null;
|
||||
|
||||
boolean isLevel = inputAmount.endsWith("l") || inputAmount.endsWith("L");
|
||||
if (isLevel && inputAmount.length() > 1) {
|
||||
inputAmount = inputAmount.substring(0, inputAmount.length() - 1);
|
||||
}
|
||||
|
||||
int amount = getInteger(sender, inputAmount, Integer.MIN_VALUE, Integer.MAX_VALUE);
|
||||
boolean isTaking = amount < 0;
|
||||
|
||||
if (isTaking) {
|
||||
amount *= -1;
|
||||
}
|
||||
|
||||
if (args.length > 1) {
|
||||
player = Bukkit.getPlayer(args[1]);
|
||||
} else if (sender instanceof Player) {
|
||||
player = (Player) sender;
|
||||
}
|
||||
|
||||
if (player != null) {
|
||||
if (isLevel) {
|
||||
if (isTaking) {
|
||||
player.giveExpLevels(-amount);
|
||||
Command.broadcastCommandMessage(sender, "Taken " + amount + " level(s) from " + player.getName());
|
||||
} else {
|
||||
player.giveExpLevels(amount);
|
||||
Command.broadcastCommandMessage(sender, "Given " + amount + " level(s) to " + player.getName());
|
||||
}
|
||||
} else {
|
||||
if (isTaking) {
|
||||
sender.sendMessage(ChatColor.RED + "Taking experience can only be done by levels, cannot give players negative experience points");
|
||||
return false;
|
||||
} else {
|
||||
player.giveExp(amount);
|
||||
Command.broadcastCommandMessage(sender, "Given " + amount + " experience to " + player.getName());
|
||||
}
|
||||
}
|
||||
} else {
|
||||
sender.sendMessage("Can't find player, was one provided?\n" + ChatColor.RED + "Usage: " + usageMessage);
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
sender.sendMessage(ChatColor.RED + "Usage: " + usageMessage);
|
||||
return false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> tabComplete(CommandSender sender, String alias, String[] args) throws IllegalArgumentException {
|
||||
Validate.notNull(sender, "Sender cannot be null");
|
||||
Validate.notNull(args, "Arguments cannot be null");
|
||||
Validate.notNull(alias, "Alias cannot be null");
|
||||
|
||||
if (args.length == 2) {
|
||||
return super.tabComplete(sender, alias, args);
|
||||
}
|
||||
return ImmutableList.of();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,98 @@
|
||||
package org.bukkit.command.defaults;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.GameMode;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.util.StringUtil;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
|
||||
public class GameModeCommand extends VanillaCommand {
|
||||
private static final List<String> GAMEMODE_NAMES = ImmutableList.of("adventure", "creative", "survival");
|
||||
|
||||
public GameModeCommand() {
|
||||
super("gamemode");
|
||||
this.description = "Changes the player to a specific game mode";
|
||||
this.usageMessage = "/gamemode <mode> [player]";
|
||||
this.setPermission("bukkit.command.gamemode");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String currentAlias, String[] args) {
|
||||
if (!testPermission(sender)) return true;
|
||||
if (args.length == 0) {
|
||||
sender.sendMessage(ChatColor.RED + "Usage: " + usageMessage);
|
||||
return false;
|
||||
}
|
||||
|
||||
String modeArg = args[0];
|
||||
String playerArg = sender.getName();
|
||||
|
||||
if (args.length == 2) {
|
||||
playerArg = args[1];
|
||||
}
|
||||
|
||||
Player player = Bukkit.getPlayerExact(playerArg);
|
||||
|
||||
if (player != null) {
|
||||
int value = -1;
|
||||
|
||||
try {
|
||||
value = Integer.parseInt(modeArg);
|
||||
} catch (NumberFormatException ex) {}
|
||||
|
||||
GameMode mode = GameMode.getByValue(value);
|
||||
|
||||
if (mode == null) {
|
||||
if (modeArg.equalsIgnoreCase("creative") || modeArg.equalsIgnoreCase("c")) {
|
||||
mode = GameMode.CREATIVE;
|
||||
} else if (modeArg.equalsIgnoreCase("adventure") || modeArg.equalsIgnoreCase("a")) {
|
||||
mode = GameMode.ADVENTURE;
|
||||
} else {
|
||||
mode = GameMode.SURVIVAL;
|
||||
}
|
||||
}
|
||||
|
||||
if (mode != player.getGameMode()) {
|
||||
player.setGameMode(mode);
|
||||
|
||||
if (mode != player.getGameMode()) {
|
||||
sender.sendMessage("Game mode change for " + player.getName() + " failed!");
|
||||
} else {
|
||||
if (player == sender) {
|
||||
Command.broadcastCommandMessage(sender, "Set own game mode to " + mode.toString() + " mode");
|
||||
} else {
|
||||
Command.broadcastCommandMessage(sender, "Set " + player.getName() + "'s game mode to " + mode.toString() + " mode");
|
||||
}
|
||||
}
|
||||
} else {
|
||||
sender.sendMessage(player.getName() + " already has game mode " + mode.getValue());
|
||||
}
|
||||
} else {
|
||||
sender.sendMessage("Can't find player " + playerArg);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> tabComplete(CommandSender sender, String alias, String[] args) {
|
||||
Validate.notNull(sender, "Sender cannot be null");
|
||||
Validate.notNull(args, "Arguments cannot be null");
|
||||
Validate.notNull(alias, "Alias cannot be null");
|
||||
|
||||
if (args.length == 1) {
|
||||
return StringUtil.copyPartialMatches(args[0], GAMEMODE_NAMES, new ArrayList<String>(GAMEMODE_NAMES.size()));
|
||||
} else if (args.length == 2) {
|
||||
return super.tabComplete(sender, alias, args);
|
||||
}
|
||||
return ImmutableList.of();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,88 @@
|
||||
package org.bukkit.command.defaults;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.command.BlockCommandSender;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.util.StringUtil;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.List;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.World;
|
||||
import org.bukkit.entity.HumanEntity;
|
||||
|
||||
public class GameRuleCommand extends VanillaCommand {
|
||||
private static final List<String> GAMERULE_STATES = ImmutableList.of("true", "false");
|
||||
|
||||
public GameRuleCommand() {
|
||||
super("gamerule");
|
||||
this.description = "Sets a server's game rules";
|
||||
this.usageMessage = "/gamerule <rule name> <value> OR /gamerule <rule name>";
|
||||
this.setPermission("bukkit.command.gamerule");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String currentAlias, String[] args) {
|
||||
if (!testPermission(sender)) return true;
|
||||
|
||||
if (args.length > 0) {
|
||||
String rule = args[0];
|
||||
World world = getGameWorld(sender);
|
||||
|
||||
if (world.isGameRule(rule)) {
|
||||
if (args.length > 1) {
|
||||
String value = args[1];
|
||||
|
||||
world.setGameRuleValue(rule, value);
|
||||
Command.broadcastCommandMessage(sender, "Game rule " + rule + " has been set to: " + value);
|
||||
} else {
|
||||
String value = world.getGameRuleValue(rule);
|
||||
sender.sendMessage(rule + " = " + value);
|
||||
}
|
||||
} else {
|
||||
sender.sendMessage(ChatColor.RED + "No game rule called " + rule + " is available");
|
||||
}
|
||||
|
||||
return true;
|
||||
} else {
|
||||
sender.sendMessage(ChatColor.RED + "Usage: " + usageMessage);
|
||||
sender.sendMessage("Rules: " + this.createString(getGameWorld(sender).getGameRules(), 0, ", "));
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
private World getGameWorld(CommandSender sender) {
|
||||
if (sender instanceof HumanEntity) {
|
||||
World world = ((HumanEntity) sender).getWorld();
|
||||
if (world != null) {
|
||||
return world;
|
||||
}
|
||||
} else if (sender instanceof BlockCommandSender) {
|
||||
return ((BlockCommandSender) sender).getBlock().getWorld();
|
||||
}
|
||||
|
||||
return Bukkit.getWorlds().get(0);
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> tabComplete(CommandSender sender, String alias, String[] args) throws IllegalArgumentException {
|
||||
Validate.notNull(sender, "Sender cannot be null");
|
||||
Validate.notNull(args, "Arguments cannot be null");
|
||||
Validate.notNull(alias, "Alias cannot be null");
|
||||
|
||||
if (args.length == 1) {
|
||||
return StringUtil.copyPartialMatches(args[0], Arrays.asList(getGameWorld(sender).getGameRules()), new ArrayList<String>());
|
||||
}
|
||||
|
||||
if (args.length == 2) {
|
||||
return StringUtil.copyPartialMatches(args[1], GAMERULE_STATES, new ArrayList<String>(GAMERULE_STATES.size()));
|
||||
}
|
||||
|
||||
return ImmutableList.of();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,129 @@
|
||||
package org.bukkit.command.defaults;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.Material;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.inventory.ItemStack;
|
||||
import org.bukkit.util.StringUtil;
|
||||
|
||||
import com.google.common.base.Joiner;
|
||||
import com.google.common.collect.ImmutableList;
|
||||
|
||||
public class GiveCommand extends VanillaCommand {
|
||||
private static List<String> materials;
|
||||
static {
|
||||
ArrayList<String> materialList = new ArrayList<String>();
|
||||
for (Material material : Material.values()) {
|
||||
materialList.add(material.name());
|
||||
}
|
||||
Collections.sort(materialList);
|
||||
materials = ImmutableList.copyOf(materialList);
|
||||
}
|
||||
|
||||
public GiveCommand() {
|
||||
super("give");
|
||||
this.description = "Gives the specified player a certain amount of items";
|
||||
this.usageMessage = "/give <player> <item> [amount [data]]";
|
||||
this.setPermission("bukkit.command.give");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String currentAlias, String[] args) {
|
||||
if (!testPermission(sender)) return true;
|
||||
if ((args.length < 2)) {
|
||||
sender.sendMessage(ChatColor.RED + "Usage: " + usageMessage);
|
||||
return false;
|
||||
}
|
||||
|
||||
Player player = Bukkit.getPlayerExact(args[0]);
|
||||
|
||||
if (player != null) {
|
||||
Material material = Material.matchMaterial(args[1]);
|
||||
|
||||
if (material == null) {
|
||||
material = Bukkit.getUnsafe().getMaterialFromInternalName(args[1]);
|
||||
}
|
||||
|
||||
if (material != null) {
|
||||
int amount = 1;
|
||||
short data = 0;
|
||||
|
||||
if (args.length >= 3) {
|
||||
amount = this.getInteger(sender, args[2], 1, 64);
|
||||
|
||||
if (args.length >= 4) {
|
||||
try {
|
||||
data = Short.parseShort(args[3]);
|
||||
} catch (NumberFormatException ex) {}
|
||||
}
|
||||
}
|
||||
|
||||
ItemStack stack = new ItemStack(material, amount, data);
|
||||
|
||||
if (args.length >= 5) {
|
||||
try {
|
||||
stack = Bukkit.getUnsafe().modifyItemStack(stack, Joiner.on(' ').join(Arrays.asList(args).subList(4, args.length)));
|
||||
} catch (Throwable t) {
|
||||
player.sendMessage("Not a valid tag");
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
player.getInventory().addItem(stack);
|
||||
|
||||
Command.broadcastCommandMessage(sender, "Gave " + player.getName() + " some " + material.getId() + " (" + material + ")");
|
||||
} else {
|
||||
sender.sendMessage("There's no item called " + args[1]);
|
||||
}
|
||||
} else {
|
||||
sender.sendMessage("Can't find player " + args[0]);
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> tabComplete(CommandSender sender, String alias, String[] args) throws IllegalArgumentException {
|
||||
Validate.notNull(sender, "Sender cannot be null");
|
||||
Validate.notNull(args, "Arguments cannot be null");
|
||||
Validate.notNull(alias, "Alias cannot be null");
|
||||
|
||||
if (args.length == 1) {
|
||||
return super.tabComplete(sender, alias, args);
|
||||
}
|
||||
if (args.length == 2) {
|
||||
final String arg = args[1];
|
||||
final List<String> materials = GiveCommand.materials;
|
||||
List<String> completion = new ArrayList<String>();
|
||||
|
||||
final int size = materials.size();
|
||||
int i = Collections.binarySearch(materials, arg, String.CASE_INSENSITIVE_ORDER);
|
||||
|
||||
if (i < 0) {
|
||||
// Insertion (start) index
|
||||
i = -1 - i;
|
||||
}
|
||||
|
||||
for ( ; i < size; i++) {
|
||||
String material = materials.get(i);
|
||||
if (StringUtil.startsWithIgnoreCase(material, arg)) {
|
||||
completion.add(material);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return Bukkit.getUnsafe().tabCompleteInternalMaterialName(arg, completion);
|
||||
}
|
||||
return ImmutableList.of();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,228 @@
|
||||
package org.bukkit.command.defaults;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Arrays;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Set;
|
||||
import java.util.TreeSet;
|
||||
|
||||
import org.apache.commons.lang.ArrayUtils;
|
||||
import org.apache.commons.lang.StringUtils;
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.apache.commons.lang.math.NumberUtils;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.command.ConsoleCommandSender;
|
||||
import org.bukkit.help.HelpMap;
|
||||
import org.bukkit.help.HelpTopic;
|
||||
import org.bukkit.help.HelpTopicComparator;
|
||||
import org.bukkit.help.IndexHelpTopic;
|
||||
import org.bukkit.util.ChatPaginator;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
|
||||
public class HelpCommand extends VanillaCommand {
|
||||
public HelpCommand() {
|
||||
super("help");
|
||||
this.description = "Shows the help menu";
|
||||
this.usageMessage = "/help <pageNumber>\n/help <topic>\n/help <topic> <pageNumber>";
|
||||
this.setAliases(Arrays.asList(new String[] { "?" }));
|
||||
this.setPermission("bukkit.command.help");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String currentAlias, String[] args) {
|
||||
if (!testPermission(sender)) return true;
|
||||
|
||||
String command;
|
||||
int pageNumber;
|
||||
int pageHeight;
|
||||
int pageWidth;
|
||||
|
||||
if (args.length == 0) {
|
||||
command = "";
|
||||
pageNumber = 1;
|
||||
} else if (NumberUtils.isDigits(args[args.length - 1])) {
|
||||
command = StringUtils.join(ArrayUtils.subarray(args, 0, args.length - 1), " ");
|
||||
try {
|
||||
pageNumber = NumberUtils.createInteger(args[args.length - 1]);
|
||||
} catch (NumberFormatException exception) {
|
||||
pageNumber = 1;
|
||||
}
|
||||
if (pageNumber <= 0) {
|
||||
pageNumber = 1;
|
||||
}
|
||||
} else {
|
||||
command = StringUtils.join(args, " ");
|
||||
pageNumber = 1;
|
||||
}
|
||||
|
||||
if (sender instanceof ConsoleCommandSender) {
|
||||
pageHeight = ChatPaginator.UNBOUNDED_PAGE_HEIGHT;
|
||||
pageWidth = ChatPaginator.UNBOUNDED_PAGE_WIDTH;
|
||||
} else {
|
||||
pageHeight = ChatPaginator.CLOSED_CHAT_PAGE_HEIGHT - 1;
|
||||
pageWidth = ChatPaginator.GUARANTEED_NO_WRAP_CHAT_PAGE_WIDTH;
|
||||
}
|
||||
|
||||
HelpMap helpMap = Bukkit.getServer().getHelpMap();
|
||||
HelpTopic topic = helpMap.getHelpTopic(command);
|
||||
|
||||
if (topic == null) {
|
||||
topic = helpMap.getHelpTopic("/" + command);
|
||||
}
|
||||
|
||||
if (topic == null) {
|
||||
topic = findPossibleMatches(command);
|
||||
}
|
||||
|
||||
if (topic == null || !topic.canSee(sender)) {
|
||||
sender.sendMessage(ChatColor.RED + "No help for " + command);
|
||||
return true;
|
||||
}
|
||||
|
||||
ChatPaginator.ChatPage page = ChatPaginator.paginate(topic.getFullText(sender), pageNumber, pageWidth, pageHeight);
|
||||
|
||||
StringBuilder header = new StringBuilder();
|
||||
header.append(ChatColor.YELLOW);
|
||||
header.append("--------- ");
|
||||
header.append(ChatColor.WHITE);
|
||||
header.append("Help: ");
|
||||
header.append(topic.getName());
|
||||
header.append(" ");
|
||||
if (page.getTotalPages() > 1) {
|
||||
header.append("(");
|
||||
header.append(page.getPageNumber());
|
||||
header.append("/");
|
||||
header.append(page.getTotalPages());
|
||||
header.append(") ");
|
||||
}
|
||||
header.append(ChatColor.YELLOW);
|
||||
for (int i = header.length(); i < ChatPaginator.GUARANTEED_NO_WRAP_CHAT_PAGE_WIDTH; i++) {
|
||||
header.append("-");
|
||||
}
|
||||
sender.sendMessage(header.toString());
|
||||
|
||||
sender.sendMessage(page.getLines());
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> tabComplete(CommandSender sender, String alias, String[] args) {
|
||||
Validate.notNull(sender, "Sender cannot be null");
|
||||
Validate.notNull(args, "Arguments cannot be null");
|
||||
Validate.notNull(alias, "Alias cannot be null");
|
||||
|
||||
if (args.length == 1) {
|
||||
List<String> matchedTopics = new ArrayList<String>();
|
||||
String searchString = args[0];
|
||||
for (HelpTopic topic : Bukkit.getServer().getHelpMap().getHelpTopics()) {
|
||||
String trimmedTopic = topic.getName().startsWith("/") ? topic.getName().substring(1) : topic.getName();
|
||||
|
||||
if (trimmedTopic.startsWith(searchString)) {
|
||||
matchedTopics.add(trimmedTopic);
|
||||
}
|
||||
}
|
||||
return matchedTopics;
|
||||
}
|
||||
return ImmutableList.of();
|
||||
}
|
||||
|
||||
protected HelpTopic findPossibleMatches(String searchString) {
|
||||
int maxDistance = (searchString.length() / 5) + 3;
|
||||
Set<HelpTopic> possibleMatches = new TreeSet<HelpTopic>(HelpTopicComparator.helpTopicComparatorInstance());
|
||||
|
||||
if (searchString.startsWith("/")) {
|
||||
searchString = searchString.substring(1);
|
||||
}
|
||||
|
||||
for (HelpTopic topic : Bukkit.getServer().getHelpMap().getHelpTopics()) {
|
||||
String trimmedTopic = topic.getName().startsWith("/") ? topic.getName().substring(1) : topic.getName();
|
||||
|
||||
if (trimmedTopic.length() < searchString.length()) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (Character.toLowerCase(trimmedTopic.charAt(0)) != Character.toLowerCase(searchString.charAt(0))) {
|
||||
continue;
|
||||
}
|
||||
|
||||
if (damerauLevenshteinDistance(searchString, trimmedTopic.substring(0, searchString.length())) < maxDistance) {
|
||||
possibleMatches.add(topic);
|
||||
}
|
||||
}
|
||||
|
||||
if (possibleMatches.size() > 0) {
|
||||
return new IndexHelpTopic("Search", null, null, possibleMatches, "Search for: " + searchString);
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Computes the Dameraur-Levenshtein Distance between two strings. Adapted
|
||||
* from the algorithm at <a href="http://en.wikipedia.org/wiki/Damerau–Levenshtein_distance">Wikipedia: Damerau–Levenshtein distance</a>
|
||||
*
|
||||
* @param s1 The first string being compared.
|
||||
* @param s2 The second string being compared.
|
||||
* @return The number of substitutions, deletions, insertions, and
|
||||
* transpositions required to get from s1 to s2.
|
||||
*/
|
||||
protected static int damerauLevenshteinDistance(String s1, String s2) {
|
||||
if (s1 == null && s2 == null) {
|
||||
return 0;
|
||||
}
|
||||
if (s1 != null && s2 == null) {
|
||||
return s1.length();
|
||||
}
|
||||
if (s1 == null && s2 != null) {
|
||||
return s2.length();
|
||||
}
|
||||
|
||||
int s1Len = s1.length();
|
||||
int s2Len = s2.length();
|
||||
int[][] H = new int[s1Len + 2][s2Len + 2];
|
||||
|
||||
int INF = s1Len + s2Len;
|
||||
H[0][0] = INF;
|
||||
for (int i = 0; i <= s1Len; i++) {
|
||||
H[i + 1][1] = i;
|
||||
H[i + 1][0] = INF;
|
||||
}
|
||||
for (int j = 0; j <= s2Len; j++) {
|
||||
H[1][j + 1] = j;
|
||||
H[0][j + 1] = INF;
|
||||
}
|
||||
|
||||
Map<Character, Integer> sd = new HashMap<Character, Integer>();
|
||||
for (char Letter : (s1 + s2).toCharArray()) {
|
||||
if (!sd.containsKey(Letter)) {
|
||||
sd.put(Letter, 0);
|
||||
}
|
||||
}
|
||||
|
||||
for (int i = 1; i <= s1Len; i++) {
|
||||
int DB = 0;
|
||||
for (int j = 1; j <= s2Len; j++) {
|
||||
int i1 = sd.get(s2.charAt(j - 1));
|
||||
int j1 = DB;
|
||||
|
||||
if (s1.charAt(i - 1) == s2.charAt(j - 1)) {
|
||||
H[i + 1][j + 1] = H[i][j];
|
||||
DB = j;
|
||||
} else {
|
||||
H[i + 1][j + 1] = Math.min(H[i][j], Math.min(H[i + 1][j], H[i][j + 1])) + 1;
|
||||
}
|
||||
|
||||
H[i + 1][j + 1] = Math.min(H[i + 1][j + 1], H[i1][j1] + (i - i1 - 1) + 1 + (j - j1 - 1));
|
||||
}
|
||||
sd.put(s1.charAt(i - 1), i);
|
||||
}
|
||||
|
||||
return H[s1Len + 1][s2Len + 1];
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
package org.bukkit.command.defaults;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
|
||||
public class KickCommand extends VanillaCommand {
|
||||
public KickCommand() {
|
||||
super("kick");
|
||||
this.description = "Removes the specified player from the server";
|
||||
this.usageMessage = "/kick <player> [reason ...]";
|
||||
this.setPermission("bukkit.command.kick");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String currentAlias, String[] args) {
|
||||
if (!testPermission(sender)) return true;
|
||||
if (args.length < 1 || args[0].length() == 0) {
|
||||
sender.sendMessage(ChatColor.RED + "Usage: " + usageMessage);
|
||||
return false;
|
||||
}
|
||||
|
||||
Player player = Bukkit.getPlayerExact(args[0]);
|
||||
|
||||
if (player != null) {
|
||||
String reason = "Kicked by an operator.";
|
||||
|
||||
if (args.length > 1) {
|
||||
reason = createString(args, 1);
|
||||
}
|
||||
|
||||
player.kickPlayer(reason);
|
||||
Command.broadcastCommandMessage(sender, "Kicked player " + player.getName() + ". With reason:\n" + reason);
|
||||
} else {
|
||||
sender.sendMessage( args[0] + " not found.");
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> tabComplete(CommandSender sender, String alias, String[] args) throws IllegalArgumentException {
|
||||
Validate.notNull(sender, "Sender cannot be null");
|
||||
Validate.notNull(args, "Arguments cannot be null");
|
||||
Validate.notNull(alias, "Alias cannot be null");
|
||||
|
||||
if (args.length >= 1) {
|
||||
return super.tabComplete(sender, alias, args);
|
||||
}
|
||||
return ImmutableList.of();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
package org.bukkit.command.defaults;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.event.entity.EntityDamageEvent;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
|
||||
public class KillCommand extends VanillaCommand {
|
||||
public KillCommand() {
|
||||
super("kill");
|
||||
this.description = "Commits suicide, only usable as a player";
|
||||
this.usageMessage = "/kill";
|
||||
this.setPermission("bukkit.command.kill");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String currentAlias, String[] args) {
|
||||
if (!testPermission(sender)) return true;
|
||||
|
||||
if (sender instanceof Player) {
|
||||
Player player = (Player) sender;
|
||||
|
||||
EntityDamageEvent ede = new EntityDamageEvent(player, EntityDamageEvent.DamageCause.SUICIDE, 1000);
|
||||
Bukkit.getPluginManager().callEvent(ede);
|
||||
if (ede.isCancelled()) return true;
|
||||
|
||||
ede.getEntity().setLastDamageCause(ede);
|
||||
player.setHealth(0);
|
||||
sender.sendMessage("Ouch. That look like it hurt.");
|
||||
} else {
|
||||
sender.sendMessage("You can only perform this command as a player");
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> tabComplete(CommandSender sender, String alias, String[] args) throws IllegalArgumentException {
|
||||
Validate.notNull(sender, "Sender cannot be null");
|
||||
Validate.notNull(args, "Arguments cannot be null");
|
||||
Validate.notNull(alias, "Alias cannot be null");
|
||||
|
||||
return ImmutableList.of();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
package org.bukkit.command.defaults;
|
||||
|
||||
import java.util.Collection;
|
||||
import java.util.List;
|
||||
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
|
||||
public class ListCommand extends VanillaCommand {
|
||||
public ListCommand() {
|
||||
super("list");
|
||||
this.description = "Lists all online players";
|
||||
this.usageMessage = "/list";
|
||||
this.setPermission("bukkit.command.list");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String currentAlias, String[] args) {
|
||||
if (!testPermission(sender)) return true;
|
||||
|
||||
StringBuilder online = new StringBuilder();
|
||||
|
||||
final Collection<? extends Player> players = Bukkit.getOnlinePlayers();
|
||||
|
||||
for (Player player : players) {
|
||||
// If a player is hidden from the sender don't show them in the list
|
||||
if (sender instanceof Player && !((Player) sender).canSee(player))
|
||||
continue;
|
||||
|
||||
if (online.length() > 0) {
|
||||
online.append(", ");
|
||||
}
|
||||
|
||||
online.append(player.getDisplayName());
|
||||
}
|
||||
|
||||
sender.sendMessage("There are " + players.size() + "/" + Bukkit.getMaxPlayers() + " players online:\n" + online.toString());
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> tabComplete(CommandSender sender, String alias, String[] args) throws IllegalArgumentException {
|
||||
Validate.notNull(sender, "Sender cannot be null");
|
||||
Validate.notNull(args, "Arguments cannot be null");
|
||||
Validate.notNull(alias, "Alias cannot be null");
|
||||
|
||||
return ImmutableList.of();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
package org.bukkit.command.defaults;
|
||||
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.command.CommandSender;
|
||||
|
||||
public class MeCommand extends VanillaCommand {
|
||||
public MeCommand() {
|
||||
super("me");
|
||||
this.description = "Performs the specified action in chat";
|
||||
this.usageMessage = "/me <action>";
|
||||
this.setPermission("bukkit.command.me");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String currentAlias, String[] args) {
|
||||
if (!testPermission(sender)) return true;
|
||||
if (args.length < 1) {
|
||||
sender.sendMessage(ChatColor.RED + "Usage: " + usageMessage);
|
||||
return false;
|
||||
}
|
||||
|
||||
StringBuilder message = new StringBuilder();
|
||||
message.append(sender.getName());
|
||||
|
||||
for (String arg : args) {
|
||||
message.append(" ");
|
||||
message.append(arg);
|
||||
}
|
||||
|
||||
Bukkit.broadcastMessage("* " + message.toString());
|
||||
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
package org.bukkit.command.defaults;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
|
||||
import org.apache.commons.lang.Validate;
|
||||
import org.bukkit.Bukkit;
|
||||
import org.bukkit.ChatColor;
|
||||
import org.bukkit.OfflinePlayer;
|
||||
import org.bukkit.command.Command;
|
||||
import org.bukkit.command.CommandSender;
|
||||
import org.bukkit.entity.Player;
|
||||
import org.bukkit.util.StringUtil;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
|
||||
public class OpCommand extends VanillaCommand {
|
||||
public OpCommand() {
|
||||
super("op");
|
||||
this.description = "Gives the specified player operator status";
|
||||
this.usageMessage = "/op <player>";
|
||||
this.setPermission("bukkit.command.op.give");
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean execute(CommandSender sender, String currentAlias, String[] args) {
|
||||
if (!testPermission(sender)) return true;
|
||||
if (args.length != 1 || args[0].length() == 0) {
|
||||
sender.sendMessage(ChatColor.RED + "Usage: " + usageMessage);
|
||||
return false;
|
||||
}
|
||||
|
||||
OfflinePlayer player = Bukkit.getOfflinePlayer(args[0]);
|
||||
player.setOp(true);
|
||||
|
||||
Command.broadcastCommandMessage(sender, "Opped " + args[0]);
|
||||
return true;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<String> tabComplete(CommandSender sender, String alias, String[] args) throws IllegalArgumentException {
|
||||
Validate.notNull(sender, "Sender cannot be null");
|
||||
Validate.notNull(args, "Arguments cannot be null");
|
||||
Validate.notNull(alias, "Alias cannot be null");
|
||||
|
||||
if (args.length == 1) {
|
||||
if (!(sender instanceof Player)) {
|
||||
return ImmutableList.of();
|
||||
}
|
||||
|
||||
String lastWord = args[0];
|
||||
if (lastWord.length() == 0) {
|
||||
return ImmutableList.of();
|
||||
}
|
||||
|
||||
Player senderPlayer = (Player) sender;
|
||||
|
||||
ArrayList<String> matchedPlayers = new ArrayList<String>();
|
||||
for (Player player : sender.getServer().getOnlinePlayers()) {
|
||||
String name = player.getName();
|
||||
if (!senderPlayer.canSee(player) || player.isOp()) {
|
||||
continue;
|
||||
}
|
||||
if (StringUtil.startsWithIgnoreCase(name, lastWord)) {
|
||||
matchedPlayers.add(name);
|
||||
}
|
||||
}
|
||||
|
||||
Collections.sort(matchedPlayers, String.CASE_INSENSITIVE_ORDER);
|
||||
return matchedPlayers;
|
||||
}
|
||||
return ImmutableList.of();
|
||||
}
|
||||
}
|
||||
Loaded 100 of 739 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user