update version

build.gradle

@@ -14,6 +14,7 @@ repositories {
     mavenLocal()
     mavenCentral()
     maven { url 'https://hub.spigotmc.org/nexus/content/groups/public' }
+    maven { url 'https://dmx-mc-project.gitlab.io/maven-repository/' }
 }
 
 ext {
@@ -24,7 +25,9 @@ ext {
                     'commons-lang:commons-lang',
                     'org.yaml:snakeyaml'
             ]],
-            lombok: 'org.projectlombok:lombok:1.18.12'
+            commons_text: 'org.apache.commons:commons-text:1.9',
+            lombok: 'org.projectlombok:lombok:1.18.12',
+            reflection_object: 'ru.dmitriymx:reflection-object:1.0-BETA'
     ]
 }
 
@@ -42,4 +45,6 @@ dependencies {
     annotationProcessor libs.lombok
 
     compileOnly2 libs.bukkit
+    implementation libs.commons_text
+    implementation libs.reflection_object
 }

gradle.properties

@@ -1,3 +1,3 @@
 projectGroup=ghast
 projectName=ghast-tools
-projectVersion=1.2.1
+projectVersion=1.8

src/main/java/ghast/EffectsHelper.java

@@ -0,0 +1,27 @@
+package ghast;
+
+import lombok.experimental.UtilityClass;
+import org.bukkit.Location;
+import org.bukkit.Particle;
+import org.bukkit.Sound;
+import org.bukkit.SoundCategory;
+import org.bukkit.util.Vector;
+
+@UtilityClass
+@SuppressWarnings("unused")
+public class EffectsHelper {
+
+	public void playSound(Location location, Sound sound, float pitch) {
+		location.getWorld().playSound(location, sound, SoundCategory.MASTER, 1.0f, pitch);
+	}
+
+	public void particle(Location location, Particle particle, double dx, double dy, double dz, double speed, int amount) {
+		location.getWorld().spawnParticle(particle, location, amount, dx, dy, dz, speed);
+	}
+
+	//TODO нужно проверить
+	public void particle(Location location, Particle particle, Vector vector, double speed, int amount) {
+		particle(location, particle, vector.getX(), vector.getY(), vector.getZ(), speed, amount);
+	}
+}
+

src/main/java/ghast/EventContext.java

@@ -0,0 +1,71 @@
+package ghast;
+
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import org.bukkit.Bukkit;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.BooleanSupplier;
+import java.util.function.Consumer;
+
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+@SuppressWarnings("unused")
+public class EventContext implements Listener {
+
+	private static final BooleanSupplier EMPTY_FILTER = () -> true;
+	private static final Consumer<Cancellable> CANCEL_EVENT = event -> event.setCancelled(true);
+
+	private final Map<Class<? extends Event>, Consumer<?>> eventMap = new HashMap<>();
+	private BooleanSupplier filter = EMPTY_FILTER;
+
+	public EventContext filter(BooleanSupplier filter) {
+		this.filter = (filter != null ? filter : EMPTY_FILTER);
+		return this;
+	}
+
+	public <T extends Event> EventContext onEvent(Class<T> eventType, EventPriority eventPriority, Consumer<T> consumer) {
+		if (consumer == null) {
+			eventMap.remove(eventType);
+		} else {
+			eventMap.put(eventType, consumer);
+			bukkitRegisterEvent(eventType, eventPriority);
+		}
+		return this;
+	}
+
+	public <T extends Event> EventContext onEvent(Class<T> eventType, Consumer<T> consumer) {
+		return onEvent(eventType, EventPriority.NORMAL, consumer);
+	}
+
+	public <T extends Event & Cancellable> EventContext cancelEvent(Class<T> eventType, EventPriority eventPriority) {
+		eventMap.put(eventType, CANCEL_EVENT);
+		bukkitRegisterEvent(eventType, eventPriority);
+		return this;
+	}
+
+	public <T extends Event & Cancellable> EventContext cancelEvent(Class<T> eventType) {
+		return cancelEvent(eventType, EventPriority.NORMAL);
+	}
+
+	private void bukkitRegisterEvent(Class<? extends Event> eventType, EventPriority eventPriority) {
+		Bukkit.getPluginManager().registerEvent(eventType, this, eventPriority,
+				this::eventExecute, GhastTools.getPlugin());
+	}
+
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	private void eventExecute(Listener listener, Event event) {
+		Consumer consumer = eventMap.get(event.getClass());
+		if (consumer != null && filter.getAsBoolean()) {
+			consumer.accept(event);
+		}
+	}
+
+	public static EventContext create() {
+		return new EventContext();
+	}
+}

