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.1
+projectVersion=1.7

src/main/java/ghast/AssetsManager.java

@@ -3,13 +3,13 @@ package ghast;
 import lombok.experimental.UtilityClass;
 import org.bukkit.plugin.Plugin;
 
-import java.io.File;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
+import java.io.*;
 import java.net.URL;
+import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.Scanner;
 
 import static java.text.MessageFormat.format;
 
@@ -18,25 +18,10 @@ import static java.text.MessageFormat.format;
 public class AssetsManager {
 
 	private static final String ERROR_NOT_FOUND = "Asset \"{0}\" not found";
+	private static final String ERROR_OPEN = "Error open asset \"{0}\": {1}";
 
-	public void saveTo(String resourceName, Path targetPath) {
-		URL resourceUrl = getResourceUrl(resourceName);
-
-		Path saveToPath;
-		if (Files.isDirectory(targetPath)) {
-			saveToPath = targetPath.resolve(resourceName);
-		} else {
-			saveToPath = targetPath;
-		}
-
-		doSaveTo(resourceUrl, saveToPath);
-	}
-
-	public void saveTo(String resourceName, File targetPath) {
-		saveTo(resourceName, targetPath.toPath());
-	}
-
-	public InputStream loadResource(String resourceName, String defaultResourceName, boolean saveDefault) {
+	//region getAsInputStream methods
+	public InputStream getAsInputStream(String resourceName, String defaultResourceName, boolean saveDefault) {
 		Plugin plugin = GhastTools.getPlugin();
 		InputStream inputStream;
 
@@ -59,18 +44,77 @@ public class AssetsManager {
 		return inputStream;
 	}
 
-	public InputStream loadResource(String resourceName, String defaultResourceName) {
-		return loadResource(resourceName, defaultResourceName, true);
+	public InputStream getAsInputStream(String resourceName, String defaultResourceName) {
+		return getAsInputStream(resourceName, defaultResourceName, true);
 	}
 
-	public InputStream loadResource(String resourceName, boolean saveDefault) {
-		return loadResource(resourceName, resourceName, saveDefault);
+	public InputStream getAsInputStream(String resourceName, boolean saveDefault) {
+		return getAsInputStream(resourceName, resourceName, saveDefault);
 	}
 
-	public InputStream loadResource(String resourceName) {
-		return loadResource(resourceName, resourceName, true);
+	public InputStream getAsInputStream(String resourceName) {
+		return getAsInputStream(resourceName, resourceName, true);
+	}
+	//endregion
+
+	//region getAsReader methods
+	public Reader getAsReader(String resourceName, String defaultResourceName, boolean saveDefault) {
+		return new InputStreamReader(getAsInputStream(resourceName, defaultResourceName, saveDefault));
 	}
 
+	public Reader getAsReader(String resourceName, String defaultResourceName) {
+		return new InputStreamReader(getAsInputStream(resourceName, defaultResourceName, true));
+	}
+
+	public Reader getAsReader(String resourceName, boolean saveDefault) {
+		return new InputStreamReader(getAsInputStream(resourceName, resourceName, saveDefault));
+	}
+
+	public Reader getAsReader(String resourceName) {
+		return new InputStreamReader(getAsInputStream(resourceName, resourceName, true));
+	}
+	//endregion
+
+	//region getAsString methods
+	public String getAsString(String resourceName, String defaultResourceName, Charset charset, boolean saveDefault) {
+		try (InputStream inputStream = getAsInputStream(resourceName, defaultResourceName, saveDefault);
+			 Scanner scanner = new Scanner(inputStream, charset.name()).useDelimiter("\\A")) {
+
+			return scanner.next();
+		} catch (IOException e) {
+			throw new AssetsException(format(ERROR_OPEN, resourceName, e.getMessage()), e);
+		}
+	}
+
+	public String getAsString(String resourceName, String defaultResourceName, Charset charset) {
+		return getAsString(resourceName, defaultResourceName, charset, true);
+	}
+
+	public String getAsString(String resourceName, String defaultResourceName, boolean saveDefault) {
+		return getAsString(resourceName, defaultResourceName, StandardCharsets.UTF_8, saveDefault);
+	}
+
+	public String getAsString(String resourceName, String defaultResourceName) {
+		return getAsString(resourceName, defaultResourceName, StandardCharsets.UTF_8, true);
+	}
+
+	public String getAsString(String resourceName, Charset charset, boolean saveDefault) {
+		return getAsString(resourceName, resourceName, charset, saveDefault);
+	}
+
+	public String getAsString(String resourceName, Charset charset) {
+		return getAsString(resourceName, resourceName, charset, true);
+	}
+
+	public String getAsString(String resourceName, boolean saveDefault) {
+		return getAsString(resourceName, resourceName, StandardCharsets.UTF_8, saveDefault);
+	}
+
+	public String getAsString(String resourceName) {
+		return getAsString(resourceName, resourceName, StandardCharsets.UTF_8, true);
+	}
+	//endregion
+	
 	private URL getResourceUrl(String resourceName) {
 		URL resourceUrl = AssetsManager.class.getClassLoader().getResource(resourceName);
 		if (resourceUrl == null) {
@@ -81,13 +125,18 @@ public class AssetsManager {
 	}
 
 	private void doSaveTo(URL resourceUrl, Path saveToPath) {
-		try (InputStream inputStream = resourceUrl.openStream();
-			 OutputStream outputStream = Files.newOutputStream(saveToPath)) {
+		try {
+			Files.createDirectories(saveToPath.getParent());
 
-			byte[] buffer = new byte[8192];
-			int count;
-			while ((count = inputStream.read(buffer)) != -1) {
-				outputStream.write(buffer, 0, count);
+			try (InputStream inputStream = resourceUrl.openStream();
+				 OutputStream outputStream = Files.newOutputStream(saveToPath)) {
+
+				byte[] buffer = new byte[8192];
+				int count;
+				while ((count = inputStream.read(buffer)) != -1) {
+					outputStream.write(buffer, 0, count);
+				}
+				outputStream.flush();
 			}
 		} catch (IOException e) {
 			throw new AssetsException(format("Error save asset \"{0}\" to \"{1}\": {2}",
@@ -99,7 +148,7 @@ public class AssetsManager {
 		try {
 			return Files.newInputStream(pathToResource);
 		} catch (IOException e) {
-			throw new AssetsException(format("Error open asset \"{0}\": {1}", pathToResource, e.getMessage()), e);
+			throw new AssetsException(format(ERROR_OPEN, pathToResource, e.getMessage()), e);
 		}
 	}
 
@@ -107,7 +156,7 @@ public class AssetsManager {
 		try {
 			return resourceUrl.openStream();
 		} catch (IOException e) {
-			throw new AssetsException(format("Error open asset \"{0}\": {1}", resourceUrl, e.getMessage()), e);
+			throw new AssetsException(format(ERROR_OPEN, resourceUrl, e.getMessage()), e);
 		}
 	}
 }

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

@@ -5,8 +5,7 @@ import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.plugin.Plugin;
 
 import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
+import java.io.Reader;
 import java.lang.ref.WeakReference;
 
 @UtilityClass
@@ -25,24 +24,7 @@ public class GhastTools {
 	}
 
 	@SuppressWarnings("java:S112")
-	public YamlConfiguration loadConfig(boolean saveDefault) {
-		if (saveDefault) {
-			getPlugin().saveDefaultConfig();
-		}
-
-		try (InputStream inputStream = AssetsManager.loadResource("config.yml", saveDefault)) {
-			return YamlConfiguration.loadConfiguration(new InputStreamReader(inputStream));
-		} catch (IOException e) {
-			throw new RuntimeException("Error load config: " + e.getMessage(), e);
-		}
-	}
-
-	public YamlConfiguration loadConfig() {
-		return loadConfig(true);
-	}
-
-	@SuppressWarnings("java:S112")
-	Plugin getPlugin() {
+	public Plugin getPlugin() {
 		if (refPlugin == null) {
 			throw new RuntimeException("Plugin not set.");
 		}
@@ -54,4 +36,21 @@ public class GhastTools {
 
 		return plugin;
 	}
+
+	@SuppressWarnings("java:S112")
+	public YamlConfiguration loadConfig(boolean saveDefault) {
+		if (saveDefault) {
+			getPlugin().saveDefaultConfig();
+		}
+
+		try (Reader reader = AssetsManager.getAsReader("config.yml", saveDefault)) {
+			return YamlConfiguration.loadConfiguration(reader);
+		} catch (IOException e) {
+			throw new RuntimeException("Error load config: " + e.getMessage(), e);
+		}
+	}
+
+	public YamlConfiguration loadConfig() {
+		return loadConfig(true);
+	}
 }

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);
+}