Upstream/FastAsyncWorldedit
1
0
Fork 0
mirror of https://github.com/boy0001/FastAsyncWorldedit.git synced 2024-12-01 07:03:52 +01:00
Code Issues Projects Releases Wiki Activity

API and brush improvements.

Browse Source
This commit is contained in:
Jesse Boyd 2016-04-23 02:11:46 +10:00
parent 70362d348f
commit 14dd048662
14 changed files with 1095 additions and 166 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
bukkit/src/main/java/com/boydti/fawe/bukkit/FaweBukkit.java
View File

@ -23,11 +23,14 @@ import com.boydti.fawe.object.FaweCommand;
import com.boydti.fawe.object.FawePlayer;
import com.boydti.fawe.regions.FaweMaskManager;
import com.boydti.fawe.util.FaweQueue;
import com.boydti.fawe.util.ReflectionUtils;
import com.boydti.fawe.util.StringMan;
import com.boydti.fawe.util.TaskManager;
import com.sk89q.worldedit.EditSession;
import com.sk89q.worldedit.bukkit.WorldEditPlugin;
import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
@ -64,6 +67,14 @@ public class FaweBukkit extends JavaPlugin implements IFawe, Listener {
try {
Bukkit.getPluginManager().registerEvents(this, this);
Fawe.set(this);
if (Bukkit.getVersion().contains("git-Spigot") && FaweAPI.checkVersion(this.getVersion(), 1, 7, 10)) {
debug("====== USE PAPER SPIGOT ======");
debug("DOWNLOAD: https://tcpr.ca/downloads/paperspigot");
debug("GUIDE: https://www.spigotmc.org/threads/21726/");
debug(" - This is only a recommendation");
debug("==============================");
}
} catch (final Throwable e) {
e.printStackTrace();
this.getServer().shutdown();
@ -204,6 +215,19 @@ public class FaweBukkit extends JavaPlugin implements IFawe, Listener {
return new BukkitQueue_1_8(world);
} catch (Throwable ignore) {}
if (hasNMS) {
try {
ReflectionUtils.init();
Field fieldDirtyCount = ReflectionUtils.getRefClass("{nms}.PlayerChunk").getField("dirtyCount").getRealField();
fieldDirtyCount.setAccessible(true);
int mod = fieldDirtyCount.getModifiers();
if ((mod & Modifier.VOLATILE) == 0) {
Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(fieldDirtyCount, mod + Modifier.VOLATILE);
}
} catch (Throwable e) {
e.printStackTrace();
}
debug("====== NO NMS BLOCK PLACER FOUND ======");
debug("FAWE couldn't find a fast block placer");
debug("Bukkit version: " + Bukkit.getVersion());

51
bukkit/src/main/java/com/boydti/fawe/bukkit/v0/BukkitQueue_All.java
View File

@ -6,6 +6,7 @@ import com.boydti.fawe.bukkit.v1_8.BukkitChunk_1_8;
import com.boydti.fawe.config.Settings;
import com.boydti.fawe.object.FaweChunk;
import com.boydti.fawe.object.IntegerPair;
import com.boydti.fawe.object.RunnableVal;
import com.boydti.fawe.object.exception.FaweException;
import com.boydti.fawe.util.TaskManager;
import com.sk89q.worldedit.LocalWorld;
@ -14,7 +15,6 @@ import com.sk89q.worldedit.bukkit.BukkitUtil;
import com.sk89q.worldedit.world.biome.BaseBiome;
import java.util.ArrayList;
import java.util.Collection;
import java.util.concurrent.LinkedBlockingDeque;
import org.bukkit.Bukkit;
import org.bukkit.Chunk;
import org.bukkit.World;
@ -26,27 +26,9 @@ import org.bukkit.plugin.Plugin;
import org.spigotmc.AsyncCatcher;
public class BukkitQueue_All extends BukkitQueue_0 {
public final LinkedBlockingDeque<IntegerPair> loadQueue = new LinkedBlockingDeque<>();
public BukkitQueue_All(final String world) {
super(world);
TaskManager.IMP.repeat(new Runnable() {
@Override
public void run() {
synchronized (loadQueue) {
while (loadQueue.size() > 0) {
IntegerPair loc = loadQueue.poll();
if (bukkitWorld == null) {
bukkitWorld = Bukkit.getServer().getWorld(world);
}
if (!bukkitWorld.isChunkLoaded(loc.x, loc.z)) {
bukkitWorld.loadChunk(loc.x, loc.z, true);
}
}
loadQueue.notifyAll();
}
}
}, 1);
if (getClass() == BukkitQueue_All.class) {
TaskManager.IMP.task(new Runnable() {
@Override
@ -213,10 +195,6 @@ public class BukkitQueue_All extends BukkitQueue_0 {
return true;
}
public void loadChunk(IntegerPair chunk) {
loadQueue.add(chunk);
}
public int lastChunkX = Integer.MIN_VALUE;
public int lastChunkZ = Integer.MIN_VALUE;
public int lastChunkY = Integer.MIN_VALUE;
@ -241,6 +219,15 @@ public class BukkitQueue_All extends BukkitQueue_0 {
return combined;
}
private final RunnableVal<IntegerPair> loadChunk = new RunnableVal<IntegerPair>() {
@Override
public void run(IntegerPair coord) {
bukkitWorld.loadChunk(coord.x, coord.z, true);
}
};
long average = 0;
@Override
public int getCombinedId4Data(int x, int y, int z) throws FaweException.FaweChunkLoadException {
if (y < 0 || y > 255) {
@ -256,24 +243,26 @@ public class BukkitQueue_All extends BukkitQueue_0 {
lastChunkX = cx;
lastChunkZ = cz;
if (!bukkitWorld.isChunkLoaded(cx, cz)) {
long start = System.currentTimeMillis();
boolean sync = Thread.currentThread() == Fawe.get().getMainThread();
if (sync) {
bukkitWorld.loadChunk(cx, cz, true);
} else if (Settings.CHUNK_WAIT > 0) {
synchronized (loadQueue) {
loadQueue.add(new IntegerPair(cx, cz));
try {
loadQueue.wait(Settings.CHUNK_WAIT);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
loadChunk.value = new IntegerPair(cx, cz);
TaskManager.IMP.sync(loadChunk, Settings.CHUNK_WAIT);
if (!bukkitWorld.isChunkLoaded(cx, cz)) {
throw new FaweException.FaweChunkLoadException();
}
} else {
return 0;
}
long diff = System.currentTimeMillis() - start;
if (average == 0) {
average = diff;
} else {
average = ((average * 15) + diff) / 16;
}
System.out.println(average);
}
lastChunk = getCachedChunk(cx, cz);
lastSection = getCachedSection(lastChunk, cy);

26
core/src/main/java/com/boydti/fawe/Fawe.java
View File

@ -24,6 +24,7 @@ import com.sk89q.worldedit.WorldEdit;
import com.sk89q.worldedit.command.SchematicCommands;
import com.sk89q.worldedit.command.ScriptingCommands;
import com.sk89q.worldedit.extension.platform.CommandManager;
import com.sk89q.worldedit.extension.platform.PlatformManager;
import com.sk89q.worldedit.extent.clipboard.BlockArrayClipboard;
import com.sk89q.worldedit.extent.transform.BlockTransformExtent;
import com.sk89q.worldedit.function.operation.Operations;
@ -240,6 +241,7 @@ public class Fawe {
Vector.inject();
try {
CommandManager.inject();
PlatformManager.inject();
} catch (Throwable e) {
debug("====== UPDATE WORLDEDIT TO 6.1.1 ======");
e.printStackTrace();
@ -255,16 +257,18 @@ public class Fawe {
}
try {
Native.load();
String arch = System.getenv("PROCESSOR_ARCHITECTURE");
String wow64Arch = System.getenv("PROCESSOR_ARCHITEW6432");
boolean x86OS = arch.endsWith("64") || wow64Arch != null && wow64Arch.endsWith("64") ? false : true;
boolean x86JVM = System.getProperty("sun.arch.data.model").equals("32");
if (x86OS != x86JVM) {
debug("====== UPGRADE TO 64-BIT JAVA ======");
debug("You are running 32-bit Java on a 64-bit machine");
debug(" - This is a recommendation");
debug("====================================");
}
try {
String arch = System.getenv("PROCESSOR_ARCHITECTURE");
String wow64Arch = System.getenv("PROCESSOR_ARCHITEW6432");
boolean x86OS = arch.endsWith("64") || wow64Arch != null && wow64Arch.endsWith("64") ? false : true;
boolean x86JVM = System.getProperty("sun.arch.data.model").equals("32");
if (x86OS != x86JVM) {
debug("====== UPGRADE TO 64-BIT JAVA ======");
debug("You are running 32-bit Java on a 64-bit machine");
debug(" - This is only a recommendation");
debug("====================================");
}
} catch (Throwable ignore) {}
} catch (Throwable e) {
debug("====== LZ4 COMPRESSION BINDING NOT FOUND ======");
e.printStackTrace();
@ -277,7 +281,7 @@ public class Fawe {
if (getJavaVersion() < 1.8) {
debug("====== UPGRADE TO JAVA 8 ======");
debug("You are running " + System.getProperty("java.version"));
debug(" - This is a recommendation");
debug(" - This is only a recommendation");
debug("====================================");
}
}

330
core/src/main/java/com/boydti/fawe/FaweAPI.java
View File

@ -1,14 +1,27 @@
package com.boydti.fawe;
import com.boydti.fawe.config.BBC;
import com.boydti.fawe.config.Settings;
import com.boydti.fawe.object.FaweLocation;
import com.boydti.fawe.object.FawePlayer;
import com.boydti.fawe.object.RegionWrapper;
import com.boydti.fawe.object.changeset.DiskStorageHistory;
import com.boydti.fawe.regions.FaweMaskManager;
import com.boydti.fawe.util.FaweQueue;
import com.boydti.fawe.util.MemUtil;
import com.boydti.fawe.util.SetQueue;
import com.boydti.fawe.util.TaskManager;
import com.boydti.fawe.util.WEManager;
import com.intellectualcrafters.plot.object.PseudoRandom;
import com.sk89q.jnbt.ByteArrayTag;
import com.sk89q.jnbt.IntTag;
import com.sk89q.jnbt.NBTInputStream;
import com.sk89q.jnbt.ShortTag;
import com.sk89q.jnbt.Tag;
import com.sk89q.worldedit.WorldEdit;
import com.sk89q.worldedit.WorldEditException;
import com.sk89q.worldedit.extent.Extent;
import com.sk89q.worldedit.world.World;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
@ -16,7 +29,15 @@ import java.io.InputStream;
import java.net.URL;
import java.nio.channels.Channels;
import java.nio.channels.ReadableByteChannel;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.zip.GZIPInputStream;
import org.bukkit.Chunk;
import org.bukkit.Location;
@ -24,11 +45,229 @@ import org.bukkit.Location;
/**
* The FaweAPI class offers a few useful functions.<br>
* - This class is not intended to replace the WorldEdit API<br>
* - With FAWE installed, you can use the EditSession and other WorldEdit classes from an async thread.<br>
* <br>
* FaweAPI.[some method]
*/
public class FaweAPI {
/**
* The TaskManager has some useful methods for doing things asynchronously
* @return TaskManager
*/
public TaskManager getTaskManager() {
return TaskManager.IMP;
}
/**
* Wrap some object into a FawePlayer<br>
* - org.bukkit.entity.Player
* - org.spongepowered.api.entity.living.player
* - com.sk89q.worldedit.entity.Player
* - String (name)
* - UUID (player UUID)
* @param obj
* @return
*/
public FawePlayer wrapPlayer(Object obj) {
return FawePlayer.wrap(obj);
}
/**
* You can either use a FaweQueue or an EditSession to change blocks<br>
* - The FaweQueue skips a bit of overhead so it's faster<br>
* - The WorldEdit EditSession can do a lot more<br>
* Remember to enqueue it when you're done!<br>
* @see com.boydti.fawe.util.FaweQueue#enqueue()
* @param worldName The name of the world
* @param autoqueue If it should start dispatching before you enqueue it.
* @return
*/
public FaweQueue createQueue(String worldName, boolean autoqueue) {
return SetQueue.IMP.getNewQueue(worldName, autoqueue);
}
/**
* Get a list of supported protection plugin masks.
* @return Set of FaweMaskManager
*/
public Set<FaweMaskManager> getMaskManagers() {
return new HashSet<>(WEManager.IMP.managers);
}
/**
* Check if the server has more than the configured low memory threshold
* @return True if the server has limited memory
*/
public boolean isMemoryLimited() {
return MemUtil.isMemoryLimited();
}
/**
* If you just need things to look random, use this faster alternative
* @return PseudoRandom
*/
public PseudoRandom getFastRandom() {
return new PseudoRandom();
}
/**
* Get a player's allowed WorldEdit region
* @param player
* @return
*/
public Set<RegionWrapper> getRegions(FawePlayer player) {
return WEManager.IMP.getMask(player);
}
/**
* Cancel the edit with the following extent<br>
* - The extent must be the one being used by an EditSession, otherwise an error may be thrown <br>
* - Insert an extent into the EditSession using the EditSessionEvent: http://wiki.sk89q.com/wiki/WorldEdit/API/Hooking_EditSession <br>
* @see com.sk89q.worldedit.EditSession#getFaweExtent() To get the FaweExtent for an EditSession
* @param extent
* @param reason
*/
public void cancelEdit(Extent extent, BBC reason) {
try {
WEManager.IMP.cancelEdit(extent, reason);
} catch (WorldEditException ignore) {}
}
/**
* Get the DiskStorageHistory object representing a File
* @param file
* @return
*/
public DiskStorageHistory getChangeSetFromFile(File file) {
if (!file.exists() || file.isDirectory()) {
throw new IllegalArgumentException("Not a file!");
}
if (!file.getName().toLowerCase().endsWith(".bd")) {
throw new IllegalArgumentException("Not a BD file!");
}
if (Settings.STORE_HISTORY_ON_DISK) {
throw new IllegalArgumentException("History on disk not enabled!");
}
String[] path = file.getPath().split(File.separator);
if (path.length < 3) {
throw new IllegalArgumentException("Not in history directory!");
}
String worldName = path[path.length - 3];
String uuidString = path[path.length - 2];
World world = null;
for (World current : WorldEdit.getInstance().getServer().getWorlds()) {
if (current.getName().equals(worldName)) {
world = current;
break;
}
}
if (world == null) {
throw new IllegalArgumentException("Corresponding world does not exist: " + worldName);
}
UUID uuid;
try {
uuid = UUID.fromString(uuidString);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Invalid UUID from file path: " + uuidString);
}
DiskStorageHistory history = new DiskStorageHistory(world, uuid, Integer.parseInt(file.getName().split("\\.")[0]));
return history;
}
/**
* Used in the RollBack to generate a list of DiskStorageHistory objects<br>
* - Note: An edit outside the radius may be included if it overlaps with an edit inside that depends on it.
* @param origin - The origin location
* @param user - The uuid (may be null)
* @param radius - The radius from the origin of the edit
* @param timediff - The max age of the file in milliseconds
* @param shallow - If shallow is true, FAWE will only read the first Settings.BUFFER_SIZE bytes to obtain history info<br>
* Reading only part of the file will result in unreliable bounds info for large edits
* @return
*/
public static List<DiskStorageHistory> getBDFiles(FaweLocation origin, UUID user, int radius, long timediff, boolean shallow) {
File history = new File(Fawe.imp().getDirectory(), "history" + File.separator + origin.world);
if (!history.exists()) {
return new ArrayList<>();
}
long now = System.currentTimeMillis();
ArrayList<File> files = new ArrayList<>();
for (File userFile : history.listFiles()) {
if (!userFile.isDirectory()) {
continue;
}
UUID userUUID;
try {
userUUID = UUID.fromString(userFile.getName());
} catch (IllegalArgumentException e) {
continue;
}
if (user != null && !userUUID.equals(user)) {
continue;
}
ArrayList<Integer> ids = new ArrayList<>();
for (File file : userFile.listFiles()) {
if (file.getName().endsWith(".bd")) {
if (timediff >= Integer.MAX_VALUE || now - file.lastModified() <= timediff) {
files.add(file);
if (files.size() > 2048) {
return null;
}
}
}
}
}
World world = origin.getWorld();
Collections.sort(files, new Comparator<File>() {
@Override
public int compare(File a, File b) {
long value = a.lastModified() - b.lastModified();
return value == 0 ? 0 : value < 0 ? -1 : 1;
}
});
RegionWrapper bounds = new RegionWrapper(origin.x - radius, origin.x + radius, origin.z - radius, origin.z + radius);
RegionWrapper boundsPlus = new RegionWrapper(bounds.minX - 64, bounds.maxX + 512, bounds.minZ - 64, bounds.maxZ + 512);
HashSet<RegionWrapper> regionSet = new HashSet<RegionWrapper>(Arrays.asList(bounds));
ArrayList<DiskStorageHistory> result = new ArrayList<>();
for (File file : files) {
UUID uuid = UUID.fromString(file.getParentFile().getName());
DiskStorageHistory dsh = new DiskStorageHistory(world, uuid, Integer.parseInt(file.getName().split("\\.")[0]));
DiskStorageHistory.DiskStorageSummary summary = dsh.summarize(boundsPlus, shallow);
RegionWrapper region = new RegionWrapper(summary.minX, summary.maxX, summary.minZ, summary.maxZ);
boolean encompassed = false;
boolean isIn = false;
for (RegionWrapper allowed : regionSet) {
isIn = isIn || allowed.intersects(region);
if (encompassed = allowed.isIn(region.minX, region.maxX) && allowed.isIn(region.minZ, region.maxZ)) {
break;
}
}
if (isIn) {
result.add(0, dsh);
if (!encompassed) {
regionSet.add(region);
}
if (shallow && result.size() > 64) {
return result;
}
}
}
return result;
}
/**
* The DiskStorageHistory class is what FAWE uses to represent the undo on disk.
* @see com.boydti.fawe.object.changeset.DiskStorageHistory#toEditSession(com.sk89q.worldedit.entity.Player)
* @param world
* @param uuid
* @param index
* @return
*/
public DiskStorageHistory getChangeSetFromDisk(World world, UUID uuid, int index) {
return new DiskStorageHistory(world, uuid, index);
}
/**
* Compare two versions
* @param version
@ -41,12 +280,23 @@ public class FaweAPI {
return (version[0] > major) || ((version[0] == major) && (version[1] > minor)) || ((version[0] == major) && (version[1] == minor) && (version[2] >= minor2));
}
/**
* Fix the lighting in a chunk
* @param world
* @param x
* @param z
* @param fixAll
*/
public static void fixLighting(String world, int x, int z, final boolean fixAll) {
FaweQueue queue = SetQueue.IMP.getNewQueue(world, false);
queue.fixLighting(queue.getChunk(x, z), fixAll);
}
/**
* Fix the lighting in a chunk
* @param chunk
* @param fixAll
*/
public static void fixLighting(final Chunk chunk, final boolean fixAll) {
FaweQueue queue = SetQueue.IMP.getNewQueue(chunk.getWorld().getName(), false);
queue.fixLighting(queue.getChunk(chunk.getX(), chunk.getZ()), fixAll);
@ -55,59 +305,49 @@ public class FaweAPI {
/**
* If a schematic is too large to be pasted normally<br>
* - Skips any block history
* - Ignores some block data
* - No, it's not streaming it from disk, but it is a lot faster
* - Ignores nbt
* - No, technically I haven't added proper streaming yet (WIP)
* @param file
* @param loc
* @return
*/
public static void streamSchematicAsync(final File file, final Location loc) {
public static void streamSchematic(final File file, final Location loc) {
final FaweLocation fl = new FaweLocation(loc.getWorld().getName(), loc.getBlockX(), loc.getBlockY(), loc.getBlockZ());
streamSchematicAsync(file, fl);
streamSchematic(file, fl);
}
/**
* If a schematic is too large to be pasted normally<br>
* - Skips any block history
* - Ignores some block data
* - Ignores nbt
* @param file
* @param loc
* @return
*/
public static void streamSchematicAsync(final File file, final FaweLocation loc) {
TaskManager.IMP.async(new Runnable() {
@Override
public void run() {
try {
final FileInputStream is = new FileInputStream(file);
streamSchematic(is, loc);
} catch (final IOException e) {
e.printStackTrace();
}
}
});
public static void streamSchematic(final File file, final FaweLocation loc) {
try {
final FileInputStream is = new FileInputStream(file);
streamSchematic(is, loc);
} catch (final IOException e) {
e.printStackTrace();
}
}
/**
* If a schematic is too large to be pasted normally<br>
* - Skips any block history
* - Ignores some block data
* - Ignores nbt
* @param url
* @param loc
*/
public static void streamSchematicAsync(final URL url, final FaweLocation loc) {
TaskManager.IMP.async(new Runnable() {
@Override
public void run() {
try {
final ReadableByteChannel rbc = Channels.newChannel(url.openStream());
final InputStream is = Channels.newInputStream(rbc);
streamSchematic(is, loc);
} catch (final IOException e) {
e.printStackTrace();
}
}
});
public static void streamSchematic(final URL url, final FaweLocation loc) {
try {
final ReadableByteChannel rbc = Channels.newChannel(url.openStream());
final InputStream is = Channels.newInputStream(rbc);
streamSchematic(is, loc);
} catch (final IOException e) {
e.printStackTrace();
}
}
/**
@ -241,10 +481,34 @@ public class FaweAPI {
}
/**
* Set a task to run when the async queue is empty
* Set a task to run when the global queue (SetQueue class) is empty
* @param whenDone
*/
public static void addTask(final Runnable whenDone) {
SetQueue.IMP.addTask(whenDone);
}
/**
* Have a task run when the server is low on memory (configured threshold)
* @param run
*/
public static void addMemoryLimitedTask(Runnable run) {
MemUtil.addMemoryLimitedTask(run);
}
/**
* Have a task run when the server is no longer low on memory (configured threshold)
* @param run
*/
public static void addMemoryPlentifulTask(Runnable run) {
MemUtil.addMemoryPlentifulTask(run);
}
/**
* @see BBC
* @return
*/
public BBC[] getTranslations() {
return BBC.values();
}
}

115
core/src/main/java/com/boydti/fawe/object/FawePlayer.java
View File

@ -15,6 +15,7 @@ import com.sk89q.worldedit.regions.RegionSelector;
import com.sk89q.worldedit.regions.selector.CuboidRegionSelector;
import com.sk89q.worldedit.world.World;
import java.io.File;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
@ -32,7 +33,35 @@ public abstract class FawePlayer<T> {
*/
private volatile ConcurrentHashMap<String, Object> meta;
/**
* Wrap some object into a FawePlayer<br>
* - org.bukkit.entity.Player
* - org.spongepowered.api.entity.living.player
* - com.sk89q.worldedit.entity.Player
* - String (name)
* - UUID (player UUID)
* @param obj
* @param <V>
* @return
*/
public static <V> FawePlayer<V> wrap(final Object obj) {
if (obj == null) {
return null;
}
if (obj instanceof Player) {
Player actor = (Player) obj;
try {
Field fieldBasePlayer = actor.getClass().getDeclaredField("basePlayer");
fieldBasePlayer.setAccessible(true);
Player player = (Player) fieldBasePlayer.get(actor);
Field fieldPlayer = player.getClass().getDeclaredField("player");
fieldPlayer.setAccessible(true);
return Fawe.imp().wrap(fieldPlayer.get(player));
} catch (Throwable e) {
e.printStackTrace();
return Fawe.imp().wrap(actor.getName());
}
}
return Fawe.imp().wrap(obj);
}
@ -49,7 +78,7 @@ public abstract class FawePlayer<T> {
if (world != null) {
if (world.getName().equals(currentWorldName)) {
getSession().clearHistory();
loadSessionFromDisk(world);
loadSessionsFromDisk(world);
}
}
} catch (Exception e) {
@ -58,6 +87,10 @@ public abstract class FawePlayer<T> {
}
}
/**
* Get the current World
* @return
*/
public World getWorld() {
String currentWorldName = getLocation().world;
for (World world : WorldEdit.getInstance().getServer().getWorlds()) {
@ -68,7 +101,12 @@ public abstract class FawePlayer<T> {
return null;
}
public void loadSessionFromDisk(World world) {
/**
* Load all the undo EditSession's from disk for a world <br>
* - Usually already called when a player joins or changes world
* @param world
*/
public void loadSessionsFromDisk(World world) {
if (world == null) {
return;
}
@ -94,26 +132,68 @@ public abstract class FawePlayer<T> {
}
}
/**
* Get the player's limit
* @return
*/
public FaweLimit getLimit() {
return Settings.getLimit(this);
}
/**
* Get the player's name
* @return
*/
public abstract String getName();
/**
* Get the player's UUID
* @return
*/
public abstract UUID getUUID();
/**
* Check the player's permission
* @param perm
* @return
*/
public abstract boolean hasPermission(final String perm);
/**
* Set a permission (requires Vault)
* @param perm
* @param flag
*/
public abstract void setPermission(final String perm, final boolean flag);
/**
* Send a message to the player
* @param message
*/
public abstract void sendMessage(final String message);
/**
* Have the player execute a command
* @param substring
*/
public abstract void executeCommand(final String substring);
/**
* Get the player's location
* @return
*/
public abstract FaweLocation getLocation();
/**
* Get the WorldEdit player object
* @return
*/
public abstract Player getPlayer();
/**
* Get the player's current selection (or null)
* @return
*/
public Region getSelection() {
try {
return this.getSession().getSelection(this.getPlayer().getWorld());
@ -122,20 +202,36 @@ public abstract class FawePlayer<T> {
}
}
/**
* Get the player's current LocalSession
* @return
*/
public LocalSession getSession() {
return (this.session != null || this.getPlayer() == null) ? this.session : (session = Fawe.get().getWorldEdit().getSession(this.getPlayer()));
}
/**
* Get the player's current allowed WorldEdit regions
* @return
*/
public HashSet<RegionWrapper> getCurrentRegions() {
return WEManager.IMP.getMask(this);
}
/**
* Set the player's WorldEdit selection to the following CuboidRegion
* @param region
*/
public void setSelection(final RegionWrapper region) {
final Player player = this.getPlayer();
final RegionSelector selector = new CuboidRegionSelector(player.getWorld(), region.getBottomVector(), region.getTopVector());
this.getSession().setRegionSelector(player.getWorld(), selector);
}
/**
* Get the largest region in the player's allowed WorldEdit region
* @return
*/
public RegionWrapper getLargestRegion() {
int area = 0;
RegionWrapper max = null;
@ -154,6 +250,10 @@ public abstract class FawePlayer<T> {
return this.getName();
}
/**
* Check if the player has WorldEdit bypass enabled
* @return
*/
public boolean hasWorldEditBypass() {
return this.hasPermission("fawe.bypass");
}
@ -183,6 +283,13 @@ public abstract class FawePlayer<T> {
return null;
}
/**
* Get the metadata for a specific key (or return the default provided)
* @param key
* @param def
* @param <V>
* @return
*/
public <V> V getMeta(String key, V def) {
if (this.meta != null) {
V value = (V) this.meta.get(key);
@ -201,6 +308,10 @@ public abstract class FawePlayer<T> {
return this.meta == null ? null : this.meta.remove(key);
}
/**
* Unregister this player (delets all metadata etc)
* - Usually called on logout
*/
public void unregister() {
getSession().setClipboard(null);
getSession().clearHistory();

5
core/src/main/java/com/boydti/fawe/object/IntegerPair.java
View File

@ -19,6 +19,11 @@ public class IntegerPair {
return this.hash;
}
@Override
public String toString() {
return x + "," + z;
}
@Override
public boolean equals(final Object obj) {
if (this == obj) {

4
core/src/main/java/com/boydti/fawe/object/RegionWrapper.java
View File

@ -46,6 +46,10 @@ public class RegionWrapper {
return minZ - z;
}
public boolean intersects(RegionWrapper other) {
return other.minX <= this.maxX && other.maxX >= this.minX && other.minZ <= this.maxZ && other.maxZ >= this.minZ;
}
public int distance(int x, int z) {
if (isIn(x, z)) {
return 0;

2
core/src/main/java/com/boydti/fawe/object/changeset/DiskStorageHistory.java
View File

@ -130,7 +130,7 @@ public class DiskStorageHistory implements ChangeSet, FaweChangeSet {
init(world, uuid, index);
}
public void init(World world, UUID uuid, int i) {
private void init(World world, UUID uuid, int i) {
this.uuid = uuid;
this.world = world;
String base = "history" + File.separator + world.getName() + File.separator + uuid;

6
core/src/main/java/com/boydti/fawe/object/exception/FaweException.java
View File

@ -15,10 +15,10 @@ public class FaweException extends RuntimeException {
}
public static FaweException get(Throwable e) {
Throwable cause = e.getCause();
if (cause instanceof FaweException) {
return (FaweException) cause;
if (e instanceof FaweException) {
return (FaweException) e;
}
Throwable cause = e.getCause();
if (cause == null) {
return null;
}

65
core/src/main/java/com/boydti/fawe/util/MainUtil.java
View File

@ -2,24 +2,15 @@ package com.boydti.fawe.util;
import com.boydti.fawe.Fawe;
import com.boydti.fawe.config.BBC;
import com.boydti.fawe.object.FaweLocation;
import com.boydti.fawe.object.FawePlayer;
import com.boydti.fawe.object.RegionWrapper;
import com.boydti.fawe.object.RunnableVal;
import com.boydti.fawe.object.changeset.DiskStorageHistory;
import com.sk89q.jnbt.CompoundTag;
import com.sk89q.jnbt.EndTag;
import com.sk89q.jnbt.ListTag;
import com.sk89q.jnbt.Tag;
import com.sk89q.worldedit.world.World;
import java.io.File;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.UUID;
public class MainUtil {
/*
@ -139,62 +130,6 @@ public class MainUtil {
return time;
}
public static List<DiskStorageHistory> getBDFiles(FaweLocation origin, UUID user, int radius, long timediff, boolean shallow) {
File history = new File(Fawe.imp().getDirectory(), "history" + File.separator + origin.world);
if (!history.exists()) {
return new ArrayList<>();
}
long now = System.currentTimeMillis();
ArrayList<File> files = new ArrayList<>();
for (File userFile : history.listFiles()) {
if (!userFile.isDirectory()) {
continue;
}
UUID userUUID;
try {
userUUID = UUID.fromString(userFile.getName());
} catch (IllegalArgumentException e) {
continue;
}
if (user != null && !userUUID.equals(user)) {
continue;
}
ArrayList<Integer> ids = new ArrayList<>();
for (File file : userFile.listFiles()) {
if (file.getName().endsWith(".bd")) {
if (timediff > Integer.MAX_VALUE || now - file.lastModified() <= timediff) {
files.add(file);
if (files.size() > 2048) {
return null;
}
}
}
}
}
World world = origin.getWorld();
Collections.sort(files, new Comparator<File>() {
@Override
public int compare(File a, File b) {
long value = a.lastModified() - b.lastModified();
return value == 0 ? 0 : value < 0 ? 1 : -1;
}
});
ArrayList<DiskStorageHistory> result = new ArrayList<>();
for (File file : files) {
UUID uuid = UUID.fromString(file.getParentFile().getName());
DiskStorageHistory dsh = new DiskStorageHistory(world, uuid, Integer.parseInt(file.getName().split("\\.")[0]));
DiskStorageHistory.DiskStorageSummary summary = dsh.summarize(new RegionWrapper(origin.x - 512, origin.x + 512, origin.z - 512, origin.z + 512), shallow);
RegionWrapper region = new RegionWrapper(summary.minX, summary.maxX, summary.minZ, summary.maxZ);
if (region.distance(origin.x, origin.z) <= radius) {
result.add(dsh);
if (result.size() > 64) {
return null;
}
}
}
return result;
}
public static void deleteOlder(File directory, final long timeDiff) {
final long now = System.currentTimeMillis();
iterateFiles(directory, new RunnableVal<File>() {

21
core/src/main/java/com/boydti/fawe/util/MemUtil.java
View File

@ -1,6 +1,8 @@
package com.boydti.fawe.util;
import com.boydti.fawe.config.Settings;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.atomic.AtomicBoolean;
public class MemUtil {
@ -30,11 +32,30 @@ public class MemUtil {
return size;
}
private static BlockingQueue<Runnable> memoryLimitedTasks = new LinkedBlockingQueue<>();
private static BlockingQueue<Runnable> memoryPlentifulTasks = new LinkedBlockingQueue<>();
public static void addMemoryLimitedTask(Runnable run) {
if (run != null)
memoryLimitedTasks.add(run);
}
public static void addMemoryPlentifulTask(Runnable run) {
if (run != null)
memoryPlentifulTasks.add(run);
}
public static void memoryLimitedTask() {
for (Runnable task : memoryLimitedTasks) {
task.run();
}
memory.set(true);
}
public static void memoryPlentifulTask() {
for (Runnable task : memoryPlentifulTasks) {
task.run();
}
memory.set(false);
}
}

82
core/src/main/java/com/boydti/fawe/util/TaskManager.java
View File

@ -4,19 +4,46 @@ import com.boydti.fawe.Fawe;
import com.boydti.fawe.object.RunnableVal;
import java.util.Collection;
import java.util.Iterator;
import java.util.concurrent.atomic.AtomicBoolean;
public abstract class TaskManager {
public static TaskManager IMP;
/**
* Run a repeating task on the main thread
* @param r
* @param interval in ticks
* @return
*/
public abstract int repeat(final Runnable r, final int interval);
/**
* Run a repeating task asynchronously
* @param r
* @param interval in ticks
* @return
*/
public abstract int repeatAsync(final Runnable r, final int interval);
/**
* Run a task asynchronously
* @param r
*/
public abstract void async(final Runnable r);
/**
* Run a task on the main thread
* @param r
*/
public abstract void task(final Runnable r);
/**
* Run a task on either the main thread or asynchronously
* - If it's already the main thread, it will jst call run()
* @param r
* @param async
*/
public void task(final Runnable r, boolean async) {
if (async) {
async(r);
@ -31,12 +58,35 @@ public abstract class TaskManager {
}
}
/**
* Run a task later on the main thread
* @param r
* @param delay in ticks
*/
public abstract void later(final Runnable r, final int delay);
/**
* Run a task later asynchronously
* @param r
* @param delay in ticks
*/
public abstract void laterAsync(final Runnable r, final int delay);
/**
* Cancel a task
* @param task
*/
public abstract void cancel(final int task);
/**
* Break up a task and run it in fragments of 5ms.<br>
* - Each task will run on the main thread.<br>
* - Usualy wait time is around 25ms<br>
* @param objects - The list of objects to run the task for
* @param task - The task to run on each object
* @param whenDone - When the object task completes
* @param <T>
*/
public <T> void objectTask(Collection<T> objects, final RunnableVal<T> task, final Runnable whenDone) {
final Iterator<T> iterator = objects.iterator();
task(new Runnable() {
@ -57,11 +107,31 @@ public abstract class TaskManager {
});
}
/**
* Quickly run a task on the main thread, and wait for execution to finish:<br>
* - Useful if you need to access something from the Bukkit API from another thread<br>
* @param function
* @param <T>
* @return
*/
public <T> T sync(final RunnableVal<T> function) {
return sync(function, Integer.MAX_VALUE);
}
/**
* Quickly run a task on the main thread, and wait for execution to finish:<br>
* - Useful if you need to access something from the Bukkit API from another thread<br>
* @param function
* @param timeout - How long to wait for execution
* @param <T>
* @return
*/
public <T> T sync(final RunnableVal<T> function, int timeout) {
if (Fawe.get().getMainThread() == Thread.currentThread()) {
function.run();
return function.value;
}
final AtomicBoolean running = new AtomicBoolean(true);
RunnableVal<RuntimeException> run = new RunnableVal<RuntimeException>() {
@Override
public void run(RuntimeException value) {
@ -71,6 +141,8 @@ public abstract class TaskManager {
this.value = e;
} catch (Throwable neverHappens) {
neverHappens.printStackTrace();
} finally {
running.set(false);
}
synchronized (function) {
function.notifyAll();
@ -78,16 +150,18 @@ public abstract class TaskManager {
}
};
TaskManager.IMP.task(run);
if (run.value != null) {
throw run.value;
}
try {
synchronized (function) {
function.wait(15000);
while (running.get()) {
function.wait(timeout);
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
if (run.value != null) {
throw run.value;
}
return function.value;
}
}

18
core/src/main/java/com/sk89q/worldedit/extension/platform/CommandManager.java
View File

@ -19,7 +19,6 @@
package com.sk89q.worldedit.extension.platform;
import com.boydti.fawe.Fawe;
import com.boydti.fawe.config.BBC;
import com.boydti.fawe.object.FawePlayer;
import com.boydti.fawe.object.exception.FaweException;
@ -86,7 +85,6 @@ import com.sk89q.worldedit.util.logging.DynamicStreamHandler;
import com.sk89q.worldedit.util.logging.LogFormat;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.Field;
import java.util.logging.FileHandler;
import java.util.logging.Level;
import java.util.logging.Logger;
@ -238,19 +236,8 @@ public final class CommandManager {
LocalConfiguration config = worldEdit.getConfiguration();
CommandLocals locals = new CommandLocals();
FawePlayer fp;
if (actor != null && actor.isPlayer()) {
try {
Field fieldBasePlayer = actor.getClass().getDeclaredField("basePlayer");
fieldBasePlayer.setAccessible(true);
Player player = (Player) fieldBasePlayer.get(actor);
Field fieldPlayer = player.getClass().getDeclaredField("player");
fieldPlayer.setAccessible(true);
fp = Fawe.imp().wrap(fieldPlayer.get(player));
} catch (Throwable e) {
e.printStackTrace();
fp = Fawe.imp().wrap(actor.getName());
}
FawePlayer fp = FawePlayer.wrap(actor);
if (fp != null) {
if (fp.getMeta("fawe_action") != null) {
BBC.WORLDEDIT_COMMAND_LIMIT.send(fp);
return;
@ -259,7 +246,6 @@ public final class CommandManager {
locals.put(Actor.class, new PlayerWrapper((Player) actor));
} else {
locals.put(Actor.class, actor);
fp = null;
}
locals.put("arguments", event.getArguments());
final long start = System.currentTimeMillis();

512
core/src/main/java/com/sk89q/worldedit/extension/platform/PlatformManager.java Normal file
View File

@ -0,0 +1,512 @@
/*
* WorldEdit, a Minecraft world manipulation toolkit
* Copyright (C) sk89q <http://www.sk89q.com>
* Copyright (C) WorldEdit team and contributors
*
* This program is free software: you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License
* for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package com.sk89q.worldedit.extension.platform;
import com.boydti.fawe.config.BBC;
import com.boydti.fawe.object.exception.FaweException;
import com.sk89q.worldedit.LocalConfiguration;
import com.sk89q.worldedit.LocalSession;
import com.sk89q.worldedit.ServerInterface;
import com.sk89q.worldedit.Vector;
import com.sk89q.worldedit.WorldEdit;
import com.sk89q.worldedit.WorldVector;
import com.sk89q.worldedit.command.tool.BlockTool;
import com.sk89q.worldedit.command.tool.DoubleActionBlockTool;
import com.sk89q.worldedit.command.tool.DoubleActionTraceTool;
import com.sk89q.worldedit.command.tool.Tool;
import com.sk89q.worldedit.command.tool.TraceTool;
import com.sk89q.worldedit.entity.Player;
import com.sk89q.worldedit.event.platform.BlockInteractEvent;
import com.sk89q.worldedit.event.platform.ConfigurationLoadEvent;
import com.sk89q.worldedit.event.platform.Interaction;
import com.sk89q.worldedit.event.platform.PlatformInitializeEvent;
import com.sk89q.worldedit.event.platform.PlatformReadyEvent;
import com.sk89q.worldedit.event.platform.PlayerInputEvent;
import com.sk89q.worldedit.extension.platform.permission.ActorSelectorLimits;
import com.sk89q.worldedit.internal.ServerInterfaceAdapter;
import com.sk89q.worldedit.regions.RegionSelector;
import com.sk89q.worldedit.util.Location;
import com.sk89q.worldedit.util.eventbus.Subscribe;
import com.sk89q.worldedit.world.World;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.EnumMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.Nullable;
import static com.google.common.base.Preconditions.checkNotNull;
/**
* Manages registered {@link Platform}s for WorldEdit. Platforms are
* implementations of WorldEdit.
*
* <p>This class is thread-safe.</p>
*/
public class PlatformManager {
private static final Logger logger = Logger.getLogger(PlatformManager.class.getCanonicalName());
private final WorldEdit worldEdit;
private final CommandManager commandManager;
private final List<Platform> platforms = new ArrayList<Platform>();
private final Map<Capability, Platform> preferences = new EnumMap<Capability, Platform>(Capability.class);
private @Nullable String firstSeenVersion;
private final AtomicBoolean initialized = new AtomicBoolean();
private final AtomicBoolean configured = new AtomicBoolean();
/**
* Create a new platform manager.
*
* @param worldEdit the WorldEdit instance
*/
public PlatformManager(WorldEdit worldEdit) {
checkNotNull(worldEdit);
this.worldEdit = worldEdit;
this.commandManager = new CommandManager(worldEdit, this);
// Register this instance for events
worldEdit.getEventBus().register(this);
}
/**
* Register a platform with WorldEdit.
*
* @param platform the platform
*/
public synchronized void register(Platform platform) {
checkNotNull(platform);
logger.log(Level.FINE, "Got request to register " + platform.getClass() + " with WorldEdit [" + super.toString() + "]");
// Just add the platform to the list of platforms: we'll pick favorites
// once all the platforms have been loaded
platforms.add(platform);
// Make sure that versions are in sync
if (firstSeenVersion != null) {
if (!firstSeenVersion.equals(platform.getVersion())) {
logger.log(Level.WARNING, "Multiple ports of WorldEdit are installed but they report different versions ({0} and {1}). " +
"If these two versions are truly different, then you may run into unexpected crashes and errors.",
new Object[]{ firstSeenVersion, platform.getVersion() });
}
} else {
firstSeenVersion = platform.getVersion();
}
}
/**
* Unregister a platform from WorldEdit.
*
* <p>If the platform has been chosen for any capabilities, then a new
* platform will be found.</p>
*
* @param platform the platform
*/
public synchronized boolean unregister(Platform platform) {
checkNotNull(platform);
boolean removed = platforms.remove(platform);
if (removed) {
logger.log(Level.FINE, "Unregistering " + platform.getClass().getCanonicalName() + " from WorldEdit");
boolean choosePreferred = false;
// Check whether this platform was chosen to be the preferred one
// for any capability and be sure to remove it
Iterator<Entry<Capability, Platform>> it = preferences.entrySet().iterator();
while (it.hasNext()) {
Entry<Capability, Platform> entry = it.next();
if (entry.getValue().equals(platform)) {
Capability key = entry.getKey();
try {
Method methodUnload = key.getClass().getDeclaredMethod("unload", PlatformManager.class, Platform.class);
methodUnload.setAccessible(true);
methodUnload.invoke(key, this, entry.getValue());
} catch (Throwable e) {
throw new RuntimeException(e);
}
it.remove();
choosePreferred = true; // Have to choose new favorites
}
}
if (choosePreferred) {
choosePreferred();
}
}
return removed;
}
/**
* Get the preferred platform for handling a certain capability. Returns
* null if none is available.
*
* @param capability the capability
* @return the platform
* @throws NoCapablePlatformException thrown if no platform is capable
*/
public synchronized Platform queryCapability(Capability capability) throws NoCapablePlatformException {
Platform platform = preferences.get(checkNotNull(capability));
if (platform != null) {
return platform;
} else {
throw new NoCapablePlatformException("No platform was found supporting " + capability.name());
}
}
/**
* Choose preferred platforms and perform necessary initialization.
*/
private synchronized void choosePreferred() {
for (Capability capability : Capability.values()) {
Platform preferred = findMostPreferred(capability);
if (preferred != null) {
preferences.put(capability, preferred);
try {
Method methodInitialize = Capability.class.getDeclaredMethod("initialize", PlatformManager.class, Platform.class);
methodInitialize.setAccessible(true);
methodInitialize.invoke(capability, this, preferred);
} catch (Throwable e) {
throw new RuntimeException(e);
}
}
}
// Fire configuration event
if (preferences.containsKey(Capability.CONFIGURATION) && configured.compareAndSet(false, true)) {
worldEdit.getEventBus().post(new ConfigurationLoadEvent(queryCapability(Capability.CONFIGURATION).getConfiguration()));
}
}
/**
* Find the most preferred platform for a given capability from the list of
* platforms. This does not use the map of preferred platforms.
*
* @param capability the capability
* @return the most preferred platform, or null if no platform was found
*/
private synchronized @Nullable Platform findMostPreferred(Capability capability) {
Platform preferred = null;
Preference highest = null;
for (Platform platform : platforms) {
Preference preference = platform.getCapabilities().get(capability);
if (preference != null && (highest == null || preference.isPreferredOver(highest))) {
preferred = platform;
highest = preference;
}
}
return preferred;
}
/**
* Get a list of loaded platforms.
*
* <p>The returned list is a copy of the original and is mutable.</p>
*
* @return a list of platforms
*/
public synchronized List<Platform> getPlatforms() {
return new ArrayList<Platform>(platforms);
}
/**
* Given a world, possibly return the same world but using a different
* platform preferred for world editing operations.
*
* @param base the world to match
* @return the preferred world, if one was found, otherwise the given world
*/
public World getWorldForEditing(World base) {
checkNotNull(base);
World match = queryCapability(Capability.WORLD_EDITING).matchWorld(base);
return match != null ? match : base;
}
/**
* Given an actor, return a new one that may use a different platform
* for permissions and world editing.
*
* @param base the base actor to match
* @return a new delegate actor
*/
@SuppressWarnings("unchecked")
public <T extends Actor> T createProxyActor(T base) {
checkNotNull(base);
if (base instanceof Player) {
Player player = (Player) base;
Player permActor = queryCapability(Capability.PERMISSIONS).matchPlayer(player);
if (permActor == null) {
permActor = player;
}
Player cuiActor = queryCapability(Capability.WORLDEDIT_CUI).matchPlayer(player);
if (cuiActor == null) {
cuiActor = player;
}
try {
Class<?> clazz = Class.forName("com.sk89q.worldedit.extension.platform.PlayerProxy");
Constructor<?> constructor = clazz.getDeclaredConstructor(Player.class, Actor.class, Actor.class, World.class);
constructor.setAccessible(true);
return (T) constructor.newInstance(player, permActor, cuiActor, getWorldForEditing(player.getWorld()));
} catch (Throwable e) {
throw new RuntimeException(e);
}
} else {
return base;
}
}
/**
* Get the command manager.
*
* @return the command manager
*/
public CommandManager getCommandManager() {
return commandManager;
}
/**
* Get the current configuration.
*
* <p>If no platform has been registered yet, then a default configuration
* will be returned.</p>
*
* @return the configuration
*/
public LocalConfiguration getConfiguration() {
return queryCapability(Capability.CONFIGURATION).getConfiguration();
}
/**
* Return a legacy {@link ServerInterface}.
*
* @return a {@link ServerInterface}
* @throws IllegalStateException if no platform has been registered
*/
@SuppressWarnings("deprecation")
public ServerInterface getServerInterface() throws IllegalStateException {
return ServerInterfaceAdapter.adapt(queryCapability(Capability.USER_COMMANDS));
}
@Subscribe
public void handlePlatformReady(PlatformReadyEvent event) {
choosePreferred();
if (initialized.compareAndSet(false, true)) {
worldEdit.getEventBus().post(new PlatformInitializeEvent());
}
}
@SuppressWarnings("deprecation")
@Subscribe
public void handleBlockInteract(BlockInteractEvent event) {
// Create a proxy actor with a potentially different world for
// making changes to the world
Actor actor = createProxyActor(event.getCause());
try {
Location location = event.getLocation();
Vector vector = location.toVector();
// At this time, only handle interaction from players
if (actor instanceof Player) {
Player player = (Player) actor;
LocalSession session = worldEdit.getSessionManager().get(actor);
if (event.getType() == Interaction.HIT) {
if (player.getItemInHand() == getConfiguration().wandItem) {
if (!session.isToolControlEnabled()) {
return;
}
if (!actor.hasPermission("worldedit.selection.pos")) {
return;
}
RegionSelector selector = session.getRegionSelector(player.getWorld());
if (selector.selectPrimary(location.toVector(), ActorSelectorLimits.forActor(player))) {
selector.explainPrimarySelection(actor, session, vector);
}
event.setCancelled(true);
return;
}
if (player.isHoldingPickAxe() && session.hasSuperPickAxe()) {
final BlockTool superPickaxe = session.getSuperPickaxe();
if (superPickaxe != null && superPickaxe.canUse(player)) {
event.setCancelled(superPickaxe.actPrimary(queryCapability(Capability.WORLD_EDITING), getConfiguration(), player, session, location));
return;
}
}
Tool tool = session.getTool(player.getItemInHand());
if (tool != null && tool instanceof DoubleActionBlockTool) {
if (tool.canUse(player)) {
((DoubleActionBlockTool) tool).actSecondary(queryCapability(Capability.WORLD_EDITING), getConfiguration(), player, session, location);
event.setCancelled(true);
}
}
} else if (event.getType() == Interaction.OPEN) {
if (player.getItemInHand() == getConfiguration().wandItem) {
if (!session.isToolControlEnabled()) {
return;
}
if (!actor.hasPermission("worldedit.selection.pos")) {
return;
}
RegionSelector selector = session.getRegionSelector(player.getWorld());
if (selector.selectSecondary(vector, ActorSelectorLimits.forActor(player))) {
selector.explainSecondarySelection(actor, session, vector);
}
event.setCancelled(true);
return;
}
Tool tool = session.getTool(player.getItemInHand());
if (tool != null && tool instanceof BlockTool) {
if (tool.canUse(player)) {
((BlockTool) tool).actPrimary(queryCapability(Capability.WORLD_EDITING), getConfiguration(), player, session, location);
event.setCancelled(true);
}
}
}
}
} catch (Throwable e) {
FaweException faweException = FaweException.get(e);
if (faweException != null) {
actor.printError(BBC.PREFIX.s() + " " + BBC.WORLDEDIT_CANCEL_REASON.format(faweException.getMessage()));
} else {
actor.printError("Please report this error: [See console]");
actor.printRaw(e.getClass().getName() + ": " + e.getMessage());
e.printStackTrace();
}
}
}
@SuppressWarnings("deprecation")
@Subscribe
public void handlePlayerInput(PlayerInputEvent event) {
// Create a proxy actor with a potentially different world for
// making changes to the world
Player player = createProxyActor(event.getPlayer());
try {
switch (event.getInputType()) {
case PRIMARY: {
if (player.getItemInHand() == getConfiguration().navigationWand) {
if (getConfiguration().navigationWandMaxDistance <= 0) {
return;
}
if (!player.hasPermission("worldedit.navigation.jumpto.tool")) {
return;
}
WorldVector pos = player.getSolidBlockTrace(getConfiguration().navigationWandMaxDistance);
if (pos != null) {
player.findFreePosition(pos);
} else {
player.printError("No block in sight (or too far)!");
}
event.setCancelled(true);
return;
}
LocalSession session = worldEdit.getSessionManager().get(player);
Tool tool = session.getTool(player.getItemInHand());
if (tool != null && tool instanceof DoubleActionTraceTool) {
if (tool.canUse(player)) {
((DoubleActionTraceTool) tool).actSecondary(queryCapability(Capability.WORLD_EDITING), getConfiguration(), player, session);
event.setCancelled(true);
return;
}
}
break;
}
case SECONDARY: {
if (player.getItemInHand() == getConfiguration().navigationWand) {
if (getConfiguration().navigationWandMaxDistance <= 0) {
return;
}
if (!player.hasPermission("worldedit.navigation.thru.tool")) {
return;
}
if (!player.passThroughForwardWall(40)) {
player.printError("Nothing to pass through!");
}
event.setCancelled(true);
return;
}
LocalSession session = worldEdit.getSessionManager().get(player);
Tool tool = session.getTool(player.getItemInHand());
if (tool != null && tool instanceof TraceTool) {
if (tool.canUse(player)) {
((TraceTool) tool).actPrimary(queryCapability(Capability.WORLD_EDITING), getConfiguration(), player, session);
event.setCancelled(true);
return;
}
}
break;
}
}
} catch (Throwable e) {
FaweException faweException = FaweException.get(e);
if (faweException != null) {
player.printError(BBC.PREFIX.s() + " " + BBC.WORLDEDIT_CANCEL_REASON.format(faweException.getMessage()));
} else {
player.printError("Please report this error: [See console]");
player.printRaw(e.getClass().getName() + ": " + e.getMessage());
e.printStackTrace();
}
}
}
public static Class<?> inject() {
return PlatformManager.class;
}
}