src/main/java/ghast/EventManager.java

@@ -1,66 +0,0 @@
-package ghast;
-
-import lombok.AccessLevel;
-import lombok.Getter;
-import lombok.RequiredArgsConstructor;
-import lombok.Setter;
-import lombok.experimental.UtilityClass;
-import org.bukkit.Bukkit;
-import org.bukkit.event.Event;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.function.BooleanSupplier;
-import java.util.function.Consumer;
-
-@UtilityClass
-@SuppressWarnings("unused")
-public class EventManager {
-
-	public Builder createContext() {
-		return new Builder();
-	}
-
-	@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
-	public static class Builder {
-
-		private static final BooleanSupplier EMPTY_FILTER = () -> true;
-
-		private final EventContext eventContext = new EventContext();
-
-		public Builder filter(BooleanSupplier filter) {
-			eventContext.setFilter(filter != null ? filter : EMPTY_FILTER);
-			return this;
-		}
-
-		public <T extends Event> Builder onEvent(Class<T> eventType, EventPriority eventPriority, Consumer<T> consumer) {
-			eventContext.getEventMap().put(eventType, consumer);
-			Bukkit.getPluginManager().registerEvent(eventType, eventContext, eventPriority,
-					eventContext::eventExecute, GhastTools.getPlugin());
-			return this;
-		}
-
-		public <T extends Event> Builder onEvent(Class<T> eventType, Consumer<T> consumer) {
-			return onEvent(eventType, EventPriority.NORMAL, consumer);
-		}
-	}
-
-	@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
-	@Getter(AccessLevel.PRIVATE)
-	@Setter(AccessLevel.PRIVATE)
-	private static class EventContext implements Listener {
-
-		private final Map<Class<? extends Event>, Consumer<?>> eventMap = new HashMap<>();
-		private BooleanSupplier filter;
-
-		@SuppressWarnings({ "unchecked", "rawtypes" })
-		private void eventExecute(Listener listener, Event event) {
-			Consumer consumer = eventMap.get(event.getClass());
-			if (consumer != null && filter.getAsBoolean()) {
-				consumer.accept(event);
-			}
-		}
-	}
-}

src/main/java/ghast/GhastTools.java

@@ -23,6 +23,20 @@ public class GhastTools {
 		}
 	}
 
+	@SuppressWarnings("java:S112")
+	public Plugin getPlugin() {
+		if (refPlugin == null) {
+			throw new RuntimeException("Plugin not set.");
+		}
+
+		Plugin plugin = refPlugin.get();
+		if (plugin == null) {
+			throw new RuntimeException("Plugin not set.");
+		}
+
+		return plugin;
+	}
+
 	@SuppressWarnings("java:S112")
 	public YamlConfiguration loadConfig(boolean saveDefault) {
 		if (saveDefault) {
@@ -39,18 +53,4 @@ public class GhastTools {
 	public YamlConfiguration loadConfig() {
 		return loadConfig(true);
 	}
-
-	@SuppressWarnings("java:S112")
-	Plugin getPlugin() {
-		if (refPlugin == null) {
-			throw new RuntimeException("Plugin not set.");
-		}
-
-		Plugin plugin = refPlugin.get();
-		if (plugin == null) {
-			throw new RuntimeException("Plugin not set.");
-		}
-
-		return plugin;
-	}
 }

src/main/java/ghast/I18n.java

@@ -0,0 +1,91 @@
+package ghast;
+
+import com.google.common.collect.HashBasedTable;
+import com.google.common.collect.Table;
+import lombok.AccessLevel;
+import lombok.NoArgsConstructor;
+import lombok.experimental.UtilityClass;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.text.StringSubstitutor;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.util.HashMap;
+import java.util.Map;
+
+@UtilityClass
+@SuppressWarnings("unused")
+public class I18n {
+
+	private final String DEFAULT_LANG = "en";
+	private final Table<String/*Lang*/, String/*Key*/, String/*Template|Message*/> messagesMap = HashBasedTable.create();
+
+	//region Load messages
+	@SuppressWarnings("java:S112")
+	public void loadMessages(String lang, Reader reader) {
+		Map<String, String> map = messagesMap.row(lang.toLowerCase());
+
+		try {
+			BufferedReader bufferedReader = new BufferedReader(reader);
+			String line;
+			while ((line = bufferedReader.readLine()) != null) {
+				String[] split = line.split("=", 2);
+				map.put(split[0].trim().toLowerCase(), split[1].trim());
+			}
+		} catch (IOException e) {
+			throw new RuntimeException("Error load messages: " + e.getMessage(), e);
+		}
+	}
+
+	public void loadMessages(String lang, Map<String, String> messages) {
+		Map<String, String> map = messagesMap.row(lang.toLowerCase());
+		messages.forEach((k, v) -> map.put(k.toLowerCase(), v));
+	}
+
+	public void loadMessages(Reader reader) {
+		loadMessages(DEFAULT_LANG, reader);
+	}
+
+	public void loadMessages(Map<String, String> messages) {
+		loadMessages(DEFAULT_LANG, messages);
+	}
+	//endregion
+
+	//region Get message
+	public String get(String lang, String key) {
+		return messagesMap.row(lang.toLowerCase()).getOrDefault(key.toLowerCase(), StringUtils.EMPTY);
+	}
+
+	public String get(String lang, String key, Map<String, Object> params) {
+		return StringSubstitutor.replace(get(lang, key.toLowerCase()), params, "{", "}");
+	}
+
+	public String get(String key) {
+		return get(DEFAULT_LANG, key);
+	}
+
+	public String get(String key, Map<String, Object> params) {
+		return get(DEFAULT_LANG, key, params);
+	}
+	//endregion
+
+	public ParamBuilder paramBuilder() {
+		return new ParamBuilder();
+	}
+
+	@NoArgsConstructor(access = AccessLevel.PRIVATE)
+	public static class ParamBuilder {
+
+		private final Map<String, Object> params = new HashMap<>();
+
+		public ParamBuilder add(String key, Object value) {
+			params.put(key, value);
+			return this;
+		}
+
+		public Map<String, Object> build() {
+			return params;
+		}
+	}
+}

src/main/java/ghast/XLog.java

@@ -0,0 +1,77 @@
+package ghast;
+
+import lombok.experimental.UtilityClass;
+
+import java.util.logging.Level;
+
+import static java.text.MessageFormat.format;
+
+@UtilityClass
+@SuppressWarnings("unused")
+public class XLog {
+
+	//region Debug
+	public void debug(String pattern, Object... objects) {
+		if (objects.length > 1 && objects[objects.length - 1] instanceof Throwable) {
+			Throwable throwable = (Throwable) objects[objects.length - 1];
+			Object[] values = new Object[objects.length - 1];
+			System.arraycopy(objects, 0, values, 0, values.length);
+
+			debug(format(pattern, values), throwable);
+		} else {
+			debug(format(pattern, objects));
+		}
+	}
+
+	public void debug(String message, Throwable throwable) {
+		GhastTools.getPlugin().getLogger().log(Level.FINE, message, throwable);
+	}
+
+	public void debug(String message) {
+		GhastTools.getPlugin().getLogger().fine(message);
+	}
+	//endregion
+
+	//region Info
+	public void info(String pattern, Object... objects) {
+		info(format(pattern, objects));
+	}
+
+	public void info(String message) {
+		GhastTools.getPlugin().getLogger().info(message);
+	}
+	//endregion
+
+	//region Warning
+	public void warn(String pattern, Object... objects) {
+		warn(format(pattern, objects));
+	}
+
+	public void warn(String message) {
+		GhastTools.getPlugin().getLogger().warning(message);
+	}
+	//endregion
+
+	//region Error
+	public void error(String pattern, Object... objects) {
+		if (objects.length > 1 && objects[objects.length - 1] instanceof Throwable) {
+			Throwable throwable = (Throwable) objects[objects.length - 1];
+			Object[] values = new Object[objects.length - 1];
+			System.arraycopy(objects, 0, values, 0, values.length);
+
+			error(format(pattern, values), throwable);
+		} else {
+			error(format(pattern, objects));
+		}
+	}
+
+	public void error(String message) {
+		GhastTools.getPlugin().getLogger().severe(message);
+	}
+
+	public void error(String message, Throwable throwable) {
+		GhastTools.getPlugin().getLogger().log(Level.SEVERE, message, throwable);
+	}
+	//endregion
+
+}

src/main/java/ghast/command/CommandExecuter.java

@@ -0,0 +1,8 @@
+package ghast.command;
+
+import org.bukkit.command.CommandSender;
+
+public interface CommandExecuter {
+
+	void execute(CommandSender sender, String[] args);
+}

src/main/java/ghast/command/CommandManager.java

@@ -0,0 +1,71 @@
+package ghast.command;
+
+import lombok.AccessLevel;
+import lombok.RequiredArgsConstructor;
+import lombok.experimental.UtilityClass;
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import ru.dmitriymx.reflection.ReflectionObject;
+
+@UtilityClass
+@SuppressWarnings("unused")
+public class CommandManager {
+
+	public Builder create(String name) {
+		return new Builder(name);
+	}
+
+	public void register(String name, CommandExecuter executer) {
+		create(name).executer(executer).register();
+	}
+
+	@RequiredArgsConstructor(access = AccessLevel.PRIVATE)
+	public static class Builder {
+
+		private final String name;
+		private CommandExecuter executer;
+		private ErrorConsumer errorConsumer;
+		private Boolean onlyPlayer;
+		private String deniedMessage;
+
+		public Builder executer(CommandExecuter executer) {
+			this.executer = executer;
+			return this;
+		}
+
+		public Builder onError(ErrorConsumer errorConsumer) {
+			this.errorConsumer = errorConsumer;
+			return this;
+		}
+
+		public Builder useOnlyPlayer(String deniedMessage) {
+			this.onlyPlayer = true;
+			this.deniedMessage = deniedMessage;
+			return this;
+		}
+
+		public Builder useOnlyPlayer() {
+			return useOnlyPlayer(null);
+		}
+
+		public Builder useOnlyConsole(String deniedMessage) {
+			this.onlyPlayer = false;
+			this.deniedMessage = deniedMessage;
+			return this;
+		}
+
+		public Builder useOnlyConsole() {
+			return useOnlyConsole(null);
+		}
+
+		public void register() {
+			//TODO для Paper такие "извращения" не требуются. Нужно продумать.
+			new ReflectionObject(Bukkit.getServer())
+					.method("getCommandMap").invoke()
+					.method("register", String.class, Command.class).invoke(
+						name, new CommandWrapper(name, this.onlyPlayer, this.deniedMessage,
+							this.executer, this.errorConsumer)
+					);
+		}
+	}
+}

src/main/java/ghast/command/CommandWrapper.java

@@ -0,0 +1,71 @@
+package ghast.command;
+
+import ghast.XLog;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.defaults.BukkitCommand;
+import org.bukkit.entity.Player;
+
+class CommandWrapper extends BukkitCommand {
+
+	private static final String DEFAULT_DENIED_MESSAGE_PLAYERS = ChatColor.RED + "This command use only players";
+	private static final String DEFAULT_DENIED_MESSAGE_CONSOLE = ChatColor.RED + "This command use only in console";
+
+	private static final ErrorConsumer DEFAULT_ERROR_CONSUMER =
+			(sender, commandName, args, exception) -> {
+				sender.sendMessage(String.format("%sError execute command '%s'!", ChatColor.RED, commandName));
+				XLog.error("Error execute command ''{0}'' with args ''{1}''",
+						commandName, String.join(" ", args), exception);
+			};
+
+	private final CommandExecuter executer;
+	private final ErrorConsumer errorConsumer;
+	private final Boolean onlyPlayer;
+	private String deniedMessage;
+
+	protected CommandWrapper(String name, Boolean onlyPlayer, String deniedMessage,
+			CommandExecuter executer, ErrorConsumer errorConsumer) {
+		super(name);
+		this.onlyPlayer = onlyPlayer;
+		this.executer = executer;
+
+		if (onlyPlayer != null) {
+			if (deniedMessage == null) {
+				this.deniedMessage = Boolean.TRUE.equals(onlyPlayer) ? DEFAULT_DENIED_MESSAGE_PLAYERS
+						: DEFAULT_DENIED_MESSAGE_CONSOLE;
+			} else {
+				this.deniedMessage = deniedMessage;
+			}
+		}
+
+		if(errorConsumer == null) {
+			this.errorConsumer = DEFAULT_ERROR_CONSUMER;
+		} else {
+			this.errorConsumer = errorConsumer;
+		}
+	}
+
+	@Override
+	@SuppressWarnings("java:S1066")
+	public boolean execute(CommandSender commandSender, String commandName, String[] args) {
+		if (Boolean.TRUE.equals(onlyPlayer)) {
+			if (!(commandSender instanceof Player)) {
+				commandSender.sendMessage(deniedMessage);
+				return true;
+			}
+		} else if (Boolean.FALSE.equals(onlyPlayer)) { // use console only
+			if (commandSender instanceof Player) {
+				commandSender.sendMessage(deniedMessage);
+				return true;
+			}
+		}
+
+		try {
+			executer.execute(commandSender, args);
+			return true;
+		} catch (Exception e) {
+			errorConsumer.accept(commandSender, commandName, args, e);
+			return false;
+		}
+	}
+}

src/main/java/ghast/command/ErrorConsumer.java

@@ -0,0 +1,8 @@
+package ghast.command;
+
+import org.bukkit.command.CommandSender;
+
+public interface ErrorConsumer {
+
+	void accept(CommandSender sender, String commandName, String[] args, Exception exception);
+}

src/main/java/ghast/scheduler/BukkitScheduleTask.java

@@ -0,0 +1,20 @@
+package ghast.scheduler;
+
+import lombok.RequiredArgsConstructor;
+import org.bukkit.scheduler.BukkitTask;
+
+@RequiredArgsConstructor
+public class BukkitScheduleTask implements ScheduleTask {
+
+	private final BukkitTask bukkitTask;
+
+	@Override
+	public boolean isCanceled() {
+		return bukkitTask.isCancelled();
+	}
+
+	@Override
+	public void cancel() {
+		bukkitTask.cancel();
+	}
+}

src/main/java/ghast/scheduler/JavaScheduleTask.java

@@ -0,0 +1,21 @@
+package ghast.scheduler;
+
+import lombok.RequiredArgsConstructor;
+
+import java.util.concurrent.Future;
+
+@RequiredArgsConstructor
+public class JavaScheduleTask implements ScheduleTask {
+
+	private final Future<?> future;
+
+	@Override
+	public boolean isCanceled() {
+		return future.isCancelled();
+	}
+
+	@Override
+	public void cancel() {
+		future.cancel(true);
+	}
+}

src/main/java/ghast/scheduler/ScheduleManager.java

@@ -1,11 +1,13 @@
-package ghast;
+package ghast.scheduler;
 
 import com.google.common.util.concurrent.ThreadFactoryBuilder;
+import ghast.GhastTools;
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import lombok.experimental.UtilityClass;
 import org.bukkit.Bukkit;
 import org.bukkit.scheduler.BukkitScheduler;
+import org.bukkit.scheduler.BukkitTask;
 
 import java.util.concurrent.*;
 
@@ -45,48 +47,65 @@ public class ScheduleManager {
 			return this;
 		}
 
-		public void execute(Runnable runnable) {
+		public ScheduleTask execute(Runnable runnable) {
 			if (useBukkitScheduler) {
-				createBukkitSchedule(runnable);
+				return createBukkitSchedule(runnable);
 			} else {
-				createSchedule(runnable);
+				return createSchedule(runnable);
 			}
 		}
 
-		private void createBukkitSchedule(Runnable runnable) {
+		private ScheduleTask createBukkitSchedule(Runnable runnable) {
 			BukkitScheduler bukkitScheduler = Bukkit.getScheduler();
+			BukkitScheduleTask resultTask;
 
 			if (this.afterMs == null && this.everyMs == null) {
-				bukkitScheduler.runTask(GhastTools.getPlugin(), runnable);
+				BukkitTask bukkitTask = bukkitScheduler.runTask(GhastTools.getPlugin(), runnable);
+				resultTask = new BukkitScheduleTask(bukkitTask);
 			} else if (this.everyMs != null) {
 				long everyTicks = this.everyMs / MS_PER_ONE_TICK;
 				long afterTicks = this.afterMs != null ? this.afterMs / MS_PER_ONE_TICK : 0;
-				bukkitScheduler.runTaskTimer(GhastTools.getPlugin(), runnable, afterTicks, everyTicks);
+				BukkitTask bukkitTask = bukkitScheduler.runTaskTimer(GhastTools.getPlugin(), runnable, afterTicks,
+						everyTicks);
+				resultTask = new BukkitScheduleTask(bukkitTask);
 			} else {
 				long ticks = this.afterMs / MS_PER_ONE_TICK;
-				bukkitScheduler.runTaskLater(GhastTools.getPlugin(), runnable, ticks);
+				BukkitTask bukkitTask = bukkitScheduler.runTaskLater(GhastTools.getPlugin(), runnable, ticks);
+				resultTask = new BukkitScheduleTask(bukkitTask);
 			}
+
+			return resultTask;
 		}
 
-		private void createSchedule(Runnable runnable) {
+		private ScheduleTask createSchedule(Runnable runnable) {
 			ExecutorService executorService;
+			JavaScheduleTask resultTask;
 
 			if (this.afterMs == null && this.everyMs == null) {
 				executorService = Executors.newSingleThreadExecutor(THREAD_FACTORY);
-				executorService.execute(runnable);
+				Future<?> future = executorService.submit(runnable);
+				resultTask = new JavaScheduleTask(future);
 			} else if (this.everyMs != null) {
-				ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1, THREAD_FACTORY);
-				scheduledExecutorService.scheduleAtFixedRate(runnable,
+				ScheduledExecutorService scheduledExecutorService
+						= Executors.newScheduledThreadPool(1, THREAD_FACTORY);
+				ScheduledFuture<?> scheduledFuture = scheduledExecutorService.scheduleAtFixedRate(runnable,
 						this.afterMs != null ? this.afterMs : 0,
 						everyMs, TimeUnit.MILLISECONDS);
+
+				resultTask = new JavaScheduleTask(scheduledFuture);
 				executorService = scheduledExecutorService;
 			} else {
-				ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1, THREAD_FACTORY);
-				scheduledExecutorService.schedule(runnable, afterMs, TimeUnit.MILLISECONDS);
+				ScheduledExecutorService scheduledExecutorService
+						= Executors.newScheduledThreadPool(1, THREAD_FACTORY);
+				ScheduledFuture<?> schedule = scheduledExecutorService
+						.schedule(runnable, afterMs, TimeUnit.MILLISECONDS);
+
+				resultTask = new JavaScheduleTask(schedule);
 				executorService = scheduledExecutorService;
 			}
 
 			executorService.shutdown();
+			return resultTask;
 		}
 	}
 }

src/main/java/ghast/scheduler/ScheduleTask.java

@@ -0,0 +1,8 @@
+package ghast.scheduler;
+
+public interface ScheduleTask {
+
+	boolean isCanceled();
+
+	void cancel();
+}