Initial copy from other repository (nothing is fixed here)

CommandFramework/CommandFrameworkBase/build.gradle.kts

@@ -0,0 +1,27 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2024  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+plugins {
+    steamwar.java
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_11
+    targetCompatibility = JavaVersion.VERSION_11
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/AbstractCommand.java

@@ -0,0 +1,216 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2020  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import de.steamwar.command.graph.NodeData;
+import de.steamwar.command.graph.RootNode;
+import de.steamwar.command.utils.Pair;
+import de.steamwar.command.utils.Triple;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.*;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+
+public abstract class AbstractCommand<T> {
+
+    private static final Map<Class<? extends AbstractCommand<?>>, Map<Class<?>, Function<?, ?>>> EXECUTOR_MAPPER = new HashMap<>();
+
+    public static <E, T> void addExecutorMapper(Class<? extends AbstractCommand<E>> wrapper, Class<T> executorType, Function<E, T> mapper) {
+        EXECUTOR_MAPPER.computeIfAbsent(wrapper, __ -> new HashMap<>())
+                .putIfAbsent(executorType, mapper);
+    }
+
+    protected final String command;
+    protected final String permission;
+    private final Consumer<CommandLoader<T>> initializer;
+    protected final String[] aliases;
+    protected final List<String> descriptions = new ArrayList<>();
+
+    private boolean initialized = false;
+    protected final RootNode<T> rootNode = new RootNode<>();
+
+    private final Map<String, AbstractTypeMapper<T, ?>> localTypeMapper = new HashMap<>();
+    private final Map<String, AbstractTypeValidator<T, ?>> localValidators = new HashMap<>();
+    private final Map<String, AbstractTypeSupplier<T, ?>> localSupplier = new HashMap<>();
+
+    protected AbstractCommand(String command, Consumer<CommandLoader<T>> initializer, String... aliases) {
+        this(command, null, initializer, aliases);
+    }
+
+    protected AbstractCommand(String command, String permission, Consumer<CommandLoader<T>> initializer, String... aliases) {
+        this.command = command;
+        this.permission = permission;
+        this.initializer = initializer;
+        this.aliases = aliases;
+        initCommand();
+        unregister();
+        register();
+    }
+
+    protected synchronized void initCommand() {
+    }
+
+    public abstract void unregister();
+
+    public abstract void register();
+
+    protected void commandSystemError(T sender, CommandFrameworkException e) {
+        Logger.getGlobal().log(Level.WARNING, "An unexpected error occurred", e);
+    }
+
+    protected void sendMessage(T sender, String message, Object[] args) {
+    }
+
+    public final void execute(T sender, String alias, String[] args) {
+        initialize();
+        List<Runnable> errors = new ArrayList<>();
+        try {
+            boolean executed = rootNode.execute(sender, new NodeData(alias, fixArgs(args), (s, args1) -> {
+                errors.add(() -> sendMessage(sender, s, args1));
+            }));
+            if (executed) return;
+            if (!errors.isEmpty()) {
+                errors.forEach(Runnable::run);
+                return;
+            }
+            descriptions.forEach(s -> sendMessage(sender, s, new Object[0]));
+        } catch (CommandFrameworkException e) {
+            commandSystemError(sender, e);
+        }
+    }
+
+    public final List<String> tabComplete(T sender, String alias, String[] args) throws IllegalArgumentException {
+        initialize();
+        List<Collection<String>> tabCompletes = new ArrayList<>();
+        rootNode.tabComplete(sender, new NodeData(alias, fixArgs(args), (s, args1) -> {}), tabCompletes);
+        return tabCompletes.stream()
+                .filter(Objects::nonNull)
+                .flatMap(Collection::stream)
+                .filter(Objects::nonNull)
+                .filter(s -> !s.isEmpty())
+                .distinct()
+                .collect(Collectors.toList());
+    }
+
+    private String[] fixArgs(String[] args) {
+        int removedCount = 0;
+        for (int i = 0; i < args.length; i++) {
+            String arg = args[i];
+            if (arg.isEmpty() && i != args.length - 1) {
+                removedCount++;
+                continue;
+            }
+            args[i] = args[i - removedCount];
+        }
+        if (removedCount != 0) {
+            args = Arrays.copyOf(args, args.length - removedCount);
+        }
+        if (args.length == 0) {
+            return new String[]{""};
+        }
+        return args;
+    }
+
+    private synchronized void initialize() {
+        if (initialized) return;
+
+        List<Object> commandObjects = new ArrayList<>();
+        initializer.accept(new CommandLoader<>() {
+            @Override
+            public AbstractCommand<T> get() {
+                return AbstractCommand.this;
+            }
+
+            @Override
+            public void add(Object command) {
+                commandObjects.add(command);
+            }
+        });
+
+        List<Pair<DataImpl, Method>> methods = new ArrayList<>();
+        for (Object commandObject : commandObjects) {
+            DataImpl dataImpl = new DataImpl(this, commandObject, rootNode, EXECUTOR_MAPPER.getOrDefault(this.getClass(), Collections.emptyMap()), (Map) localTypeMapper, CommandUtils.MAPPER_FUNCTIONS, (Map) localValidators, CommandUtils.VALIDATOR_FUNCTIONS, (Map) localSupplier, CommandUtils.SUPPLIER_FUNCTIONS);
+            methods(commandObject).stream()
+                    .filter(method -> Arrays.stream(method.getAnnotations()).anyMatch(anno -> anno.annotationType().isAnnotationPresent(Handler.Implementation.class)))
+                    .forEach(method -> methods.add(new Pair<>(dataImpl, method)));
+        }
+
+        Map<Integer, Map<Triple<DataImpl, Method, Annotation>, List<Handler.HandlerMethod<Annotation>>>> handlerMap = new HashMap<>();
+        for (Pair<DataImpl, Method> commandMethod : methods) {
+            List<Annotation> annotations = CommandUtils.getAnnotations(commandMethod.b);
+            for (Annotation annotation : annotations) {
+                Handler.Implementation handler = annotation.annotationType().getAnnotation(Handler.Implementation.class);
+                Handler handlerObject;
+                try {
+                    handlerObject = handler.value().getConstructor().newInstance();
+                } catch (NoSuchMethodException | InstantiationException | IllegalAccessException |
+                         InvocationTargetException e) {
+                    throw new UnsupportedOperationException("Handler " + handler.value().getName() + " cannot be used to check the argument validity", e);
+                }
+                if (!(handlerObject instanceof Handler.HandlerMethod)) {
+                    throw new UnsupportedOperationException("Handler " + handlerObject.getClass().getName() + " is not a HandlerMethod");
+                }
+                handlerMap.computeIfAbsent(((Handler.HandlerMethod<?>) handlerObject).getRunPriority(), k -> new LinkedHashMap<>())
+                        .computeIfAbsent(new Triple<>(commandMethod.a, commandMethod.b, annotation), k -> new ArrayList<>())
+                        .add((Handler.HandlerMethod<Annotation>) handlerObject);
+            }
+        }
+
+        List<Integer> runPriorities = new ArrayList<>(handlerMap.keySet());
+        runPriorities.sort(Comparator.naturalOrder());
+        for (int runPriority : runPriorities) {
+            handlerMap.get(runPriority).forEach((dataMethodAnnotationTriple, handlerMethods) -> {
+                handlerMethods.forEach(annotationHandlerMethod -> {
+                    try {
+                        annotationHandlerMethod.check(dataMethodAnnotationTriple.c, dataMethodAnnotationTriple.b, dataMethodAnnotationTriple.a);
+                    } catch (Exception e) {
+                        throw new UnsupportedOperationException("Method check failed for " + dataMethodAnnotationTriple.b.getName(), e);
+                    }
+                    annotationHandlerMethod.run(dataMethodAnnotationTriple.c, dataMethodAnnotationTriple.b, dataMethodAnnotationTriple.a);
+                });
+            });
+        }
+        rootNode.sort();
+        initialized = true;
+    }
+
+    // TODO: Implement this when Message System is ready
+    /*
+    public void addDefaultHelpMessage(String message) {
+        defaultHelpMessages.add(message);
+    }
+     */
+
+    private List<Method> methods(Object commandObject) {
+        List<Method> methods = new ArrayList<>();
+        Class<?> current = commandObject.getClass();
+        while (current != null) {
+            methods.addAll(Arrays.asList(current.getDeclaredMethods()));
+            current = current.getSuperclass();
+        }
+        return methods;
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/AbstractTypeMapper.java

@@ -0,0 +1,48 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2020  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import java.util.Collection;
+
+public interface AbstractTypeMapper<K, T> {
+
+    /**
+     * The CommandSender can be null!
+     */
+    T map(K sender, PreviousArguments previousArguments, String s);
+
+    Collection<String> tabComplete(K sender, PreviousArguments previousArguments, String s);
+
+    /**
+     * @return true if the next element should be appended to the current tab complete.
+     */
+    default boolean appendNextElementTabCompletions() {
+        return false;
+    }
+
+    /**
+     * Normalize the cache key by sender and user provided argument. <br>
+     * Note: The CommandSender can be null if the cache is defined as a global cache!<br>
+     * Returning null and the empty string are equivalent.
+     */
+    default String normalize(K sender, String s) {
+        return null;
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/AbstractTypeSupplier.java

@@ -1,7 +1,7 @@
 /*
  *   This file is a part of the SteamWar software.
  *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Affero General Public License as published by
@@ -19,8 +19,7 @@
 
 package de.steamwar.command;
 
-public class CommandParseException extends RuntimeException {
+public interface AbstractTypeSupplier<K, T> {
 
-    public CommandParseException() {
-    }
+    T get(K sender, PreviousArguments previousArguments);
 }

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/AbstractTypeValidator.java

@@ -0,0 +1,62 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2022  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import java.util.function.BooleanSupplier;
+
+@FunctionalInterface
+public interface AbstractTypeValidator<K, T> {
+
+    /**
+     * Validates the given value.
+     *
+     * @param sender The sender of the command.
+     * @param value The value to validate or null if mapping returned null.
+     * @param messageSender The message sender to send messages to the player. Never send messages directly to the player.
+     * @return The result of the validation.
+     */
+    boolean validate(K sender, T value, MessageSender messageSender);
+
+    default AbstractTypeValidator<K, T> and(AbstractTypeValidator<K, T> other) {
+        return (sender, value, messageSender) -> validate(sender, value, messageSender) && other.validate(sender, value, messageSender);
+    }
+
+    default AbstractTypeValidator<K, T> or(AbstractTypeValidator<K, T> other) {
+        return (sender, value, messageSender) -> validate(sender, value, messageSender) || other.validate(sender, value, messageSender);
+    }
+
+    default AbstractTypeValidator<K, T> not() {
+        return (sender, value, messageSender) -> !validate(sender, value, messageSender);
+    }
+
+    @FunctionalInterface
+    interface MessageSender {
+        void send(String s, Object... args);
+
+        default boolean send(boolean condition, String s, Object... args) {
+            if (condition) send(s, args);
+            return condition;
+        }
+
+        default boolean send(BooleanSupplier condition, String s, Object... args) {
+            return send(condition.getAsBoolean(), s, args);
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/CommandFrameworkException.java

@@ -1,27 +1,26 @@
 /*
- *   This file is a part of the SteamWar software.
+ * This file is a part of the SteamWar software.
  *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
+ * Copyright (C) 2020  SteamWar.de-Serverteam
  *
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU Affero 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 free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ * 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 Affero General Public License for more details.
  *
- *   You should have received a copy of the GNU Affero General Public License
- *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
 package de.steamwar.command;
 
 import java.io.PrintStream;
 import java.io.PrintWriter;
-import java.lang.reflect.Executable;
 import java.lang.reflect.InvocationTargetException;
 import java.util.Arrays;
 import java.util.function.Function;
@@ -36,23 +35,7 @@ public class CommandFrameworkException extends RuntimeException {
 
     private String message;
 
-    static CommandFrameworkException commandPartExceptions(String type, Throwable cause, String current, Class<?> clazzType, Executable executable, int index) {
-        return new CommandFrameworkException(e -> {
-            return CommandFrameworkException.class.getTypeName() + ": Error while " + type + " (" + current + ") to type " + clazzType.getTypeName() + " with parameter index " + index;
-        }, cause, exception -> {
-            StackTraceElement[] stackTraceElements = exception.getStackTrace();
-            int last = 0;
-            for (int i = 0; i < stackTraceElements.length; i++) {
-                if (stackTraceElements[i].getClassName().equals(CommandPart.class.getTypeName())) {
-                    last = i;
-                    break;
-                }
-            }
-            return Arrays.stream(stackTraceElements).limit(last - 1);
-        }, executable.getDeclaringClass().getTypeName() + "." + executable.getName() + "(Unknown Source)");
-    }
-
-    CommandFrameworkException(InvocationTargetException invocationTargetException, String alias, String[] args) {
+    public CommandFrameworkException(InvocationTargetException invocationTargetException, String alias, String[] args) {
         this(e -> {
             StringBuilder st = new StringBuilder();
             st.append(e.getCause().getClass().getTypeName());

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/CommandLoader.java

@@ -1,7 +1,7 @@
 /*
  *   This file is a part of the SteamWar software.
  *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Affero General Public License as published by
@@ -17,9 +17,10 @@
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package de.steamwar.command.dto;
+package de.steamwar.command;
 
-import de.steamwar.command.AbstractValidator;
+public interface CommandLoader<T> {
 
-public interface TestValidator<T> extends AbstractValidator<String, T> {
+    AbstractCommand<T> get();
+    void add(Object command);
 }

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/CommandUtils.java

@@ -0,0 +1,148 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2020  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import de.steamwar.command.mapper.BooleanMapper;
+import de.steamwar.command.mapper.NumberMapper;
+import lombok.experimental.UtilityClass;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Repeatable;
+import java.lang.reflect.AnnotatedElement;
+import java.lang.reflect.Method;
+import java.util.*;
+import java.util.function.ToIntFunction;
+
+@UtilityClass
+public class CommandUtils {
+
+    final Map<String, AbstractTypeMapper<?, ?>> MAPPER_FUNCTIONS = new HashMap<>();
+
+    final Map<String, AbstractTypeValidator<?, ?>> VALIDATOR_FUNCTIONS = new HashMap<>();
+
+    final Map<String, AbstractTypeSupplier<?, ?>> SUPPLIER_FUNCTIONS = new HashMap<>();
+
+    static final AbstractTypeMapper<Object, String> STRING_MAPPER = new AbstractTypeMapper<>() {
+        @Override
+        public String map(Object sender, PreviousArguments previousArguments, String s) {
+            return s;
+        }
+
+        @Override
+        public Collection<String> tabComplete(Object sender, PreviousArguments previousArguments, String s) {
+            return Collections.singletonList(s);
+        }
+    };
+
+    static {
+        addMapper(boolean.class, Boolean.class, new BooleanMapper());
+        addMapper(int.class, Integer.class, new NumberMapper(Integer::parseInt, false));
+        addMapper(long.class, Long.class, new NumberMapper(Long::parseLong, false));
+        addMapper(float.class, Float.class, new NumberMapper(Float::parseFloat, true));
+        addMapper(double.class, Double.class, new NumberMapper(Double::parseDouble, true));
+        MAPPER_FUNCTIONS.put(String.class.getTypeName(), STRING_MAPPER);
+    }
+
+    private static void addMapper(Class<?> clazz, Class<?> alternativeClazz, AbstractTypeMapper<?, ?> mapper) {
+        MAPPER_FUNCTIONS.put(clazz.getTypeName(), mapper);
+        MAPPER_FUNCTIONS.put(alternativeClazz.getTypeName(), mapper);
+    }
+
+    public static <K, T> void addMapper(Class<T> clazz, AbstractTypeMapper<K, T> mapper) {
+        addMapper(clazz.getTypeName(), mapper);
+    }
+
+    public static <T> void addMapper(String name, AbstractTypeMapper<T, ?> mapper) {
+        MAPPER_FUNCTIONS.putIfAbsent(name, mapper);
+    }
+
+    public static <T> void addValidator(Class<T> clazz, AbstractTypeValidator<T, ?> validator) {
+        addValidator(clazz.getTypeName(), validator);
+    }
+
+    public static <T> void addValidator(String name, AbstractTypeValidator<T, ?> validator) {
+        VALIDATOR_FUNCTIONS.putIfAbsent(name, validator);
+    }
+
+    public static <T> void addSupplier(Class<T> clazz, AbstractTypeSupplier<T, ?> supplier) {
+        addSupplier(clazz.getTypeName(), supplier);
+    }
+
+    public static <T> void addSupplier(String name, AbstractTypeSupplier<T, ?> supplier) {
+        SUPPLIER_FUNCTIONS.putIfAbsent(name, supplier);
+    }
+
+    public static List<Annotation> getAnnotations(AnnotatedElement annotatedElement) {
+        List<Annotation> annotationList = new ArrayList<>();
+        for (Annotation annotation : annotatedElement.getAnnotations()) {
+            try {
+                Method method = annotation.annotationType().getMethod("value");
+                Class<?> returnType = method.getReturnType();
+                if (!returnType.isArray()) {
+                    annotationList.add(annotation);
+                    continue;
+                }
+                Class<?> innerReturnType = returnType.getComponentType();
+                if (!(innerReturnType.isAnnotation() && innerReturnType.isAnnotationPresent(Repeatable.class))) {
+                    annotationList.add(annotation);
+                    continue;
+                }
+                Repeatable repeatable = innerReturnType.getAnnotation(Repeatable.class);
+                Class<? extends Annotation> containerType = repeatable.value();
+                if (containerType == returnType) {
+                    throw new UnsupportedOperationException("Repeatable annotation must have a container annotation");
+                }
+                try {
+                    Annotation[] innerAnnotations = (Annotation[]) method.invoke(annotation);
+                    Collections.addAll(annotationList, innerAnnotations);
+                } catch (Exception e) {
+                    annotationList.add(annotation);
+                }
+            } catch (NoSuchMethodException e) {
+                annotationList.add(annotation);
+            }
+        }
+        annotationList.removeIf(anno -> !anno.annotationType().isAnnotationPresent(Handler.Implementation.class));
+        return annotationList;
+    }
+
+    public static <T extends Handler> List<Annotation> getAnnotations(AnnotatedElement annotatedElement, Class<T> type) {
+        List<Annotation> annotations = getAnnotations(annotatedElement);
+        annotations.removeIf(annotation -> {
+            Handler.Implementation implementation = annotation.annotationType().getAnnotation(Handler.Implementation.class);
+            return implementation == null || !type.isAssignableFrom(implementation.value());
+        });
+        return annotations;
+    }
+
+    public static ToIntFunction<Number> createComparator(String type, Class<?> clazz, int iValue, long lValue, float fValue, double dValue) {
+        if (clazz == int.class || clazz == Integer.class) {
+            return number -> Integer.compare(number.intValue(), iValue);
+        } else if (clazz == long.class || clazz == Long.class) {
+            return number -> Long.compare(number.longValue(), lValue);
+        } else if (clazz == float.class || clazz == Float.class) {
+            return number -> Float.compare(number.floatValue(), fValue);
+        } else if (clazz == double.class || clazz == Double.class) {
+            return number -> Double.compare(number.doubleValue(), dValue);
+        } else {
+            throw new IllegalArgumentException(type + " annotation is not supported for " + clazz);
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/DataImpl.java

@@ -0,0 +1,186 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import de.steamwar.command.annotations.Supplier;
+import de.steamwar.command.graph.*;
+import de.steamwar.command.handler.GreedyHandler;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Function;
+
+class DataImpl implements Handler.DataCheckable, Handler.DataReadable, Handler.DataWritable {
+
+    private final AbstractCommand<?> container;
+    private final Object self;
+    private final RootNode<?> node;
+    private final Map<Class<?>, Function<?, ?>> executorMapper;
+    private final Map<String, AbstractTypeMapper<?, ?>> mapper;
+    private final Map<String, AbstractTypeMapper<?, ?>> globalMapper;
+    private final Map<String, AbstractTypeValidator<?, ?>> validator;
+    private final Map<String, AbstractTypeValidator<?, ?>> globalValidator;
+    private final Map<String, AbstractTypeSupplier<?, ?>> supplier;
+    private final Map<String, AbstractTypeSupplier<?, ?>> globalSupplier;
+
+    private final Map<Method, Object> cache = new HashMap<>();
+
+    DataImpl(AbstractCommand<?> container, Object self, RootNode<?> node, Map<Class<?>, Function<?, ?>> executorMapper, Map<String, AbstractTypeMapper<?, ?>> mapper, Map<String, AbstractTypeMapper<?, ?>> globalMapper, Map<String, AbstractTypeValidator<?, ?>> validator, Map<String, AbstractTypeValidator<?, ?>> globalValidator, Map<String, AbstractTypeSupplier<?, ?>> supplier, Map<String, AbstractTypeSupplier<?, ?>> globalSupplier) {
+        this.container = container;
+        this.self = self;
+        this.node = node;
+        this.executorMapper = executorMapper;
+        this.mapper = mapper;
+        this.globalMapper = globalMapper;
+        this.validator = validator;
+        this.globalValidator = globalValidator;
+        this.supplier = supplier;
+        this.globalSupplier = globalSupplier;
+    }
+
+    @Override
+    public boolean hasExecutorMapper(Class<?> clazz) {
+        return getExecutorMapper(clazz) != null;
+    }
+
+    @Override
+    public Function<?, ?> getExecutorMapper(Class<?> clazz) {
+        for (Map.Entry<Class<?>, Function<?, ?>> entry : executorMapper.entrySet()) {
+            if (entry.getKey().isAssignableFrom(clazz)) {
+                return entry.getValue();
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public boolean hasMapper(String key) {
+        return mapper.containsKey(key) || globalMapper.containsKey(key);
+    }
+
+    @Override
+    public <A, B> AbstractTypeMapper<A, B> getMapper(String key) {
+        return (AbstractTypeMapper<A, B>) mapper.getOrDefault(key, globalMapper.get(key));
+    }
+
+    @Override
+    public <A, B> void addMapper(String key, boolean local, AbstractTypeMapper<A, B> mapper) {
+        if (local) {
+            this.mapper.put(key, mapper);
+        } else {
+            this.globalMapper.putIfAbsent(key, mapper);
+        }
+    }
+
+    @Override
+    public boolean hasValidator(String key) {
+        return validator.containsKey(key) || globalValidator.containsKey(key);
+    }
+
+    @Override
+    public <A, B> AbstractTypeValidator<A, B> getValidator(String key) {
+        return (AbstractTypeValidator<A, B>) validator.getOrDefault(key, globalValidator.get(key));
+    }
+
+    @Override
+    public <A, B> void addValidator(String key, boolean local, AbstractTypeValidator<A, B> validator) {
+        if (local) {
+            this.validator.put(key, validator);
+        } else {
+            this.globalValidator.putIfAbsent(key, validator);
+        }
+    }
+
+    @Override
+    public boolean hasSupplier(String key) {
+        return supplier.containsKey(key) || globalSupplier.containsKey(key);
+    }
+
+    @Override
+    public <A, B> AbstractTypeSupplier<A, B> getSupplier(String key) {
+        return (AbstractTypeSupplier<A, B>) supplier.getOrDefault(key, globalSupplier.get(key));
+    }
+
+    @Override
+    public <A, B> void addSupplier(String key, boolean local, AbstractTypeSupplier<A, B> supplier) {
+        if (local) {
+            this.supplier.put(key, supplier);
+        } else {
+            this.globalSupplier.putIfAbsent(key, supplier);
+        }
+    }
+
+    /**
+     * Invoking the same method twice will result in the exact same result.
+     */
+    @Override
+    public <T> T invoke(Method method) {
+        return (T) cache.computeIfAbsent(method, m -> {
+            try {
+                return m.invoke(self);
+            } catch (IllegalAccessException | InvocationTargetException e) {
+                return null;
+            } catch (Exception e) {
+                throw new RuntimeException(e);
+            }
+        });
+    }
+
+    @Override
+    public void addCommand(Method method, String[] subCommand, String[] description, boolean noTabComplete) {
+        Node<?> temp = node;
+        container.descriptions.addAll(Arrays.asList(description));
+        if (noTabComplete) {
+            temp = temp.addChild(null, new NoTabCompleteNode<>());
+        }
+        for (int i = 0; i < subCommand.length; i++) {
+            temp = temp.addChild(null, new LiteralNode<>(subCommand[i]));
+        }
+        Parameter[] parameters = method.getParameters();
+        for (int i = 0; i < parameters.length; i++) {
+            Parameter parameter = parameters[i];
+            if (i == 0) {
+                temp = temp.addChild(parameter, new ExecutorTypeNode<>(parameter, i, this));
+                continue;
+            }
+            if (parameter.isAnnotationPresent(Supplier.class)) {
+                temp = temp.addChild(parameter, new SupplierNode<>(parameter, this));
+                continue;
+            }
+            Class<?> type = parameter.getType();
+            boolean isArray = parameter.isVarArgs() || type.isArray();
+            if (!isArray) {
+                temp = temp.addChild(parameter, new TypeNode<>(parameter, i, this));
+                continue;
+            }
+            boolean greedy = parameter.isVarArgs() || GreedyHandler.isGreedy(parameter);
+            if (greedy) {
+                temp = temp.addChild(parameter, new GreedyArrayNode<>(parameter, i, this));
+            } else {
+                temp = temp.addChild(parameter, new NonGreedyArrayNode<>(parameter, i, this));
+            }
+        }
+        temp.addChild(null, new ExecuteNode<>(self, method));
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/Handler.java

@@ -0,0 +1,121 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.Optional;
+import java.util.function.Function;
+
+public interface Handler {
+
+    default Optional<Class<?>> getGenericTypeOfReturn(Method method) {
+        Type type;
+        try {
+            type = method.getGenericReturnType();
+        } catch (Exception e) {
+            return Optional.empty();
+        }
+        if (!(type instanceof ParameterizedType)) {
+            return Optional.empty();
+        }
+        ParameterizedType parameterizedType = (ParameterizedType) type;
+        Type[] generics = parameterizedType.getActualTypeArguments();
+        if (generics.length != 1 && generics.length != 2) {
+            return Optional.empty();
+        }
+        Type genericType = generics[generics.length - 1];
+        try {
+            return Optional.of(Class.forName(genericType.getTypeName()));
+        } catch (Exception e) {
+            return Optional.empty();
+        }
+    }
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target(ElementType.ANNOTATION_TYPE)
+    @interface Implementation {
+        Class<? extends Handler> value();
+    }
+
+    interface DataCheckable {
+        boolean hasExecutorMapper(Class<?> clazz);
+        boolean hasMapper(String key);
+        boolean hasValidator(String key);
+        boolean hasSupplier(String key);
+    }
+
+    interface DataReadable {
+        Function<?, ?> getExecutorMapper(Class<?> clazz);
+        <A, B> AbstractTypeMapper<A, B> getMapper(String key);
+        <A, B> AbstractTypeValidator<A, B> getValidator(String key);
+        <A, B> AbstractTypeSupplier<A, B> getSupplier(String key);
+    }
+
+    interface DataWritable {
+        Function<?, ?> getExecutorMapper(Class<?> clazz);
+
+        <A, B> void addMapper(String key, boolean local, AbstractTypeMapper<A, B> mapper);
+        <A, B> void addValidator(String key, boolean local, AbstractTypeValidator<A, B> validator);
+        <A, B> void addSupplier(String key, boolean local, AbstractTypeSupplier<A, B> supplier);
+        /**
+         * Invoking the same method twice will result in the exact same result.
+         */
+        <T> T invoke(Method method);
+        void addCommand(Method method, String[] subCommand, String[] description, boolean noTabComplete);
+    }
+
+    interface HandlerMethod<T extends Annotation> extends Handler {
+        void check(T annotation, Method method, DataCheckable dataCheckable) throws Exception;
+
+        int getRunPriority();
+
+        void run(T annotation, Method method, DataWritable dataWritable);
+    }
+
+    interface HandlerParameter<T extends Annotation, A, B> extends Handler {
+        void check(T annotation, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception;
+
+        default boolean needsParentTypeMapper() {
+            return false;
+        }
+
+        /**
+         * Null values are allowed to be returned.
+         */
+        default AbstractTypeMapper<A, B> getTypeMapper(T annotation, Parameter parameter, int index, DataReadable dataReadable, AbstractTypeMapper<A, B> parentTypeMapper) {
+            return null;
+        }
+
+        default int getValidatorPriority() {
+            return 0;
+        }
+
+        /**
+         * Null values are allowed to be returned.
+         */
+        default AbstractTypeValidator<A, B> getValidator(T annotation, Parameter parameter, int index, DataReadable dataReadable) {
+            return null;
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/OptionEnum.java

@@ -0,0 +1,30 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import java.util.Arrays;
+import java.util.List;
+
+public interface OptionEnum<T extends Enum<T> & OptionEnum<T>> {
+    default List<String> getTabCompletes() {
+        return Arrays.asList("-" + ((T) this).name().toLowerCase());
+    }
+    T[] getRemoved();
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/PreviousArguments.java

@@ -0,0 +1,96 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2022  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import lombok.NonNull;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+
+public class PreviousArguments {
+
+    public final String[] userArgs;
+    public final Object[] mappedArgs;
+    public final boolean hasMoreArguments;
+    private final Function<String, Object> getByNameFunction;
+    private boolean usedOptionalValue = false;
+
+    public PreviousArguments(String[] userArgs, Object[] mappedArgs, boolean hasMoreArguments, Function<String, Object> getByNameFunction) {
+        this.userArgs = userArgs;
+        this.mappedArgs = mappedArgs;
+        this.hasMoreArguments = hasMoreArguments;
+        this.getByNameFunction = getByNameFunction;
+    }
+
+    public boolean hasUsedOptionalValue() {
+        return usedOptionalValue;
+    }
+
+    public void usedOptionalValue() {
+        this.usedOptionalValue = true;
+    }
+
+    public String getUserArg(int index) {
+        return userArgs[userArgs.length - index - 1];
+    }
+
+    public <T> T getMappedArg(int index) {
+        return (T) mappedArgs[mappedArgs.length - index - 1];
+    }
+
+    public <T> Optional<T> getFirst(Class<T> clazz) {
+        for (Object o : mappedArgs) {
+            if (clazz.isInstance(o)) {
+                return Optional.of((T) o);
+            }
+        }
+        return Optional.empty();
+    }
+
+    public <T> List<T> getAll(Class<T> clazz) {
+        List<T> list = new ArrayList<>();
+        for (Object o : mappedArgs) {
+            if (clazz.isInstance(o)) {
+                list.add((T) o);
+            }
+            if (o == null) {
+                continue;
+            }
+            if (o.getClass().isArray()) {
+                Object[] array = (Object[]) o;
+                if (array.length == 0) {
+                    continue;
+                }
+                for (Object o1 : array) {
+                    if (clazz.isInstance(o1)) {
+                        list.add((T) o1);
+                    }
+                }
+            }
+        }
+        return list;
+    }
+
+    public <T> T getByName(@NonNull String name) {
+        return (T) getByNameFunction.apply(name);
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/TabCompletionCache.java

@@ -0,0 +1,109 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2020  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import de.steamwar.command.mapper.internal.DelegatingMapper;
+import lombok.AllArgsConstructor;
+import lombok.EqualsAndHashCode;
+import lombok.experimental.UtilityClass;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
+
+@UtilityClass
+public class TabCompletionCache {
+
+    private final Map<Key, TabCompletions> tabCompletionCache = new ConcurrentHashMap<>();
+
+    Set<AbstractTypeMapper<?, ?>> cached = new HashSet<>();
+    Set<AbstractTypeMapper<?, ?>> global = new HashSet<>();
+    Map<AbstractTypeMapper<?, ?>, Long> cacheDuration = new HashMap<>();
+
+    static {
+        Thread thread = new Thread(() -> {
+            while (true) {
+                Set<Key> toRemove = new HashSet<>();
+                for (Map.Entry<Key, TabCompletions> tabCompletionsEntry : tabCompletionCache.entrySet()) {
+                    if (System.currentTimeMillis() - tabCompletionsEntry.getValue().timestamp > cacheDuration.get(tabCompletionsEntry.getKey().typeMapper)) {
+                        toRemove.add(tabCompletionsEntry.getKey());
+                    }
+                }
+                for (Key key : toRemove) {
+                    tabCompletionCache.remove(key);
+                }
+
+                try {
+                    Thread.sleep(1000);
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                }
+            }
+        });
+        thread.setName("TabCompletionCache Invalidator");
+        thread.setDaemon(true);
+        thread.start();
+    }
+
+    public void add(AbstractTypeMapper<?, ?> typeMapper, boolean global, long cacheDuration, TimeUnit timeUnit) {
+        TabCompletionCache.cached.add(typeMapper);
+        if (global) TabCompletionCache.global.add(typeMapper);
+        TabCompletionCache.cacheDuration.put(typeMapper, timeUnit.toMillis(cacheDuration));
+    }
+
+    public <A, B> AbstractTypeMapper<A, B> cached(AbstractTypeMapper<A, B> dataMapper, AbstractTypeMapper<A, B> toBeCached) {
+        if (!cached.contains(dataMapper)) return toBeCached;
+        boolean global = TabCompletionCache.global.contains(dataMapper);
+        long cacheDuration = TabCompletionCache.cacheDuration.get(dataMapper);
+
+        return new DelegatingMapper<>(toBeCached, null) {
+            @Override
+            public Collection<String> tabComplete(A sender, PreviousArguments previousArguments, String s) {
+                String normalizedArg = dataMapper.normalize(global ? null : sender, s);
+                if (normalizedArg == null) normalizedArg = "";
+                Key key = new Key(global ? null : sender, normalizedArg, dataMapper);
+
+                TabCompletions tabCompletions = tabCompletionCache.computeIfAbsent(key, ignore -> {
+                    return new TabCompletions(System.currentTimeMillis(), toBeCached.tabComplete(sender, previousArguments, s));
+                });
+
+                if (System.currentTimeMillis() - tabCompletions.timestamp > cacheDuration) {
+                    tabCompletions.tabCompletions = toBeCached.tabComplete(sender, previousArguments, s);
+                }
+                tabCompletions.timestamp = System.currentTimeMillis();
+                return tabCompletions.tabCompletions;
+            }
+        };
+    }
+
+    @EqualsAndHashCode
+    @AllArgsConstructor
+    private static class Key {
+        private Object sender;
+        private String arg;
+        private AbstractTypeMapper<?, ?> typeMapper;
+    }
+
+    @AllArgsConstructor
+    private static class TabCompletions {
+        private long timestamp;
+        private Collection<String> tabCompletions;
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/AllowNull.java

@@ -0,0 +1,37 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.AllowNullHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to allow null values passed to the command.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(AllowNullHandler.Impl.class)
+public @interface AllowNull {
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/ArrayLength.java

@@ -0,0 +1,53 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.ArrayLengthHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to define a minimum and maximum length the supplied array can have.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(ArrayLengthHandler.Impl.class)
+public @interface ArrayLength {
+    /**
+     * Inclusive
+     */
+    int min() default 0;
+
+    /**
+     * Inclusive
+     */
+    int max() default Integer.MAX_VALUE;
+
+    /**
+     * Error message if too few Elements got parsed. There are 2 arguments provided to the message.
+     * The first is the number of elements that got parsed as a number and the second one is how many
+     * should have been parsed, so the min number of elements expected.
+     */
+    String error() default "";
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Cached.java

@@ -0,0 +1,52 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.CachedHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * This annotation is used to register a or {@link Mapper}
+ * on registration as being cached. Only TabCompletions are cached for the duration
+ * denoted by {@link #timeUnit()} and {@link #cacheDuration()} using
+ * {@link TimeUnit#toMillis(long)}. If {@link #global()} is {@code true}, the
+ * cache will not be created per player but for everyone. This is useful for
+ * commands that are not player specific.
+ * <br><br>
+ * To calculate the cache key for a {@link AbstractTypeMapper} the
+ * {@link AbstractTypeMapper#normalize(Object, String)} method is called.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD})
+@Handler.Implementation(CachedHandler.Impl.class)
+public @interface Cached {
+    long cacheDuration() default 5;
+
+    TimeUnit timeUnit() default TimeUnit.SECONDS;
+
+    boolean global() default false;
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/ClassMapper.java

@@ -0,0 +1,56 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.ClassMapperHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation for registering a method as a class mapper.
+ * The annotated method will be executed while {@link #initialize()}
+ * is evaluated. The result of this method will be cached under the
+ * name {@link ClassMapper#value()} converted to a {@link String} using
+ * {@link Class#getTypeName()}. {@link AbstractTypeMapper} will be used
+ * as the default mapper if the type this mapper is registered for is
+ * found as a parameter of any command method annotated with {@link Register}.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD})
+@Handler.Implementation(ClassMapperHandler.Impl.class)
+@Deprecated
+@DeprecationInfo("Use @Mapper instead")
+public @interface ClassMapper {
+
+    /**
+     * The type this mapper is registered for.
+     */
+    Class<?> value();
+
+    /**
+     * If {@code true}, the mapper will only be used in the current command class.
+     */
+    boolean local() default true;
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/ClassValidator.java

@@ -0,0 +1,53 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.ClassValidatorHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation for registering a method as a class validator.
+ * The annotated method will be executed while {@link #initialize()}
+ * is evaluated. The result of this method will be cached under the
+ * name {@link ClassValidator#value()} converted to a {@link String} using
+ * {@link Class#getTypeName()}.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD})
+@Handler.Implementation(ClassValidatorHandler.Impl.class)
+@Deprecated
+@DeprecationInfo("Use @Validator instead")
+public @interface ClassValidator {
+
+    /**
+     * The type this validator is registered for.
+     */
+    Class<?> value();
+
+    /**
+     * If {@code true}, the validator will only be used in the current command class.
+     */
+    boolean local() default true;
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/DeprecationInfo.java

@@ -0,0 +1,28 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface DeprecationInfo {
+    String value();
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/EndsWith.java

@@ -0,0 +1,38 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.EndsWithHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(EndsWithHandler.Impl.class)
+public @interface EndsWith {
+
+    String value();
+
+    String error() default "";
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/ErrorMessage.java

@@ -0,0 +1,48 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.ErrorMessageHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to define an error message for a parameter.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(ErrorMessageHandler.Impl.class)
+public @interface ErrorMessage {
+    /**
+     * Error message to be displayed when the parameter is invalid.
+     */
+    String value();
+
+    /**
+     * This is the short form for 'allowEmptyArrays'.
+     */
+    @Deprecated
+    @DeprecationInfo("Use @ArrayLength instead of this flag")
+    boolean allowEAs() default true;
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Greedy.java

@@ -0,0 +1,46 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.GreedyHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation can have a huge performance impact. Both positive and negative.
+ * You can design your command to be more flexible and allow performance improvements if used correctly.
+ * <br><br>
+ * The more restrictive the underlying array type is, the more performance can be gained.
+ * <br><br>
+ * Using this annotation on the varargs parameter of a command will not have any effect, since they are already treated as greedy arrays.
+ * <br><br>
+ * The {@link #backTrackingDepth()} can be used to limit the amount of backtracking that is done. This can be used to improve performance.
+ * For varargs parameters, this value is defaulted to 0, since they are at the end of the parameter list.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(GreedyHandler.Impl.class)
+public @interface Greedy {
+    int backTrackingDepth() default Integer.MAX_VALUE;
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Length.java

@@ -1,7 +1,7 @@
 /*
  *   This file is a part of the SteamWar software.
  *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Affero General Public License as published by
@@ -17,24 +17,30 @@
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package de.steamwar.command;
+package de.steamwar.command.annotations;
 
-import de.steamwar.command.dto.ExecutionIdentifier;
-import de.steamwar.command.dto.TestSWCommand;
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.LengthHandler;
 
-public class SimpleCommand extends TestSWCommand {
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
 
-    public SimpleCommand() {
-        super("simple");
-    }
+/**
+ * This annotation is used to define a minimum and maximum length the supplied string can have.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(LengthHandler.Impl.class)
+public @interface Length {
+    /**
+     * Inclusive
+     */
+    int min() default 0;
 
-    @Register(value = "a", noTabComplete = true)
-    public void test(String s, String... varargs) {
-        throw new ExecutionIdentifier("RunSimple with Varargs");
-    }
-
-    @Register
-    public void simple(String s) {
-        throw new ExecutionIdentifier("RunSimple with noArgs");
-    }
+    /**
+     * Inclusive
+     */
+    int max() default Integer.MAX_VALUE;
 }

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Mapper.java

@@ -0,0 +1,58 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.MapperHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Annotation for registering a method as a mapper. The annotated method will
+ * be executed while {@link #initialize()} is evaluated. The result of this
+ * method will be cached under either {@link Mapper#value()} or {@link Mapper#value()}.
+ * If {@link Mapper#type()} is used any parameter using that type will be using
+ * this {@link AbstractTypeMapper} implicitly. While using this annotation on
+ * a method it can be possible to not supply any type. On a parameter you can
+ * only use this annotation using the {@link Mapper#value()} value.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER, ElementType.METHOD})
+@Handler.Implementation(MapperHandler.Impl.class)
+public @interface Mapper {
+    /**
+     * The name this mapper is registered for.
+     */
+    String value() default "";
+
+    /**
+     * The type this mapper is registered for.
+     */
+    Class<?> type() default void.class;
+
+    /**
+     * If {@code true}, the mapper will only be used in the current command class.
+     */
+    boolean local() default true;
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Max.java

@@ -0,0 +1,70 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.MaxHandler;
+import de.steamwar.command.handler.MaxReferenceHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to define a maximum number value for a parameter.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(MaxHandler.Impl.class)
+public @interface Max {
+    int intValue() default Integer.MAX_VALUE;
+
+    long longValue() default Long.MAX_VALUE;
+
+    float floatValue() default Float.MAX_VALUE;
+
+    double doubleValue() default Double.MAX_VALUE;
+
+    boolean inclusive() default true;
+
+    /**
+     * Error message to be displayed when the argument supplied is bigger than this allows.
+     * Two arguments are supplied to the error message. The first is the number that got parsed
+     * and the second is the max this annotation allows.
+     */
+    String error() default "";
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target({ElementType.PARAMETER})
+    @Handler.Implementation(MaxReferenceHandler.Impl.class)
+    @interface Reference {
+        String value();
+
+        boolean inclusive() default true;
+
+        /**
+         * Error message to be displayed when the argument supplied is smaller than this allows.
+         * Two arguments are supplied to the error message. The first is the number that got parsed
+         * and the second is the min this annotation allows.
+         */
+        String error() default "";
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Min.java

@@ -0,0 +1,70 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.MinHandler;
+import de.steamwar.command.handler.MinReferenceHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to define a minimum number value for a parameter.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(MinHandler.Impl.class)
+public @interface Min {
+    int intValue() default Integer.MIN_VALUE;
+
+    long longValue() default Long.MIN_VALUE;
+
+    float floatValue() default Float.MIN_VALUE;
+
+    double doubleValue() default Double.MIN_VALUE;
+
+    boolean inclusive() default true;
+
+    /**
+     * Error message to be displayed when the argument supplied is smaller than this allows.
+     * Two arguments are supplied to the error message. The first is the number that got parsed
+     * and the second is the min this annotation allows.
+     */
+    String error() default "";
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target({ElementType.PARAMETER})
+    @Handler.Implementation(MinReferenceHandler.Impl.class)
+    @interface Reference {
+        String value();
+
+        boolean inclusive() default true;
+
+        /**
+         * Error message to be displayed when the argument supplied is smaller than this allows.
+         * Two arguments are supplied to the error message. The first is the number that got parsed
+         * and the second is the min this annotation allows.
+         */
+        String error() default "";
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Name.java

@@ -0,0 +1,31 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2024  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+public @interface Name {
+    String value();
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/OptionalValue.java

@@ -0,0 +1,46 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.OptionalValueHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to define a default value for a parameter.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(OptionalValueHandler.Impl.class)
+public @interface OptionalValue {
+    /**
+     * Will pe parsed against the TypeMapper specified by the parameter or annotation.
+     */
+    String value();
+
+    /**
+     * The method name stands for 'onlyUseIfNoneIsGiven'.
+     */
+    boolean onlyUINIG() default false;
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Regex.java

@@ -1,7 +1,7 @@
 /*
  *   This file is a part of the SteamWar software.
  *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Affero General Public License as published by
@@ -17,19 +17,22 @@
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package de.steamwar.command;
+package de.steamwar.command.annotations;
 
-import de.steamwar.command.dto.ExecutionIdentifier;
-import de.steamwar.command.dto.TestSWCommand;
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.RegexHandler;
 
-public class NumberValidatorCommand extends TestSWCommand {
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
 
-    public NumberValidatorCommand() {
-        super("numberValidator");
-    }
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(RegexHandler.Impl.class)
+public @interface Regex {
 
-    @Register
-    public void test(String sender, @Min(intValue = 0) @Max(intValue = 10) int i) {
-        throw new ExecutionIdentifier("RunNumberValidator with int");
-    }
+    String value();
+
+    String error() default "";
 }

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Register.java

@@ -0,0 +1,57 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.RegisterHandler;
+
+import java.lang.annotation.*;
+
+/**
+ * Annotation for registering a method as a command.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD})
+@Repeatable(Register.Registers.class)
+@Handler.Implementation(RegisterHandler.Impl.class)
+public @interface Register {
+
+    /**
+     * Identifier of subcommand.
+     */
+    String[] value() default {};
+
+    /**
+     * Description of subcommand.
+     */
+    String[] description() default {};
+
+    /**
+     * If {@code true}, the command will not be tab completed.
+     */
+    boolean noTabComplete() default false;
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target({ElementType.METHOD})
+    @Handler.Implementation(RegisterHandler.Impl.class)
+    @interface Registers {
+        Register[] value();
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/StartsWith.java

@@ -0,0 +1,38 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.StartsWithHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(StartsWithHandler.Impl.class)
+public @interface StartsWith {
+
+    String value();
+
+    String error() default "";
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/StaticValue.java

@@ -0,0 +1,58 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.StaticValueHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to define static values for a parameter like an enum just without the enum.
+ * You can use this annotation on a parameter of type {@link String} or {@link int}, {@link long} and
+ * {@link boolean}. While using an int, the value will represent the index into the value array. While
+ * using a boolean, the {@link #falseValues()} defines which indices are considered {@code false} or
+ * {@code true}.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(StaticValueHandler.Impl.class)
+@Deprecated
+@DeprecationInfo("Use @Values instead")
+public @interface StaticValue {
+    String[] value();
+
+    /**
+     * This is the short form for 'allowImplicitSwitchExpressions'
+     * and can be set to true if you want to allow int as well as boolean as annotated parameter types.
+     * The value array needs to be at least 2 long for this flag to be considered.
+     * While using an int, the value will represent the index into the value array.
+     * While using a boolean, the {@link #falseValues()} defines which indices are
+     * considered {@code false} or {@code true}.
+     */
+    @Deprecated
+    @DeprecationInfo("Dont need to set this to true")
+    boolean allowISE() default false;
+
+    int[] falseValues() default {0};
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Supplier.java

@@ -0,0 +1,48 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.SupplierHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER, ElementType.METHOD})
+@Handler.Implementation(SupplierHandler.Impl.class)
+public @interface Supplier {
+    /**
+     * The name this supplier is registered for.
+     */
+    String value() default "";
+
+    /**
+     * The type this supplier is registered for.
+     */
+    Class<?> type() default void.class;
+
+    /**
+     * If {@code true}, the supplier will only be used in the current command class.
+     */
+    boolean local() default true;
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/TabFilter.java

@@ -0,0 +1,40 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.TabFilterHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation defines per Parameter how the TabCompletions should be filtered and displayed by the client.
+ * There are 3 modes further described by {@link TabFilterType}. If this annotation is not present the default
+ * {@link TabFilterType#STARTS_WITH} is used.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(TabFilterHandler.Impl.class)
+public @interface TabFilter {
+    TabFilterType value();
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/TabFilterType.java

@@ -1,7 +1,7 @@
 /*
  *   This file is a part of the SteamWar software.
  *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Affero General Public License as published by
@@ -17,24 +17,25 @@
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package de.steamwar.command;
+package de.steamwar.command.annotations;
 
-import de.steamwar.command.dto.ExecutionIdentifier;
-import de.steamwar.command.dto.TestSWCommand;
+public enum TabFilterType {
 
-public class TypeMapperCommand extends TestSWCommand {
+    /**
+     * This value defines that, the starts with tab-completion filter is used.<br>
+     * see: {@link de.steamwar.command.mapper.internal.StartsWithFilter} for more.
+     */
+    STARTS_WITH,
 
-    public TypeMapperCommand() {
-        super("typemapper");
-    }
+    /**
+     * This value defines that, the contains tab-completions filter is used.
+     * see: {@link de.steamwar.command.mapper.internal.ContainsFilter} for more.
+     */
+    CONTAINS,
 
-    @Register
-    public void test(String sender, String s) {
-        throw new ExecutionIdentifier("RunTypeMapper with CustomMapper");
-    }
-
-    @ClassMapper(value = String.class, local = true)
-    public AbstractTypeMapper<String, String> getTypeMapper() {
-        return SWCommandUtils.createMapper("1", "2", "3", "4", "5");
-    }
+    /**
+     * This value disables any tab-completion filters and just returns anything you
+     * specified inside the TypeMapper.
+     */
+    NONE
 }

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Unique.java

@@ -0,0 +1,37 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2024  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.UniqueHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to define an array with unique values.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(UniqueHandler.Impl.class)
+public @interface Unique {
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Validator.java

@@ -0,0 +1,68 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.ValidatorHandler;
+
+import java.lang.annotation.*;
+
+/**
+ * Annotation for registering a method as a validator.
+ * The annotated method will be executed while {@link #initialize()}
+ * is evaluated. The result of this method will be cached under the
+ * name {@link ClassValidator#value()} converted to a {@link String} using
+ * {@link Class#getTypeName()}.
+ * This annotation can also be used on parameters to apply a validator to them.
+ * You can leave the {@link #value()} empty here to use the type of the parameter.
+ * For registering you should never leave {@link #value()} empty.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER, ElementType.METHOD})
+@Handler.Implementation(ValidatorHandler.Impl.class)
+@Repeatable(Validator.Validators.class)
+public @interface Validator {
+    /**
+     * The name this validator is registered for.
+     */
+    String value() default "";
+
+    /**
+     * The type this validator is registered for.
+     */
+    Class<?> type() default void.class;
+
+    /**
+     * If {@code true}, the validator will only be used in the current command class.
+     */
+    boolean local() default true;
+
+    /**
+     * If {@code true}, the validator will be inverted for parameter usage.
+     */
+    boolean invert() default false;
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target({ElementType.PARAMETER})
+    @Handler.Implementation(ValidatorHandler.Impl.class)
+    @interface Validators {
+        Validator[] value();
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/annotations/Values.java

@@ -0,0 +1,52 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.annotations;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.ValuesHandler;
+import de.steamwar.command.handler.ValuesReferenceHandler;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This annotation is used to define static values for a parameter like an enum just without the enum.
+ * You can use this annotation on a parameter of type {@link String} or {@link int}, {@link long} and
+ * {@link boolean}. While using an int, the value will represent the index into the value array. While
+ * using a boolean, the {@link #falseValues()} defines which indices are considered {@code false} or
+ * {@code true}.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.PARAMETER})
+@Handler.Implementation(ValuesHandler.Impl.class)
+public @interface Values {
+    String[] value();
+
+    int[] falseValues() default {0};
+
+    @Retention(RetentionPolicy.RUNTIME)
+    @Target({ElementType.PARAMETER})
+    @Handler.Implementation(ValuesReferenceHandler.Impl.class)
+    @interface Reference {
+        String value();
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/AbstractArrayNode.java

@@ -0,0 +1,110 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.graph;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.PreviousArguments;
+import de.steamwar.command.handler.ArrayLengthHandler;
+import de.steamwar.command.handler.UniqueHandler;
+import de.steamwar.command.utils.Triple;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Parameter;
+import java.util.*;
+
+public abstract class AbstractArrayNode<E> extends AbstractTypeNode<E> {
+
+    protected final boolean unique;
+    protected final int minArrayLength;
+    protected final int maxArrayLength;
+    protected final String error;
+
+    protected AbstractArrayNode(Parameter parameter, int index, Handler.DataReadable dataReadable) {
+        super(parameter, index, dataReadable);
+
+        this.unique = UniqueHandler.isPresent(parameter);
+        this.minArrayLength = ArrayLengthHandler.getMin(parameter);
+        this.maxArrayLength = ArrayLengthHandler.getMax(parameter);
+        this.error = ArrayLengthHandler.getError(parameter);
+    }
+
+    @Override
+    public void tabComplete(E executor, NodeData nodeData, List<Collection<String>> completions) {
+        Object array = Array.newInstance(type, Math.min(nodeData.unparsedArgumentsSize(), maxArrayLength));
+
+        int i = 0;
+        while (!nodeData.hasOneLeft()) {
+            if (i >= minArrayLength) {
+                for (Node<E> child : children) {
+                    child.tabComplete(executor, nodeData, completions);
+                }
+            }
+
+            nodeData.add(name, arrayCopy(array, i));
+            Triple<Object, Boolean, Boolean> argument = argument(executor, nodeData);
+            nodeData.remove();
+
+            if (!argument.b) {
+                for (; i > 0; i--) nodeData.unconsume();
+                return;
+            }
+            nodeData.consume();
+            Array.set(array, i, argument.a);
+            i++;
+        }
+        nodeData.add(name, arrayCopy(array, i));
+        if (i < maxArrayLength) {
+            PreviousArguments previousArguments = nodeData.toPreviousArguments();
+            if (unique) {
+                Map<Object, List<String>> mapped = new HashMap<>();
+                for (String s : typeMapper.tabComplete(executor, previousArguments, nodeData.current())) {
+                    mapped.computeIfAbsent(typeMapper.map(executor, previousArguments, s), object -> new ArrayList<>())
+                            .add(s);
+                }
+                for (int j = 0; j < i; j++) {
+                    mapped.remove(Array.get(array, j));
+                }
+                mapped.forEach((object, strings) -> {
+                    completions.add(strings);
+                });
+            } else {
+                completions.add(typeMapper.tabComplete(executor, previousArguments, nodeData.current()));
+            }
+        }
+        if (i >= minArrayLength) {
+            for (Node<E> child : children) {
+                child.tabComplete(executor, nodeData, completions);
+            }
+        }
+        nodeData.remove();
+        for (; i > 0; i--) nodeData.unconsume();
+    }
+
+    protected Object arrayCopy(Object array, int newLength) {
+        Object newArray = Array.newInstance(type, newLength);
+        System.arraycopy(array, 0, newArray, 0, Math.min(Array.getLength(array), newLength));
+        return newArray;
+    }
+
+    @Override
+    public int nodeCost() {
+        return minArrayLength * 2 + super.nodeCost();
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/AbstractTypeNode.java

@@ -0,0 +1,145 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.graph;
+
+import de.steamwar.command.*;
+import de.steamwar.command.annotations.TabFilterType;
+import de.steamwar.command.handler.TabFilterHandler;
+import de.steamwar.command.mapper.EnumMapper;
+import de.steamwar.command.mapper.OptionEnumMapper;
+import de.steamwar.command.mapper.internal.ContainsFilter;
+import de.steamwar.command.mapper.internal.StartsWithFilter;
+import de.steamwar.command.utils.Pair;
+import de.steamwar.command.utils.Triple;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Parameter;
+import java.util.List;
+
+public abstract class AbstractTypeNode<E> extends AbstractValidationNode<E> {
+
+    protected Class<?> type;
+    protected AbstractTypeMapper<E, Object> typeMapper;
+
+    protected AbstractTypeNode(Parameter parameter, int index, Handler.DataReadable dataReadable) {
+        super(parameter, index, dataReadable);
+
+        type = parameter.getType();
+        if (type.isArray()) type = type.getComponentType();
+
+        initializeTypeMapper(handlerParameters, parameter, index, dataReadable);
+    }
+
+    private AbstractTypeMapper<E, Object> getTypeMapper(Handler.DataReadable dataReadable) {
+        AbstractTypeMapper<E, Object> typeMapper = dataReadable.getMapper(type.getTypeName());
+        if (typeMapper == null && type.isEnum()) {
+            if (OptionEnum.class.isAssignableFrom(type)) {
+                typeMapper = (AbstractTypeMapper) new OptionEnumMapper((Class) type);
+            } else {
+                typeMapper = (AbstractTypeMapper) new EnumMapper((Class) type);
+            }
+        }
+        return typeMapper;
+    }
+
+    private void initializeTypeMapper(List<Pair<Annotation, Handler.HandlerParameter>> pairs, Parameter parameter, int index, Handler.DataReadable dataReadable) {
+        AbstractTypeMapper<E, Object> typeMapper = getTypeMapper(dataReadable);
+        boolean isStillDefault = true;
+        for (Pair<Annotation, Handler.HandlerParameter> pair : pairs) {
+            if (pair.b.needsParentTypeMapper()) {
+                continue;
+            }
+            if (!isStillDefault) {
+                throw new UnsupportedOperationException("Only one HandlerParameter can be used without a parent TypeMapper");
+            }
+            AbstractTypeMapper<E, Object> temp = pair.b.getTypeMapper(pair.a, parameter, index, dataReadable, null);
+            if (temp != null) {
+                typeMapper = temp;
+                isStillDefault = false;
+            }
+        }
+
+        AbstractTypeMapper<E, Object> current = typeMapper;
+        for (Pair<Annotation, Handler.HandlerParameter> pair : pairs) {
+            if (!pair.b.needsParentTypeMapper()) {
+                continue;
+            }
+            AbstractTypeMapper<E, Object> temp = pair.b.getTypeMapper(pair.a, parameter, index, dataReadable, typeMapper);
+            if (temp != null) {
+                typeMapper = temp;
+            }
+        }
+
+        current = TabCompletionCache.cached(current, typeMapper);
+
+        TabFilterType tabFilterType = TabFilterHandler.getTabFilterType(parameter);
+        switch (tabFilterType) {
+            case NONE:
+                this.typeMapper = current;
+                break;
+            case STARTS_WITH:
+                this.typeMapper = new StartsWithFilter<>(current);
+                break;
+            case CONTAINS:
+                this.typeMapper = new ContainsFilter<>(current);
+                break;
+        }
+    }
+
+    protected Triple<Object, Boolean, Boolean> argument(E executor, NodeData nodeData) {
+        Object value;
+        boolean usedOptional;
+        try {
+            PreviousArguments previousArguments = nodeData.toPreviousArguments();
+            value = typeMapper.map(executor, previousArguments, nodeData.current());
+            usedOptional = previousArguments.hasUsedOptionalValue();
+        } catch (Exception e) {
+            return new Triple<>(null, false, false);
+        }
+        if (validate(executor, value, nodeData)) {
+            return new Triple<>(value, true, usedOptional);
+        } else {
+            return new Triple<>(null, false, false);
+        }
+    }
+
+    protected boolean validate(E executor, Object value, NodeData nodeData) {
+        for (AbstractTypeValidator<E, Object> validator : validators) {
+            try {
+                if (!validator.validate(executor, value, nodeData)) {
+                    return false;
+                }
+            } catch (ClassCastException e) {
+                // Ignore
+            } catch (Throwable e) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public boolean equals(Parameter parameter, Node<E> children) {
+        if (!(children instanceof AbstractTypeNode)) {
+            return false;
+        }
+        return super.equals(parameter, children);
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/AbstractValidationNode.java

@@ -0,0 +1,109 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.graph;
+
+import de.steamwar.command.AbstractTypeValidator;
+import de.steamwar.command.CommandUtils;
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.AllowNullHandler;
+import de.steamwar.command.utils.Pair;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Parameter;
+import java.util.*;
+
+public abstract class AbstractValidationNode<E> extends Node<E> {
+
+    private static final AbstractTypeValidator<?, ?> NON_NULL_VALIDATOR = (AbstractTypeValidator<Object, Object>) (sender, value, messageSender) -> value != null;
+
+    protected final List<Annotation> annotations;
+    protected final List<Pair<Annotation, Handler.HandlerParameter>> handlerParameters;
+    protected final List<AbstractTypeValidator<E, Object>> validators = new ArrayList<>();
+
+    protected AbstractValidationNode(Parameter parameter, int index, Handler.DataReadable dataReadable) {
+        super(parameter);
+        annotations = CommandUtils.getAnnotations(parameter, Handler.HandlerParameter.class);
+        List<Pair<Annotation, Handler.HandlerParameter>> pairs = new ArrayList<>();
+        for (Annotation annotation : annotations) {
+            Handler.Implementation implementation = annotation.annotationType().getAnnotation(Handler.Implementation.class);
+            try {
+                pairs.add(new Pair<>(annotation, (Handler.HandlerParameter) implementation.value().getConstructor().newInstance()));
+            } catch (Exception e) {
+                throw new SecurityException(e);
+            }
+        }
+        handlerParameters = pairs;
+
+        initializeValidators(handlerParameters, parameter, index, dataReadable);
+    }
+
+    private void initializeValidators(List<Pair<Annotation, Handler.HandlerParameter>> pairs, Parameter parameter, int index, Handler.DataReadable dataReadable) {
+        pairs.sort(Comparator.comparingInt(p -> p.b.getValidatorPriority()));
+        for (Pair<Annotation, Handler.HandlerParameter> pair : pairs) {
+            AbstractTypeValidator<E, Object> validator = pair.b.getValidator(pair.a, parameter, index, dataReadable);
+            if (validator != null) {
+                validators.add(validator);
+            }
+        }
+
+        if (!AllowNullHandler.isPresent(parameter)) {
+            validators.add((AbstractTypeValidator<E, Object>) NON_NULL_VALIDATOR);
+        }
+    }
+
+    @Override
+    public boolean equals(Parameter parameter, Node<E> children) {
+        if (this.parameter.getType() != parameter.getType()) {
+            return false;
+        }
+
+        Annotation[] annotations = this.parameter.getAnnotations();
+        Annotation[] currentAnnotations = parameter.getAnnotations();
+
+        if (annotations.length == 0 && currentAnnotations.length == 0) {
+            return true;
+        }
+
+        if (annotations.length != currentAnnotations.length) {
+            return false;
+        }
+
+        Map<Class<?>, Annotation> annotationMap = new HashMap<>();
+        boolean duplicate = false;
+        for (Annotation annotation : annotations) {
+            if (annotationMap.put(annotation.annotationType(), annotation) != null) {
+                duplicate = true;
+                break;
+            }
+        }
+        if (duplicate) {
+            return false;
+        }
+
+        for (Annotation annotation : currentAnnotations) {
+            Annotation other = annotationMap.get(annotation.annotationType());
+            if (!annotation.equals(other)) {
+                continue;
+            }
+            annotationMap.remove(annotation.annotationType());
+        }
+        return annotationMap.isEmpty();
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/ExecuteNode.java

@@ -0,0 +1,89 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.graph;
+
+import de.steamwar.command.CommandFrameworkException;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class ExecuteNode<E> extends Node<E> {
+
+    private final Object self;
+    private final Method method;
+
+    public ExecuteNode(Object self, Method method) {
+        super(null);
+        this.self = self;
+        this.method = method;
+    }
+
+    @Override
+    public boolean execute(E executor, NodeData nodeData) {
+        for (Node<E> child : children) {
+            if (child.execute(executor, nodeData)) {
+                return true;
+            }
+        }
+
+        if (nodeData.hasMore()) {
+            return false;
+        }
+
+        try {
+            method.invoke(self, nodeData.mapped());
+            return true;
+        } catch (InvocationTargetException e) {
+            throw new CommandFrameworkException(e, nodeData.alias(), nodeData.args());
+        } catch (IllegalAccessException | RuntimeException e) {
+            return false;
+        }
+    }
+
+    @Override
+    public void tabComplete(E executor, NodeData nodeData, List<Collection<String>> completions) {
+        for (Node<E> child : children) {
+            child.tabComplete(executor, nodeData, completions);
+        }
+    }
+
+    @Override
+    public boolean equals(Parameter parameter, Node<E> children) {
+        if (children instanceof ExecuteNode) {
+            String parameters = Arrays.stream(method.getParameters()).map(par -> {
+                String annotations = Arrays.stream(par.getAnnotations())
+                        .map(annotation -> "@" + annotation.getClass().getSimpleName())
+                        .collect(Collectors.joining(" "));
+                if (par.isVarArgs()) {
+                    return annotations + (annotations.isEmpty() ? "" : " ") + par.getType().componentType().getSimpleName() + "...";
+                } else {
+                    return annotations + (annotations.isEmpty() ? "" : " ") + par.getType().getSimpleName();
+                }
+            }).collect(Collectors.joining(", "));
+            throw new UnsupportedOperationException("Command with parameters " + parameters + " is already defined in " + self.getClass().getName());
+        }
+        return children instanceof ExecuteNode;
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/ExecutorTypeNode.java

@@ -0,0 +1,95 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.graph;
+
+import de.steamwar.command.AbstractTypeValidator;
+import de.steamwar.command.Handler;
+
+import java.lang.reflect.Parameter;
+import java.util.Collection;
+import java.util.List;
+import java.util.function.Function;
+
+public class ExecutorTypeNode<E> extends AbstractValidationNode<E> {
+
+    protected final Function<E, ?> executorMapper;
+
+    public ExecutorTypeNode(Parameter parameter, int index, Handler.DataReadable dataReadable) {
+        super(parameter, index, dataReadable);
+        this.executorMapper = (Function<E, ?>) dataReadable.getExecutorMapper(parameter.getType());
+    }
+
+    @Override
+    public boolean execute(E executor, NodeData nodeData) {
+        Object mappedExecutor = executorMapper.apply(executor);
+        if (mappedExecutor == null) return false;
+        for (AbstractTypeValidator<E, Object> validator : validators) {
+            try {
+                if (!validator.validate(executor, executor, nodeData)) {
+                    return false;
+                }
+            } catch (ClassCastException e) {
+                // Ignore
+            } catch (Throwable e) {
+                return false;
+            }
+        }
+        nodeData.add(name, mappedExecutor);
+        for (Node<E> child : children) {
+            if (child.execute(executor, nodeData)) return true;
+        }
+        nodeData.remove();
+        return false;
+    }
+
+    @Override
+    public void tabComplete(E executor, NodeData nodeData, List<Collection<String>> completions) {
+        Object mappedExecutor = executorMapper.apply(executor);
+        if (mappedExecutor == null) return;
+        for (AbstractTypeValidator<E, Object> validator : validators) {
+            try {
+                if (!validator.validate(executor, executor, nodeData)) {
+                    return;
+                }
+            } catch (ClassCastException e) {
+                // Ignore
+            } catch (Throwable e) {
+                return;
+            }
+        }
+        nodeData.add(name, mappedExecutor);
+        for (Node<E> child : children) {
+            child.tabComplete(executor, nodeData, completions);
+        }
+        nodeData.remove();
+    }
+
+    @Override
+    public boolean equals(Parameter parameter, Node<E> children) {
+        if (!(children instanceof ExecutorTypeNode)) {
+            return false;
+        }
+        ExecutorTypeNode other = (ExecutorTypeNode) children;
+        if (executorMapper != other.executorMapper) {
+            return false;
+        }
+        return super.equals(parameter, children);
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/GreedyArrayNode.java

@@ -0,0 +1,98 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.graph;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.handler.GreedyHandler;
+import de.steamwar.command.utils.Triple;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Parameter;
+import java.util.HashSet;
+import java.util.Set;
+
+public class GreedyArrayNode<E> extends AbstractArrayNode<E> {
+
+    protected final int backTrackingDepth;
+
+    public GreedyArrayNode(Parameter parameter, int index, Handler.DataReadable dataReadable) {
+        super(parameter, index, dataReadable);
+        this.backTrackingDepth = GreedyHandler.getBackTrackingDepth(parameter);
+    }
+
+    @Override
+    public boolean execute(E executor, NodeData nodeData) {
+        int min = Math.min(nodeData.unparsedArgumentsSize(), minArrayLength);
+        int max = Math.min(nodeData.unparsedArgumentsSize(), maxArrayLength);
+        if (max < minArrayLength) {
+            nodeData.send(error, 0, minArrayLength);
+            return false;
+        }
+
+        Object array = Array.newInstance(type, max);
+        Set<Object> seen = new HashSet<>();
+
+        int i = 0;
+        for (; i < max; i++) {
+            nodeData.add(name, arrayCopy(array, i));
+            Triple<Object, Boolean, Boolean> argument = argument(executor, nodeData);
+            nodeData.remove();
+
+            if (!argument.b || (unique && !seen.add(argument.a))) {
+                if (i < minArrayLength) {
+                    nodeData.send(error, i, minArrayLength);
+                    for (; i > 0; i--) nodeData.unconsume();
+                    return false;
+                }
+                break;
+            }
+            Array.set(array, i, argument.a);
+            nodeData.consume();
+        }
+
+        int backTrackingDepth = i - this.backTrackingDepth;
+        for (; i >= min; i--) {
+            Object copiedArray = arrayCopy(array, i);
+            nodeData.add(name, copiedArray);
+            if (validate(executor, copiedArray, nodeData)) {
+                for (Node<E> child : children) {
+                    if (child.execute(executor, nodeData)) {
+                        return true;
+                    }
+                }
+            }
+            nodeData.remove();
+            if (i <= backTrackingDepth) {
+                break;
+            }
+            if (i > 0) {
+                nodeData.unconsume();
+            }
+        }
+        if (i < minArrayLength) nodeData.send(error, i, minArrayLength);
+        for (; i > 0; i--) nodeData.unconsume();
+        return false;
+    }
+
+    @Override
+    public int nodeCost() {
+        return -1;
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/LiteralNode.java

@@ -0,0 +1,75 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.graph;
+
+import java.lang.reflect.Parameter;
+import java.util.Collection;
+import java.util.List;
+
+public class LiteralNode<E> extends Node<E> {
+
+    protected final String literal;
+
+    public LiteralNode(String literal) {
+        super(null);
+        this.literal = literal;
+    }
+
+    @Override
+    public boolean execute(E executor, NodeData nodeData) {
+        if (!nodeData.hasMore()) return false;
+        if (nodeData.current().equalsIgnoreCase(literal)) {
+            nodeData.consume();
+            for (Node<E> child : children) {
+                if (child.execute(executor, nodeData)) {
+                    return true;
+                }
+            }
+            nodeData.unconsume();
+        }
+        return false;
+    }
+
+    @Override
+    public void tabComplete(E executor, NodeData nodeData, List<Collection<String>> completions) {
+        if (nodeData.hasOneLeft()) {
+            if (literal.startsWith(nodeData.current())) {
+                completions.add(List.of(literal));
+            }
+            return;
+        }
+
+        if (nodeData.current().equalsIgnoreCase(literal)) {
+            nodeData.consume();
+            for (Node<E> child : children) {
+                child.tabComplete(executor, nodeData, completions);
+            }
+            nodeData.unconsume();
+        }
+    }
+
+    @Override
+    public boolean equals(Parameter parameter, Node<E> children) {
+        if (!(children instanceof LiteralNode)) {
+            return false;
+        }
+        return literal.equalsIgnoreCase(((LiteralNode) children).literal);
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/NoTabCompleteNode.java

@@ -0,0 +1,49 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.graph;
+
+import java.lang.reflect.Parameter;
+import java.util.Collection;
+import java.util.List;
+
+public class NoTabCompleteNode<E> extends Node<E> {
+
+    public NoTabCompleteNode() {
+        super(null);
+    }
+
+    @Override
+    public boolean execute(E executor, NodeData nodeData) {
+        for (Node<E> child : children) {
+            if (child.execute(executor, nodeData)) return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void tabComplete(E executor, NodeData nodeData, List<Collection<String>> completions) {
+        // Do nothing
+    }
+
+    @Override
+    public boolean equals(Parameter parameter, Node<E> children) {
+        return children instanceof NoTabCompleteNode;
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/Node.java

@@ -0,0 +1,83 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.graph;
+
+import de.steamwar.command.annotations.Name;
+
+import java.lang.reflect.Parameter;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Comparator;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public abstract class Node<E> {
+
+    protected final Parameter parameter;
+    protected final String name;
+    protected final List<Node<E>> children = new ArrayList<>();
+
+    protected Node(Parameter parameter) {
+        this.parameter = parameter;
+        if (parameter == null) {
+            this.name = null;
+            return;
+        }
+
+        Name name = parameter.getAnnotation(Name.class);
+        if (name == null) {
+            this.name = parameter.getName();
+        } else {
+            this.name = name.value();
+        }
+    }
+
+    public abstract boolean execute(E executor, NodeData nodeData);
+    public abstract void tabComplete(E executor, NodeData nodeData, List<Collection<String>> completions);
+
+    public final Node<E> addChild(Parameter parameter, Node<E> child) {
+        for (Node<E> currentChild : children) {
+            if (currentChild.equals(parameter, child)) {
+                return currentChild;
+            }
+        }
+        children.add(child);
+        return child;
+    }
+
+    public abstract boolean equals(Parameter parameter, Node<E> children);
+
+    public int nodeCost() {
+        return 2;
+    }
+
+    public final int sort() {
+        AtomicInteger max = new AtomicInteger(0);
+        if (children.size() == 1) {
+            return children.get(0).sort() + nodeCost();
+        }
+        children.sort(Comparator.comparingInt(value -> {
+            int sort = value.sort();
+            if (sort > max.get()) max.set(sort);
+            return -sort;
+        }));
+        return max.get() + nodeCost();
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/NodeData.java

@@ -0,0 +1,120 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.graph;
+
+import de.steamwar.command.AbstractTypeValidator;
+import de.steamwar.command.PreviousArguments;
+import lombok.NonNull;
+
+import java.util.Arrays;
+import java.util.LinkedList;
+
+public class NodeData implements AbstractTypeValidator.MessageSender {
+
+    private final String alias;
+    private final LinkedList<String> parsedArguments = new LinkedList<>();
+    private final LinkedList<String> unparsedArguments;
+    private final LinkedList<Object> mapped = new LinkedList<>();
+    private final LinkedList<String> names = new LinkedList<>();
+    private final AbstractTypeValidator.MessageSender messageSender;
+
+    public NodeData(String alias, String[] args, AbstractTypeValidator.MessageSender messageSender) {
+        this.alias = alias;
+        this.unparsedArguments = new LinkedList<>(Arrays.asList(args));
+        this.messageSender = messageSender;
+    }
+
+    public String[] args() {
+        return parsedArguments.toArray(String[]::new);
+    }
+
+    public String alias() {
+        return alias;
+    }
+
+    public String current() {
+        if (unparsedArguments.isEmpty()) return null;
+        return unparsedArguments.getFirst();
+    }
+
+    public boolean hasMore() {
+        return !unparsedArguments.isEmpty();
+    }
+
+    public boolean hasOneLeft() {
+        return unparsedArguments.size() == 1;
+    }
+
+    void consume() {
+        parsedArguments.addLast(unparsedArguments.removeFirst());
+    }
+
+    void unconsume() {
+        unparsedArguments.addFirst(parsedArguments.removeLast());
+    }
+
+    void add(String name, Object mapped) {
+        this.names.addLast(name);
+        this.mapped.addLast(mapped);
+    }
+
+    void remove() {
+        this.names.removeLast();
+        this.mapped.removeLast();
+    }
+
+    public Object getByName(@NonNull String name) {
+        for (int i = mapped.size() - 1; i >= 0; i--) {
+            if (name.equals(names.get(i))) {
+                return mapped.get(i);
+            }
+        }
+        return null;
+    }
+
+    public Object[] mapped() {
+        return mapped.toArray();
+    }
+
+    public int unparsedArgumentsSize() {
+        return unparsedArguments.size();
+    }
+
+    @Override
+    public void send(String s, Object... args) {
+        if (s == null || s.isEmpty()) return;
+        messageSender.send(s, args);
+    }
+
+    PreviousArguments toPreviousArguments() {
+        return new PreviousArguments(args(), mapped(), hasMore(), this::getByName);
+    }
+
+    @Override
+    public String toString() {
+        return "NodeData{" +
+                "alias='" + alias + '\'' +
+                ", parsedArguments=" + parsedArguments + " (" + parsedArguments.size() + ")" +
+                ", unparsedArguments=" + unparsedArguments + " (" + unparsedArguments.size() + ")" +
+                ", mapped=" + mapped + " (" + mapped.size() + ")" +
+                ", names=" + names + " (" + names.size() + ")" +
+                '}';
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/NonGreedyArrayNode.java

@@ -0,0 +1,83 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.graph;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.utils.Triple;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Parameter;
+import java.util.HashSet;
+import java.util.Set;
+
+public class NonGreedyArrayNode<E> extends AbstractArrayNode<E> {
+
+    public NonGreedyArrayNode(Parameter parameter, int index, Handler.DataReadable dataReadable) {
+        super(parameter, index, dataReadable);
+    }
+
+    @Override
+    public boolean execute(E executor, NodeData nodeData) {
+        int min = Math.max(nodeData.unparsedArgumentsSize(), minArrayLength);
+        int max = Math.min(nodeData.unparsedArgumentsSize(), maxArrayLength);
+        if (max < minArrayLength) {
+            nodeData.send(error, 0, minArrayLength);
+            return false;
+        }
+        Object array = Array.newInstance(type, max);
+        Set<Object> seen = new HashSet<>();
+
+        int i = 0;
+        do {
+            Object copiedArray = arrayCopy(array, i);
+            nodeData.add(name, copiedArray);
+            if (i >= min && validate(executor, copiedArray, nodeData)) {
+                for (Node<E> child : children) {
+                    if (child.execute(executor, nodeData)) return true;
+                }
+            }
+
+            Triple<Object, Boolean, Boolean> argument = argument(executor, nodeData);
+            nodeData.remove();
+            if (!argument.b || (unique && !seen.add(argument.a))) {
+                if (i < minArrayLength) nodeData.send(error, i, minArrayLength);
+                for (; i > 0; i--) nodeData.unconsume();
+                return false;
+            }
+            nodeData.consume();
+            Array.set(array, i, argument.a);
+            i++;
+        } while (i < max);
+
+        if (i >= min) {
+            Object copiedArray = arrayCopy(array, i);
+            nodeData.add(name, copiedArray);
+            if (validate(executor, copiedArray, nodeData)) {
+                for (Node<E> child : children) {
+                    if (child.execute(executor, nodeData)) return true;
+                }
+            }
+            nodeData.remove();
+        }
+        if (i < minArrayLength) nodeData.send(error, i, minArrayLength);
+        for (; i > 0; i--) nodeData.unconsume();
+        return false;
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/RootNode.java

@@ -0,0 +1,51 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.graph;
+
+import java.lang.reflect.Parameter;
+import java.util.Collection;
+import java.util.List;
+
+public class RootNode<E> extends Node<E> {
+
+    public RootNode() {
+        super(null);
+    }
+
+    @Override
+    public boolean execute(E executor, NodeData nodeData) {
+        for (Node<E> child : children) {
+            if (child.execute(executor, nodeData)) return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void tabComplete(E executor, NodeData nodeData, List<Collection<String>> completions) {
+        for (Node<E> child : children) {
+            child.tabComplete(executor, nodeData, completions);
+        }
+    }
+
+    @Override
+    public boolean equals(Parameter parameter, Node<E> children) {
+        return children instanceof RootNode;
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/SupplierNode.java

@@ -0,0 +1,100 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.graph;
+
+import de.steamwar.command.AbstractTypeSupplier;
+import de.steamwar.command.Handler;
+import de.steamwar.command.PreviousArguments;
+import de.steamwar.command.annotations.Supplier;
+import de.steamwar.command.handler.AllowNullHandler;
+
+import java.lang.reflect.Parameter;
+import java.util.Collection;
+import java.util.List;
+
+public class SupplierNode<E> extends Node<E> {
+
+    protected final AbstractTypeSupplier<E, Object> typeSupplier;
+    protected final boolean allowNull;
+
+    public SupplierNode(Parameter parameter, Handler.DataReadable dataReadable) {
+        super(parameter);
+
+        Supplier annotation = parameter.getAnnotation(Supplier.class);
+        String s = annotation.value() != null && !annotation.value().isEmpty() ? annotation.value() : parameter.getType().getTypeName();
+        typeSupplier = dataReadable.getSupplier(s);
+
+        allowNull = AllowNullHandler.isPresent(parameter);
+    }
+
+    @Override
+    public boolean execute(E executor, NodeData nodeData) {
+        PreviousArguments previousArguments = nodeData.toPreviousArguments();
+        Object value;
+        try {
+            value = typeSupplier.get(executor, previousArguments);
+        } catch (Exception e) {
+            return false;
+        }
+
+        if (!allowNull && value == null) {
+            return false;
+        }
+        nodeData.add(name, value);
+
+        for (Node<E> child : children) {
+            if (child.execute(executor, nodeData)) return true;
+        }
+
+        nodeData.remove();
+        return false;
+    }
+
+    @Override
+    public void tabComplete(E executor, NodeData nodeData, List<Collection<String>> completions) {
+        PreviousArguments previousArguments = nodeData.toPreviousArguments();
+        Object value;
+        try {
+            value = typeSupplier.get(executor, previousArguments);
+        } catch (Exception e) {
+            return;
+        }
+
+        if (!allowNull && value == null) {
+            return;
+        }
+        nodeData.add(name, value);
+
+        for (Node<E> child : children) {
+            child.tabComplete(executor, nodeData, completions);
+        }
+
+        nodeData.remove();
+    }
+
+    @Override
+    public boolean equals(Parameter parameter, Node<E> children) {
+        if (children instanceof SupplierNode) {
+            SupplierNode<?> supplierNode = (SupplierNode<?>) children;
+            return allowNull == supplierNode.allowNull && typeSupplier == supplierNode.typeSupplier;
+        }
+        return false;
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/graph/TypeNode.java

@@ -0,0 +1,84 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.graph;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.PreviousArguments;
+import de.steamwar.command.utils.Triple;
+
+import java.lang.reflect.Parameter;
+import java.util.Collection;
+import java.util.List;
+
+public class TypeNode<E> extends AbstractTypeNode<E> {
+
+    public TypeNode(Parameter parameter, int index, Handler.DataReadable dataReadable) {
+        super(parameter, index, dataReadable);
+    }
+
+    @Override
+    public boolean execute(E executor, NodeData nodeData) {
+        Triple<Object, Boolean, Boolean> argument = argument(executor, nodeData);
+        if (!argument.b) return false;
+        nodeData.add(name, argument.a);
+        if (!argument.c) nodeData.consume();
+
+        for (Node<E> child : children) {
+            if (child.execute(executor, nodeData)) return true;
+        }
+
+        nodeData.remove();
+        if (!argument.c) nodeData.unconsume();
+        return false;
+    }
+
+    @Override
+    public void tabComplete(E executor, NodeData nodeData, List<Collection<String>> completions) {
+        if (nodeData.hasOneLeft()) {
+            PreviousArguments previousArguments = nodeData.toPreviousArguments();
+            Collection<String> tabCompletions = typeMapper.tabComplete(executor, previousArguments, nodeData.current());
+            completions.add(tabCompletions);
+
+            if (typeMapper.appendNextElementTabCompletions()) {
+                for (Node<E> child : children) {
+                    child.tabComplete(executor, nodeData, completions);
+                }
+            }
+            return;
+        }
+
+        Triple<Object, Boolean, Boolean> argument = argument(executor, nodeData);
+        if (!argument.b) return;
+        nodeData.add(name, argument.a);
+        if (!argument.c) nodeData.consume();
+
+        for (Node<E> child : children) {
+            child.tabComplete(executor, nodeData, completions);
+        }
+
+        nodeData.remove();
+        if (!argument.c) nodeData.unconsume();
+    }
+
+    @Override
+    public int nodeCost() {
+        return type == String.class ? 1 : 2;
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/AllowNullHandler.java

@@ -0,0 +1,48 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.annotations.AllowNull;
+
+import java.lang.reflect.Parameter;
+
+/**
+ * This special Handler is just for validating the AllowNull annotation.
+ */
+public final class AllowNullHandler {
+
+    public static boolean isPresent(Parameter parameter) {
+        return parameter.isAnnotationPresent(AllowNull.class);
+    }
+
+    public static final class Impl implements Handler.HandlerParameter<AllowNull, Object, Object> {
+
+        @Override
+        public void check(AllowNull annotation, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            if (index == 0) {
+                throw new UnsupportedOperationException("AllowNull annotation cannot be used on the first parameter");
+            }
+            if (parameter.getType().isPrimitive()) {
+                throw new UnsupportedOperationException("AllowNull annotation cannot be used on primitive types");
+            }
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/ArrayLengthHandler.java

@@ -0,0 +1,62 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.annotations.ArrayLength;
+
+import java.lang.reflect.Parameter;
+
+public final class ArrayLengthHandler {
+
+    public static int getMin(Parameter parameter) {
+        ArrayLength arrayLength = parameter.getAnnotation(ArrayLength.class);
+        if (arrayLength == null) return 0;
+        return arrayLength.min();
+    }
+
+    public static int getMax(Parameter parameter) {
+        ArrayLength arrayLength = parameter.getAnnotation(ArrayLength.class);
+        if (arrayLength == null) return Integer.MAX_VALUE;
+        return arrayLength.max();
+    }
+
+    public static String getError(Parameter parameter) {
+        ArrayLength arrayLength = parameter.getAnnotation(ArrayLength.class);
+        if (arrayLength == null) return "";
+        return arrayLength.error();
+    }
+
+    public static final class Impl implements Handler.HandlerParameter<ArrayLength, Object, Object> {
+
+        @Override
+        public void check(ArrayLength arrayLength, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            if (index == 0) {
+                throw new UnsupportedOperationException("ArrayLength annotation cannot be used on first parameter");
+            }
+            if (!parameter.getType().isArray()) {
+                throw new UnsupportedOperationException("Parameter " + index + " of " + parameter.getDeclaringExecutable().getName() + " is not an array");
+            }
+            if (arrayLength.min() > arrayLength.max()) {
+                throw new UnsupportedOperationException("Min ArrayLength cannot be smaller than Max ArrayLength");
+            }
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/CachedHandler.java

@@ -0,0 +1,54 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.Handler;
+import de.steamwar.command.TabCompletionCache;
+import de.steamwar.command.annotations.Cached;
+
+import java.lang.reflect.Method;
+
+public final class CachedHandler {
+
+    public static final class Impl implements Handler.HandlerMethod<Cached> {
+
+        @Override
+        public void check(Cached annotation, Method method, DataCheckable dataCheckable) throws Exception {
+            if (method.getParameterCount() != 0) {
+                throw new UnsupportedOperationException("Cached method must have no parameters");
+            }
+            if (!AbstractTypeMapper.class.isAssignableFrom(method.getReturnType())) {
+                throw new UnsupportedOperationException("Cached method must return AbstractTypeMapper");
+            }
+        }
+
+        @Override
+        public int getRunPriority() {
+            return Integer.MIN_VALUE;
+        }
+
+        @Override
+        public void run(Cached annotation, Method method, DataWritable dataWritable) {
+            AbstractTypeMapper abstractTypeMapper = dataWritable.invoke(method);
+            TabCompletionCache.add(abstractTypeMapper, annotation.global(), annotation.cacheDuration(), annotation.timeUnit());
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/ClassMapperHandler.java

@@ -0,0 +1,54 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.Handler;
+import de.steamwar.command.annotations.ClassMapper;
+
+import java.lang.reflect.Method;
+
+@Deprecated
+public final class ClassMapperHandler {
+
+    public static final class Impl implements Handler.HandlerMethod<ClassMapper> {
+
+        @Override
+        public void check(ClassMapper annotation, Method method, DataCheckable dataCheckable) throws Exception {
+            if (method.getParameterCount() != 0) {
+                throw new UnsupportedOperationException("ClassMapper method must have no parameters");
+            }
+            if (!AbstractTypeMapper.class.isAssignableFrom(method.getReturnType())) {
+                throw new UnsupportedOperationException("ClassMapper method must return AbstractTypeMapper");
+            }
+        }
+
+        @Override
+        public int getRunPriority() {
+            return Integer.MIN_VALUE;
+        }
+
+        @Override
+        public void run(ClassMapper annotation, Method method, DataWritable dataWritable) {
+            AbstractTypeMapper abstractTypeMapper = dataWritable.invoke(method);
+            dataWritable.addMapper(annotation.value().getName(), annotation.local(), abstractTypeMapper);
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/ClassValidatorHandler.java

@@ -0,0 +1,54 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.AbstractTypeValidator;
+import de.steamwar.command.Handler;
+import de.steamwar.command.annotations.ClassValidator;
+
+import java.lang.reflect.Method;
+
+@Deprecated
+public final class ClassValidatorHandler {
+
+    public static final class Impl implements Handler.HandlerMethod<ClassValidator> {
+
+        @Override
+        public void check(ClassValidator annotation, Method method, DataCheckable dataCheckable) throws Exception {
+            if (method.getParameterCount() != 0) {
+                throw new UnsupportedOperationException("ClassValidator method must have no parameters");
+            }
+            if (!AbstractTypeValidator.class.isAssignableFrom(method.getReturnType())) {
+                throw new UnsupportedOperationException("ClassValidator method must return AbstractValidator");
+            }
+        }
+
+        @Override
+        public int getRunPriority() {
+            return Integer.MIN_VALUE;
+        }
+
+        @Override
+        public void run(ClassValidator annotation, Method method, DataWritable dataWritable) {
+            AbstractTypeValidator<Object, Object> abstractTypeValidator = dataWritable.invoke(method);
+            dataWritable.addValidator(annotation.value().getName(), annotation.local(), abstractTypeValidator);
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/EndsWithHandler.java

@@ -0,0 +1,84 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *   
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *   
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *   
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.AbstractTypeValidator;
+import de.steamwar.command.Handler;
+import de.steamwar.command.PreviousArguments;
+import de.steamwar.command.annotations.EndsWith;
+import de.steamwar.command.mapper.internal.DelegatingMapper;
+
+import java.lang.reflect.Parameter;
+import java.util.Collection;
+import java.util.stream.Collectors;
+
+public final class EndsWithHandler {
+    
+    public static final class Impl implements Handler.HandlerParameter<EndsWith, Object, String> {
+
+        @Override
+        public void check(EndsWith annotation, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            if (index == 0) {
+                throw new UnsupportedOperationException("EndsWith annotation cannot be used on first parameter");
+            }
+            if (parameter.getType() != String.class) {
+                throw new UnsupportedOperationException("EndsWith annotation cannot be used on String parameter");
+            }
+        }
+
+        @Override
+        public boolean needsParentTypeMapper() {
+            return true;
+        }
+
+        @Override
+        public AbstractTypeMapper<Object, String> getTypeMapper(EndsWith annotation, Parameter parameter, int index, DataReadable dataReadable, AbstractTypeMapper<Object, String> parentTypeMapper) {
+            String endsWith = annotation.value();
+
+            return new DelegatingMapper<>(parentTypeMapper, annotation) {
+                @Override
+                public Collection<String> tabComplete(Object sender, PreviousArguments previousArguments, String s) {
+                    return super.tabComplete(sender, previousArguments, s).stream().map(s1 -> {
+                        if (s1.startsWith(endsWith)) return s1;
+                        return s1 + endsWith;
+                    }).collect(Collectors.toList());
+                }
+            };
+        }
+
+        @Override
+        public int getValidatorPriority() {
+            return 0;
+        }
+
+        @Override
+        public AbstractTypeValidator<Object, String> getValidator(EndsWith annotation, Parameter parameter, int index, DataReadable dataReadable) {
+            String endsWith = annotation.value();
+            String error = annotation.error();
+            return (sender, value, messageSender) -> {
+                if (value == null) return true;
+                if (value.endsWith(endsWith)) return true;
+                messageSender.send(error);
+                return false;
+            };
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/ErrorMessageHandler.java

@@ -0,0 +1,60 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.AbstractTypeValidator;
+import de.steamwar.command.Handler;
+import de.steamwar.command.annotations.ErrorMessage;
+
+import java.lang.reflect.Array;
+import java.lang.reflect.Parameter;
+
+public final class ErrorMessageHandler {
+
+    public static final class Impl implements Handler.HandlerParameter<ErrorMessage, Object, Object> {
+
+        @Override
+        public void check(ErrorMessage errorMessage, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            if (index == 0) {
+                throw new UnsupportedOperationException("ErrorMessage annotation cannot be used on first parameter");
+            }
+            if (!errorMessage.allowEAs() && !(parameter.isVarArgs() || parameter.getType().isArray())) {
+                throw new UnsupportedOperationException("ErrorMessage allowESs cannot be used on non array or varargs parameter");
+            }
+        }
+
+        @Override
+        public int getValidatorPriority() {
+            return Integer.MAX_VALUE;
+        }
+
+        @Override
+        public AbstractTypeValidator<Object, Object> getValidator(ErrorMessage errorMessage, Parameter parameter, int index, DataReadable dataReadable) {
+            return (sender, value, messageSender) -> {
+                if (value == null) messageSender.send(errorMessage.value());
+                if (!errorMessage.allowEAs() && value != null && value.getClass().isArray() && Array.getLength(value) == 0) {
+                    messageSender.send(errorMessage.value());
+                    return false;
+                }
+                return value != null;
+            };
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/GreedyHandler.java

@@ -0,0 +1,53 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.annotations.Greedy;
+
+import java.lang.reflect.Parameter;
+
+/**
+ * This special Handler is just for validating the Greedy annotation.
+ */
+public final class GreedyHandler {
+
+    public static boolean isGreedy(Parameter parameter) {
+        return parameter.isAnnotationPresent(Greedy.class);
+    }
+
+    public static int getBackTrackingDepth(Parameter parameter) {
+        Greedy greedy = parameter.getAnnotation(Greedy.class);
+        if (greedy == null || parameter.isVarArgs()) {
+            return 0;
+        }
+        return greedy.backTrackingDepth();
+    }
+    
+    public static final class Impl implements Handler.HandlerParameter<Greedy, Object, Object> {
+
+        @Override
+        public void check(Greedy annotation, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            if (!parameter.getType().isArray() || parameter.isVarArgs()) {
+                throw new UnsupportedOperationException("Greedy annotation cannot be used on non array parameters");
+            }
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/LengthHandler.java

@@ -0,0 +1,76 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.Handler;
+import de.steamwar.command.PreviousArguments;
+import de.steamwar.command.annotations.Length;
+import de.steamwar.command.mapper.internal.DelegatingMapper;
+
+import java.lang.reflect.Parameter;
+import java.util.Collection;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public final class LengthHandler {
+    
+    public static final class Impl implements Handler.HandlerParameter<Length, Object, Object> {
+
+        @Override
+        public void check(Length annotation, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            if (index == 0) {
+                throw new UnsupportedOperationException("Length annotation cannot be used on first parameter");
+            }
+        }
+
+        @Override
+        public boolean needsParentTypeMapper() {
+            return true;
+        }
+
+        @Override
+        public AbstractTypeMapper<Object, Object> getTypeMapper(Length length, Parameter parameter, int index, DataReadable dataReadable, AbstractTypeMapper<Object, Object> parentTypeMapper) {
+            int min = length.min();
+            int max = length.max();
+
+            return new DelegatingMapper<>(parentTypeMapper, length) {
+                @Override
+                public Object map(Object sender, PreviousArguments previousArguments, String s) {
+                    if (s.length() < min || s.length() > max) return null;
+                    return delegate.map(sender, previousArguments, s);
+                }
+
+                @Override
+                public Collection<String> tabComplete(Object sender, PreviousArguments previousArguments, String s) {
+                    List<String> tabCompletes = delegate.tabComplete(sender, previousArguments, s)
+                            .stream()
+                            .filter(str -> str.length() >= min)
+                            .map(str -> str.substring(0, Math.min(str.length(), max)))
+                            .collect(Collectors.toList());
+                    if (s.length() < min) {
+                        tabCompletes.add(0, s);
+                    }
+                    return tabCompletes;
+                }
+            };
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/MapperHandler.java

@@ -0,0 +1,96 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.Handler;
+import de.steamwar.command.annotations.Mapper;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.util.Optional;
+
+public final class MapperHandler {
+    
+    public static final class Impl implements Handler.HandlerMethod<Mapper>, Handler.HandlerParameter<Mapper, Object, Object> {
+
+        @Override
+        public void check(Mapper annotation, Method method, DataCheckable dataCheckable) throws Exception {
+            if (method.getParameterCount() != 0) {
+                throw new UnsupportedOperationException("Mapper method must have no parameters");
+            }
+            if (!AbstractTypeMapper.class.isAssignableFrom(method.getReturnType())) {
+                throw new UnsupportedOperationException("Mapper method must return AbstractTypeMapper");
+            }
+
+            if (annotation.value() != null && !annotation.value().isEmpty()) {
+                return;
+            }
+
+            Optional<Class<?>> genericType = getGenericTypeOfReturn(method);
+            if (annotation.type() == void.class) {
+                if (genericType.isEmpty()) {
+                    throw new UnsupportedOperationException("Please supply a class type to the Mapper");
+                }
+            } else {
+                if (genericType.isPresent() && !annotation.type().isAssignableFrom(genericType.get())) {
+                    throw new UnsupportedOperationException("Supplied type does not conform to actual type");
+                }
+            }
+        }
+
+        @Override
+        public int getRunPriority() {
+            return Integer.MIN_VALUE;
+        }
+
+        @Override
+        public void run(Mapper annotation, Method method, DataWritable dataWritable) {
+            AbstractTypeMapper abstractTypeMapper = dataWritable.invoke(method);
+            if (annotation.value() != null && !annotation.value().isEmpty()) {
+                dataWritable.addMapper(annotation.value(), annotation.local(), abstractTypeMapper);
+            } else {
+                Class<?> type = annotation.type();
+                if (type == void.class) type = getGenericTypeOfReturn(method).get();
+                dataWritable.addMapper(type.getName(), annotation.local(), abstractTypeMapper);
+            }
+        }
+
+        @Override
+        public void check(Mapper annotation, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            if (index == 0) {
+                throw new UnsupportedOperationException("Mapper annotation cannot be used on first parameter");
+            }
+            if (!dataCheckable.hasMapper(annotation.value())) {
+                throw new UnsupportedOperationException("Mapper '" + annotation.value() + "' not found");
+            }
+        }
+
+        @Override
+        public AbstractTypeMapper<Object, Object> getTypeMapper(Mapper annotation, Parameter parameter, int index, DataReadable dataReadable, AbstractTypeMapper<Object, Object> parentTypeMapper) {
+            String s = annotation.value();
+            AbstractTypeMapper<Object, Object> abstractTypeMapper = dataReadable.getMapper(s);
+            if (abstractTypeMapper == null) {
+                throw new IllegalArgumentException("No mapper found for " + s);
+            }
+            return abstractTypeMapper;
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/MaxHandler.java

@@ -0,0 +1,172 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.*;
+import de.steamwar.command.annotations.Max;
+import de.steamwar.command.annotations.Min;
+import de.steamwar.command.mapper.internal.DelegatingMapper;
+
+import java.lang.reflect.Parameter;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.function.ToIntFunction;
+
+public final class MaxHandler {
+    
+    public static final class Impl implements Handler.HandlerParameter<Max, Object, Number> {
+
+        @Override
+        public void check(Max max, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            if (index == 0) {
+                throw new UnsupportedOperationException("Max annotation cannot be used on first parameter");
+            }
+            Class<?> type = parameter.getType();
+            if (parameter.isVarArgs()) type = type.getComponentType();
+
+            if (type != int.class && type != Integer.class && type != long.class && type != Long.class && type != float.class && type != Float.class && type != double.class && type != Double.class) {
+                throw new UnsupportedOperationException("Parameter " + index + " of " + parameter.getDeclaringExecutable() + " is not a number.");
+            }
+
+            if (!parameter.isAnnotationPresent(Min.class)) {
+                return;
+            }
+
+            Min min = parameter.getAnnotation(Min.class);
+
+            Number minValue;
+            if (type.equals(int.class) || type.equals(Integer.class)) {
+                minValue = min.intValue();
+            } else if (type.equals(long.class) || type.equals(Long.class)) {
+                minValue = min.longValue();
+            } else if (type.equals(float.class) || type.equals(Float.class)) {
+                minValue = min.floatValue();
+            } else if (type.equals(double.class) || type.equals(Double.class)) {
+                minValue = min.doubleValue();
+            } else {
+                throw new SecurityException();
+            }
+
+            ToIntFunction<Number> maxComparator = CommandUtils.createComparator("Max", type, max.intValue(), max.longValue(), max.floatValue(), max.doubleValue());
+            if (!(min.inclusive() && max.inclusive()) && maxComparator.applyAsInt(minValue) == 0) {
+                throw new UnsupportedOperationException("Min and Max cannot be equal if not both are inclusive");
+            } else if (maxComparator.applyAsInt(minValue) > 0) {
+                throw new UnsupportedOperationException("Max must be bigger then Min");
+            }
+        }
+
+        @Override
+        public boolean needsParentTypeMapper() {
+            return true;
+        }
+
+        @Override
+        public AbstractTypeMapper<Object, Number> getTypeMapper(Max max, Parameter parameter, int index, DataReadable dataReadable, AbstractTypeMapper<Object, Number> parentTypeMapper) {
+            Class<?> type = parameter.getType();
+            if (parameter.isVarArgs()) type = type.getComponentType();
+
+            int compareValue = max.inclusive() ? 0 : -1;
+            ToIntFunction<Number> comparator = CommandUtils.createComparator("Max", type, max.intValue(), max.longValue(), max.floatValue(), max.doubleValue());
+            boolean onlyNegative = comparator.applyAsInt(0) >= 0;
+
+            Min min = parameter.getAnnotation(Min.class);
+
+            Number minValue;
+            Number maxValue;
+            if (type.equals(int.class) || type.equals(Integer.class)) {
+                minValue = min != null ? min.intValue() : null;
+                maxValue = max.intValue();
+            } else if (type.equals(long.class) || type.equals(Long.class)) {
+                minValue = min != null ? min.longValue() : null;
+                maxValue = max.longValue();
+            } else if (type.equals(float.class) || type.equals(Float.class)) {
+                minValue = min != null ? min.floatValue() : null;
+                maxValue = max.floatValue();
+            } else if (type.equals(double.class) || type.equals(Double.class)) {
+                minValue = min != null ? min.doubleValue() : null;
+                maxValue = max.doubleValue();
+            } else {
+                throw new SecurityException();
+            }
+
+            return new DelegatingMapper<>(parentTypeMapper, max) {
+                @Override
+                public Collection<String> tabComplete(Object sender, PreviousArguments previousArguments, String s) {
+                    Collection<String> tabCompletions = new ArrayList<>(super.tabComplete(sender, previousArguments, s));
+                    tabCompletions.removeIf(tabCompletion -> {
+                        if (onlyNegative && !tabCompletion.startsWith("-")) return true;
+                        Number value = super.map(sender, previousArguments, tabCompletion);
+                        if (value == null) {
+                            return false;
+                        }
+                        return comparator.applyAsInt(value) > compareValue;
+                    });
+                    if (tabCompletions.isEmpty()) {
+                        if (minValue != null && min.inclusive()) {
+                            tabCompletions.add(minValue.toString());
+                        }
+                        if (max.inclusive()) {
+                            tabCompletions.add(maxValue.toString());
+                        }
+                    }
+                    return tabCompletions;
+                }
+            };
+        }
+
+        @Override
+        public int getValidatorPriority() {
+            return 2;
+        }
+
+        @Override
+        public AbstractTypeValidator<Object, Number> getValidator(Max max, Parameter parameter, int index, DataReadable dataReadable) {
+            Class<?> type = parameter.getType();
+            if (parameter.isVarArgs()) type = type.getComponentType();
+
+            Number maxValue;
+            if (type.equals(int.class) || type.equals(Integer.class)) {
+                maxValue = max.intValue();
+            } else if (type.equals(long.class) || type.equals(Long.class)) {
+                maxValue = max.longValue();
+            } else if (type.equals(float.class) || type.equals(Float.class)) {
+                maxValue = max.floatValue();
+            } else if (type.equals(double.class) || type.equals(Double.class)) {
+                maxValue = max.doubleValue();
+            } else {
+                throw new SecurityException();
+            }
+
+            int compareValue = max.inclusive() ? 0 : -1;
+            ToIntFunction<Number> comparator = CommandUtils.createComparator("Max", type, max.intValue(), max.longValue(), max.floatValue(), max.doubleValue());
+
+            return (sender, value, messageSender) -> {
+                if (value == null) return true;
+                if (comparator.applyAsInt(value) <= compareValue) {
+                    return true;
+                } else {
+                    String error = max.error();
+                    if (error != null && !error.isEmpty()) messageSender.send(error, value, maxValue);
+                    return false;
+                }
+            };
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/MaxReferenceHandler.java

@@ -0,0 +1,143 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2024  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.*;
+import de.steamwar.command.annotations.Max;
+import de.steamwar.command.annotations.Name;
+import de.steamwar.command.graph.NodeData;
+import de.steamwar.command.mapper.internal.DelegatingMapper;
+
+import java.lang.reflect.Parameter;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.function.ToIntFunction;
+
+public final class MaxReferenceHandler {
+
+    public static final class Impl implements Handler.HandlerParameter<Max.Reference, Object, Number> {
+
+        @Override
+        public void check(Max.Reference annotation, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            if (index == 0) {
+                throw new UnsupportedOperationException("Max.Reference annotation cannot be used on first parameter");
+            }
+
+            Class<?> type = parameter.getType();
+            if (type.isArray()) type = type.getComponentType();
+            if (type != int.class && type != Integer.class && type != long.class && type != Long.class && type != float.class && type != Float.class && type != double.class && type != Double.class) {
+                throw new UnsupportedOperationException("Parameter " + index + " of " + parameter.getDeclaringExecutable() + " is not a number.");
+            }
+
+            Parameter[] parameters = parameter.getDeclaringExecutable().getParameters();
+            for (int i = index - 1; i >= 1; i--) {
+                Parameter toCheck = parameters[i];
+                Name name = toCheck.getAnnotation(Name.class);
+                String parameterName;
+                if (name == null) {
+                    parameterName = toCheck.getName();
+                } else {
+                    parameterName = name.value();
+                }
+                if (!parameterName.equals(annotation.value())) {
+                    continue;
+                }
+                Class<?> parameterType = toCheck.getType();
+                if (!type.isAssignableFrom(parameterType)) {
+                    throw new UnsupportedOperationException("Parameter type being referenced cannot be assigned here!");
+                } else {
+                    return;
+                }
+            }
+            throw new UnsupportedOperationException("Parameter with name '" + annotation.value() + "' does not exist.");
+        }
+
+        @Override
+        public boolean needsParentTypeMapper() {
+            return true;
+        }
+
+        @Override
+        public AbstractTypeMapper<Object, Number> getTypeMapper(Max.Reference maxReference, Parameter parameter, int index, DataReadable dataReadable, AbstractTypeMapper<Object, Number> parentTypeMapper) {
+            Class<?> type = parameter.getType();
+            if (type.isArray()) type = type.getComponentType();
+            Class<?> finalType = type;
+
+            String name = maxReference.value();
+            int compareValue = maxReference.inclusive() ? 0 : -1;
+
+            return new DelegatingMapper<>(parentTypeMapper, maxReference) {
+                @Override
+                public Collection<String> tabComplete(Object sender, PreviousArguments previousArguments, String s) {
+                    Number number = previousArguments.getByName(name);
+                    if (number == null) return Collections.emptyList();
+
+                    ToIntFunction<Number> comparator = CommandUtils.createComparator("Max.Reference", finalType, number.intValue(), number.longValue(), number.floatValue(), number.doubleValue());
+                    boolean onlyNegative = comparator.applyAsInt(0) >= 0;
+
+                    Collection<String> tabCompletions = new ArrayList<>(super.tabComplete(sender, previousArguments, s));
+                    tabCompletions.removeIf(tabCompletion -> {
+                        if (onlyNegative && !tabCompletion.startsWith("-")) return true;
+                        Number value = super.map(sender, previousArguments, tabCompletion);
+                        if (value == null) {
+                            return false;
+                        }
+                        return comparator.applyAsInt(value) > compareValue;
+                    });
+                    if (tabCompletions.isEmpty() && maxReference.inclusive()) {
+                        tabCompletions.add(number + "");
+                    }
+                    return tabCompletions;
+                }
+            };
+        }
+
+        @Override
+        public int getValidatorPriority() {
+            return 2;
+        }
+
+        @Override
+        public AbstractTypeValidator<Object, Number> getValidator(Max.Reference maxReference, Parameter parameter, int index, DataReadable dataReadable) {
+            Class<?> type = parameter.getType();
+            if (type.isArray()) type = type.getComponentType();
+            Class<?> finalType = type;
+
+            String name = maxReference.value();
+            int compareValue = maxReference.inclusive() ? 0 : -1;
+
+            return (sender, value, messageSender) -> {
+                Number number = (Number)((NodeData) messageSender).getByName(name);
+                if (number == null) return false;
+
+                ToIntFunction<Number> comparator = CommandUtils.createComparator("Max.Reference", finalType, number.intValue(), number.longValue(), number.floatValue(), number.doubleValue());
+                if (value == null) return true;
+                if (comparator.applyAsInt(value) <= compareValue) {
+                    return true;
+                } else {
+                    String error = maxReference.error();
+                    if (error != null && !error.isEmpty()) messageSender.send(error, value, number);
+                    return false;
+                }
+            };
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/MinHandler.java

@@ -0,0 +1,147 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.*;
+import de.steamwar.command.annotations.Max;
+import de.steamwar.command.annotations.Min;
+import de.steamwar.command.mapper.internal.DelegatingMapper;
+
+import java.lang.reflect.Parameter;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.function.ToIntFunction;
+
+public final class MinHandler {
+    
+    public static final class Impl implements Handler.HandlerParameter<Min, Object, Number> {
+
+        @Override
+        public void check(Min min, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            if (index == 0) {
+                throw new UnsupportedOperationException("Min annotation cannot be used on first parameter");
+            }
+            Class<?> type = parameter.getType();
+            if (parameter.isVarArgs()) type = type.getComponentType();
+            if (type == int.class || type == Integer.class) return;
+            if (type == long.class || type == Long.class) return;
+            if (type == float.class || type == Float.class) return;
+            if (type == double.class || type == Double.class) return;
+            throw new UnsupportedOperationException("Parameter " + index + " of " + parameter.getDeclaringExecutable() + " is not a number.");
+        }
+
+        @Override
+        public boolean needsParentTypeMapper() {
+            return true;
+        }
+
+        @Override
+        public AbstractTypeMapper<Object, Number> getTypeMapper(Min min, Parameter parameter, int index, DataReadable dataReadable, AbstractTypeMapper<Object, Number> parentTypeMapper) {
+            Class<?> type = parameter.getType();
+            if (parameter.isVarArgs()) type = type.getComponentType();
+
+            int compareValue = min.inclusive() ? 0 : 1;
+            ToIntFunction<Number> comparator = CommandUtils.createComparator("Min", type, min.intValue(), min.longValue(), min.floatValue(), min.doubleValue());
+            boolean onlyPositive = comparator.applyAsInt(0) < 0;
+
+            Max max = parameter.getAnnotation(Max.class);
+
+            Number minValue;
+            Number maxValue;
+            if (type.equals(int.class) || type.equals(Integer.class)) {
+                minValue = min.intValue();
+                maxValue = max != null ? max.intValue() : null;
+            } else if (type.equals(long.class) || type.equals(Long.class)) {
+                minValue = min.longValue();
+                maxValue = max != null ? max.longValue() : null;
+            } else if (type.equals(float.class) || type.equals(Float.class)) {
+                minValue = min.floatValue();
+                maxValue = max != null ? max.floatValue() : null;
+            } else if (type.equals(double.class) || type.equals(Double.class)) {
+                minValue = min.doubleValue();
+                maxValue = max != null ? max.doubleValue() : null;
+            } else {
+                throw new SecurityException();
+            }
+
+            return new DelegatingMapper<>(parentTypeMapper, min) {
+                @Override
+                public Collection<String> tabComplete(Object sender, PreviousArguments previousArguments, String s) {
+                    Collection<String> tabCompletions = new ArrayList<>(super.tabComplete(sender, previousArguments, s));
+                    tabCompletions.removeIf(tabCompletion -> {
+                        if (onlyPositive && tabCompletion.startsWith("-")) return true;
+                        Number value = super.map(sender, previousArguments, tabCompletion);
+                        if (value == null) {
+                            return false;
+                        }
+                        return comparator.applyAsInt(value) < compareValue;
+                    });
+                    if (tabCompletions.isEmpty()) {
+                        if (min.inclusive()) {
+                            tabCompletions.add(minValue.toString());
+                        }
+                        if (maxValue != null && max.inclusive()) {
+                            tabCompletions.add(maxValue.toString());
+                        }
+                    }
+                    return tabCompletions;
+                }
+            };
+        }
+
+        @Override
+        public int getValidatorPriority() {
+            return 2;
+        }
+
+        @Override
+        public AbstractTypeValidator<Object, Number> getValidator(Min min, Parameter parameter, int index, DataReadable dataReadable) {
+            Class<?> type = parameter.getType();
+            if (parameter.isVarArgs()) type = type.getComponentType();
+
+            Number minValue;
+            if (type.equals(int.class) || type.equals(Integer.class)) {
+                minValue = min.intValue();
+            } else if (type.equals(long.class) || type.equals(Long.class)) {
+                minValue = min.longValue();
+            } else if (type.equals(float.class) || type.equals(Float.class)) {
+                minValue = min.floatValue();
+            } else if (type.equals(double.class) || type.equals(Double.class)) {
+                minValue = min.doubleValue();
+            } else {
+                throw new SecurityException();
+            }
+
+            int compareValue = min.inclusive() ? 0 : 1;
+            ToIntFunction<Number> comparator = CommandUtils.createComparator("Min", type, min.intValue(), min.longValue(), min.floatValue(), min.doubleValue());
+
+            return (sender, value, messageSender) -> {
+                if (value == null) return true;
+                if (comparator.applyAsInt(value) >= compareValue) {
+                    return true;
+                } else {
+                    String error = min.error();
+                    if (error != null && !error.isEmpty()) messageSender.send(error, value, minValue);
+                    return false;
+                }
+            };
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/MinReferenceHandler.java

@@ -0,0 +1,143 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2024  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.*;
+import de.steamwar.command.annotations.Min;
+import de.steamwar.command.annotations.Name;
+import de.steamwar.command.graph.NodeData;
+import de.steamwar.command.mapper.internal.DelegatingMapper;
+
+import java.lang.reflect.Parameter;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.function.ToIntFunction;
+
+public final class MinReferenceHandler {
+
+    public static final class Impl implements Handler.HandlerParameter<Min.Reference, Object, Number> {
+
+        @Override
+        public void check(Min.Reference annotation, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            if (index == 0) {
+                throw new UnsupportedOperationException("Min.Reference annotation cannot be used on first parameter");
+            }
+
+            Class<?> type = parameter.getType();
+            if (type.isArray()) type = type.getComponentType();
+            if (type != int.class && type != Integer.class && type != long.class && type != Long.class && type != float.class && type != Float.class && type != double.class && type != Double.class) {
+                throw new UnsupportedOperationException("Parameter " + index + " of " + parameter.getDeclaringExecutable() + " is not a number.");
+            }
+
+            Parameter[] parameters = parameter.getDeclaringExecutable().getParameters();
+            for (int i = index - 1; i >= 1; i--) {
+                Parameter toCheck = parameters[i];
+                Name name = toCheck.getAnnotation(Name.class);
+                String parameterName;
+                if (name == null) {
+                    parameterName = toCheck.getName();
+                } else {
+                    parameterName = name.value();
+                }
+                if (!parameterName.equals(annotation.value())) {
+                    continue;
+                }
+                Class<?> parameterType = toCheck.getType();
+                if (!type.isAssignableFrom(parameterType)) {
+                    throw new UnsupportedOperationException("Parameter type being referenced cannot be assigned here!");
+                } else {
+                    return;
+                }
+            }
+            throw new UnsupportedOperationException("Parameter with name '" + annotation.value() + "' does not exist.");
+        }
+
+        @Override
+        public boolean needsParentTypeMapper() {
+            return true;
+        }
+
+        @Override
+        public AbstractTypeMapper<Object, Number> getTypeMapper(Min.Reference minReference, Parameter parameter, int index, DataReadable dataReadable, AbstractTypeMapper<Object, Number> parentTypeMapper) {
+            Class<?> type = parameter.getType();
+            if (type.isArray()) type = type.getComponentType();
+            Class<?> finalType = type;
+
+            String name = minReference.value();
+            int compareValue = minReference.inclusive() ? 0 : 1;
+
+            return new DelegatingMapper<>(parentTypeMapper, minReference) {
+                @Override
+                public Collection<String> tabComplete(Object sender, PreviousArguments previousArguments, String s) {
+                    Number number = previousArguments.getByName(name);
+                    if (number == null) return Collections.emptyList();
+
+                    ToIntFunction<Number> comparator = CommandUtils.createComparator("Min.Reference", finalType, number.intValue(), number.longValue(), number.floatValue(), number.doubleValue());
+                    boolean onlyPositive = comparator.applyAsInt(0) < 0;
+
+                    Collection<String> tabCompletions = new ArrayList<>(super.tabComplete(sender, previousArguments, s));
+                    tabCompletions.removeIf(tabCompletion -> {
+                        if (onlyPositive && tabCompletion.startsWith("-")) return true;
+                        Number value = super.map(sender, previousArguments, tabCompletion);
+                        if (value == null) {
+                            return false;
+                        }
+                        return comparator.applyAsInt(value) < compareValue;
+                    });
+                    if (tabCompletions.isEmpty() && minReference.inclusive()) {
+                        tabCompletions.add(number + "");
+                    }
+                    return tabCompletions;
+                }
+            };
+        }
+
+        @Override
+        public int getValidatorPriority() {
+            return 2;
+        }
+
+        @Override
+        public AbstractTypeValidator<Object, Number> getValidator(Min.Reference minReference, Parameter parameter, int index, DataReadable dataReadable) {
+            Class<?> type = parameter.getType();
+            if (type.isArray()) type = type.getComponentType();
+            Class<?> finalType = type;
+
+            String name = minReference.value();
+            int compareValue = minReference.inclusive() ? 0 : 1;
+
+            return (sender, value, messageSender) -> {
+                Number number = (Number)((NodeData) messageSender).getByName(name);
+                if (number == null) return false;
+
+                ToIntFunction<Number> comparator = CommandUtils.createComparator("Min.Reference", finalType, number.intValue(), number.longValue(), number.floatValue(), number.doubleValue());
+                if (value == null) return true;
+                if (comparator.applyAsInt(value) >= compareValue) {
+                    return true;
+                } else {
+                    String error = minReference.error();
+                    if (error != null && !error.isEmpty()) messageSender.send(error, value, number);
+                    return false;
+                }
+            };
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/OptionalValueHandler.java

@@ -0,0 +1,80 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.Handler;
+import de.steamwar.command.PreviousArguments;
+import de.steamwar.command.annotations.OptionalValue;
+import de.steamwar.command.mapper.internal.DelegatingMapper;
+
+import java.lang.reflect.Parameter;
+
+/**
+ * This special Handler is just for validating the OptionalValue annotation.
+ */
+public final class OptionalValueHandler {
+    
+    public static final class Impl implements Handler.HandlerParameter<OptionalValue, Object, Object> {
+
+        @Override
+        public void check(OptionalValue annotation, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            if (index == 0) {
+                throw new UnsupportedOperationException("OptionalValue annotation cannot be used on the first parameter");
+            }
+            if (parameter.isVarArgs() || parameter.getType().isArray()) {
+                throw new UnsupportedOperationException("OptionalValue annotation cannot be used on varargs or array parameters");
+            }
+        }
+
+        @Override
+        public boolean needsParentTypeMapper() {
+            return true;
+        }
+
+        @Override
+        public AbstractTypeMapper<Object, Object> getTypeMapper(OptionalValue annotation, Parameter parameter, int index, DataReadable dataReadable, AbstractTypeMapper<Object, Object> parentTypeMapper) {
+            String defaultValue = annotation.value();
+            boolean onlyUseIfNoneIsGiven = annotation.onlyUINIG();
+
+            return new DelegatingMapper<>(parentTypeMapper, annotation) {
+                @Override
+                public Object map(Object sender, PreviousArguments previousArguments, String s) {
+                    if (s != null) {
+                        Object value = delegate.map(sender, previousArguments, s);
+                        if (value != null) {
+                            return value;
+                        }
+                    }
+                    if (previousArguments.hasMoreArguments && onlyUseIfNoneIsGiven) {
+                        return null;
+                    }
+                    previousArguments.usedOptionalValue();
+                    return delegate.map(sender, previousArguments, defaultValue);
+                }
+
+                @Override
+                public boolean appendNextElementTabCompletions() {
+                    return !onlyUseIfNoneIsGiven;
+                }
+            };
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/RegexHandler.java

@@ -0,0 +1,60 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.AbstractTypeValidator;
+import de.steamwar.command.Handler;
+import de.steamwar.command.annotations.Regex;
+
+import java.lang.reflect.Parameter;
+import java.util.regex.Pattern;
+
+public final class RegexHandler {
+    
+    public static final class Impl implements Handler.HandlerParameter<Regex, Object, String> {
+
+        @Override
+        public void check(Regex annotation, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            if (index == 0) {
+                throw new UnsupportedOperationException("Regex annotation cannot be used on first parameter");
+            }
+            if (parameter.getType() != String.class) {
+                throw new UnsupportedOperationException("Regex annotation cannot be used on String parameter");
+            }
+        }
+
+        @Override
+        public int getValidatorPriority() {
+            return 0;
+        }
+
+        @Override
+        public AbstractTypeValidator<Object, String> getValidator(Regex annotation, Parameter parameter, int index, DataReadable dataReadable) {
+            Pattern regex = Pattern.compile(annotation.value());
+            String error = annotation.error();
+            return (sender, value, messageSender) -> {
+                if (value == null) return true;
+                if (regex.matcher(value).matches()) return true;
+                messageSender.send(error);
+                return false;
+            };
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/RegisterHandler.java

@@ -0,0 +1,97 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.CommandUtils;
+import de.steamwar.command.Handler;
+import de.steamwar.command.annotations.Register;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.util.List;
+
+public final class RegisterHandler {
+    
+    public static final class Impl implements Handler.HandlerMethod<Register> {
+
+        @Override
+        public void check(de.steamwar.command.annotations.Register annotation, Method method, DataCheckable dataCheckable) throws Exception {
+            if (method.getParameterCount() == 0) {
+                throw new UnsupportedOperationException("Register method must have at least one parameter");
+            }
+            if (method.getReturnType() != void.class) {
+                throw new UnsupportedOperationException("Register method must return void");
+            }
+            if (!dataCheckable.hasExecutorMapper(method.getParameterTypes()[0])) {
+                throw new UnsupportedOperationException("Register method first parameter must have a executor mapper registered");
+            }
+
+            Parameter[] parameters = method.getParameters();
+            for (int i = 0; i < parameters.length; i++) {
+                Parameter parameter = parameters[i];
+                List<Annotation> annotationList = CommandUtils.getAnnotations(parameter);
+                if (annotationList.isEmpty()) {
+                    if (i == 0) {
+                        continue;
+                    }
+
+                    Class<?> type = parameter.getType();
+                    if (type.isArray()) {
+                        type = type.getComponentType();
+                    }
+                    if (!type.isEnum() && !dataCheckable.hasMapper(type.getName())) {
+                        throw new UnsupportedOperationException("Register method parameter " + parameter.getName() + " must be annotated or have a type mapper");
+                    }
+                } else {
+                    for (Annotation annotation1 : annotationList) {
+                        getParameterHandler(annotation1).check(annotation1, parameter, i, dataCheckable);
+                    }
+                }
+            }
+        }
+
+        public static HandlerParameter getParameterHandler(Annotation annotation) {
+            Implementation handler = annotation.annotationType().getAnnotation(Implementation.class);
+            Handler handlerObject;
+            try {
+                handlerObject = handler.value().getConstructor().newInstance();
+            } catch (NoSuchMethodException | InstantiationException | IllegalAccessException |
+                     InvocationTargetException e) {
+                throw new UnsupportedOperationException("Handler " + handler.value().getName() + " cannot be used to check the argument validity", e);
+            }
+            if (!(handlerObject instanceof HandlerParameter)) {
+                throw new UnsupportedOperationException("Handler " + handlerObject.getClass().getName() + " is not a HandlerParameter");
+            }
+            return (HandlerParameter) handlerObject;
+        }
+
+        @Override
+        public int getRunPriority() {
+            return Integer.MAX_VALUE;
+        }
+
+        @Override
+        public void run(de.steamwar.command.annotations.Register annotation, Method method, DataWritable dataWritable) {
+            dataWritable.addCommand(method, annotation.value(), annotation.description(), annotation.noTabComplete());
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/StartsWithHandler.java

@@ -0,0 +1,84 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.AbstractTypeValidator;
+import de.steamwar.command.Handler;
+import de.steamwar.command.PreviousArguments;
+import de.steamwar.command.annotations.StartsWith;
+import de.steamwar.command.mapper.internal.DelegatingMapper;
+
+import java.lang.reflect.Parameter;
+import java.util.Collection;
+import java.util.stream.Collectors;
+
+public final class StartsWithHandler {
+    
+    public static final class Impl implements Handler.HandlerParameter<StartsWith, Object, String> {
+
+        @Override
+        public void check(StartsWith annotation, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            if (index == 0) {
+                throw new UnsupportedOperationException("StartsWith annotation cannot be used on first parameter");
+            }
+            if (parameter.getType() != String.class) {
+                throw new UnsupportedOperationException("StartsWith annotation cannot be used on String parameter");
+            }
+        }
+
+        @Override
+        public boolean needsParentTypeMapper() {
+            return true;
+        }
+
+        @Override
+        public AbstractTypeMapper<Object, String> getTypeMapper(StartsWith annotation, Parameter parameter, int index, DataReadable dataReadable, AbstractTypeMapper<Object, String> parentTypeMapper) {
+            String startsWith = annotation.value();
+
+            return new DelegatingMapper<>(parentTypeMapper, annotation) {
+                @Override
+                public Collection<String> tabComplete(Object sender, PreviousArguments previousArguments, String s) {
+                    return super.tabComplete(sender, previousArguments, s).stream().map(s1 -> {
+                        if (s1.startsWith(startsWith)) return s1;
+                        return startsWith + s1;
+                    }).collect(Collectors.toList());
+                }
+            };
+        }
+
+        @Override
+        public int getValidatorPriority() {
+            return 0;
+        }
+
+        @Override
+        public AbstractTypeValidator<Object, String> getValidator(StartsWith annotation, Parameter parameter, int index, DataReadable dataReadable) {
+            String startsWith = annotation.value();
+            String error = annotation.error();
+            return (sender, value, messageSender) -> {
+                if (value == null) return true;
+                if (value.startsWith(startsWith)) return true;
+                messageSender.send(error);
+                return false;
+            };
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/StaticValueHandler.java

@@ -0,0 +1,105 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.Handler;
+import de.steamwar.command.PreviousArguments;
+import de.steamwar.command.annotations.StaticValue;
+import de.steamwar.command.mapper.SimpleMapper;
+
+import java.lang.reflect.Parameter;
+import java.util.*;
+
+@Deprecated
+public final class StaticValueHandler {
+    
+    public static final class Impl implements Handler.HandlerParameter<StaticValue, Object, Object> {
+
+        @Override
+        public void check(StaticValue annotation, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            if (index == 0) {
+                throw new UnsupportedOperationException("StaticValue annotation cannot be used on first parameter");
+            }
+            Class<?> type = parameter.getType();
+            if (type == String.class) return;
+            if (type == int.class || type == Integer.class) return;
+            if (type == long.class || type == Long.class) return;
+            if (type == boolean.class || type == Boolean.class) return;
+            throw new UnsupportedOperationException("StaticValue parameter must be String, int, long or boolean");
+        }
+
+        @Override
+        public AbstractTypeMapper<Object, Object> getTypeMapper(StaticValue annotation, Parameter parameter, int index, DataReadable dataReadable, AbstractTypeMapper<Object, Object> parentTypeMapper) {
+            Class<?> type = parameter.getType();
+            if (type == String.class) {
+                return (AbstractTypeMapper) new SimpleMapper(annotation.value());
+            }
+
+            List<String> tabCompletes = new ArrayList<>(Arrays.asList(annotation.value()));
+            if (type == boolean.class || type == Boolean.class) {
+                Set<Integer> falseValues = new HashSet<>();
+                for (int i : annotation.falseValues()) {
+                    falseValues.add(i);
+                }
+                return new AbstractTypeMapper<>() {
+                    @Override
+                    public Object map(Object sender, PreviousArguments previousArguments, String s) {
+                        int index = tabCompletes.indexOf(s);
+                        return index == -1 ? null : !falseValues.contains(index);
+                    }
+
+                    @Override
+                    public Collection<String> tabComplete(Object sender, PreviousArguments previousArguments, String s) {
+                        return tabCompletes;
+                    }
+                };
+            }
+
+            if (type == long.class || type == Long.class) {
+                return new AbstractTypeMapper<>() {
+                    @Override
+                    public Object map(Object sender, PreviousArguments previousArguments, String s) {
+                        long index = tabCompletes.indexOf(s);
+                        return index == -1L ? null : index;
+                    }
+
+                    @Override
+                    public Collection<String> tabComplete(Object sender, PreviousArguments previousArguments, String s) {
+                        return tabCompletes;
+                    }
+                };
+            }
+
+            return new AbstractTypeMapper<>() {
+                @Override
+                public Object map(Object sender, PreviousArguments previousArguments, String s) {
+                    int index = tabCompletes.indexOf(s);
+                    return index == -1 ? null : index;
+                }
+
+                @Override
+                public Collection<String> tabComplete(Object sender, PreviousArguments previousArguments, String s) {
+                    return tabCompletes;
+                }
+            };
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/SupplierHandler.java

@@ -0,0 +1,99 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.AbstractTypeSupplier;
+import de.steamwar.command.Handler;
+import de.steamwar.command.annotations.AllowNull;
+import de.steamwar.command.annotations.Name;
+import de.steamwar.command.annotations.Supplier;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.util.Arrays;
+import java.util.Optional;
+
+public final class SupplierHandler {
+
+    public static final class Impl implements Handler.HandlerMethod<Supplier>, Handler.HandlerParameter<Supplier, Object, Object> {
+
+        @Override
+        public void check(Supplier annotation, Method method, DataCheckable dataCheckable) throws Exception {
+            if (method.getParameterCount() != 0) {
+                throw new UnsupportedOperationException("Supplier method must have no parameters");
+            }
+            if (!AbstractTypeMapper.class.isAssignableFrom(method.getReturnType())) {
+                throw new UnsupportedOperationException("Supplier method must return AbstractTypeMapper");
+            }
+
+            if (annotation.value() != null && !annotation.value().isEmpty()) {
+                return;
+            }
+
+            Optional<Class<?>> genericType = getGenericTypeOfReturn(method);
+            if (annotation.type() == void.class) {
+                if (genericType.isEmpty()) {
+                    throw new UnsupportedOperationException("Please supply a class type to the Supplier");
+                }
+            } else {
+                if (genericType.isPresent() && !annotation.type().isAssignableFrom(genericType.get())) {
+                    throw new UnsupportedOperationException("Supplied type does not conform to actual type");
+                }
+            }
+        }
+
+        @Override
+        public int getRunPriority() {
+            return Integer.MIN_VALUE;
+        }
+
+        @Override
+        public void run(Supplier annotation, Method method, DataWritable dataWritable) {
+            AbstractTypeSupplier abstractTypeSupplier = dataWritable.invoke(method);
+            if (annotation.value() != null && !annotation.value().isEmpty()) {
+                dataWritable.addSupplier(annotation.value(), annotation.local(), abstractTypeSupplier);
+            } else {
+                Class<?> type = annotation.type();
+                if (type == void.class) type = getGenericTypeOfReturn(method).get();
+                dataWritable.addSupplier(type.getName(), annotation.local(), abstractTypeSupplier);
+            }
+        }
+
+        @Override
+        public void check(Supplier annotation, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            if (index == 0) {
+                throw new UnsupportedOperationException("Supplier annotation cannot be used on the first parameter");
+            }
+            String s = annotation.value() != null && !annotation.value().isEmpty() ? annotation.value() : parameter.getType().getTypeName();
+            if (!dataCheckable.hasSupplier(s)) {
+                throw new UnsupportedOperationException("Supplier '" + annotation.value() + "' not found");
+            }
+            boolean hasDisallowedAnnotations = Arrays.stream(parameter.getAnnotations())
+                    .filter(anno -> !(anno instanceof Supplier))
+                    .filter(anno -> !(anno instanceof AllowNull))
+                    .filter(anno -> !(anno instanceof Name))
+                    .anyMatch(anno -> anno.getClass().isAnnotationPresent(Implementation.class));
+            if (hasDisallowedAnnotations) {
+                throw new UnsupportedOperationException("Only AllowNull or Name can be used in conjunction with Supplier annotation");
+            }
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/TabFilterHandler.java

@@ -0,0 +1,49 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.annotations.TabFilter;
+import de.steamwar.command.annotations.TabFilterType;
+
+import java.lang.reflect.Parameter;
+
+/**
+ * This special Handler is just for validating the TabFilter annotation.
+ */
+public final class TabFilterHandler {
+
+    public static TabFilterType getTabFilterType(Parameter parameter) {
+        if (!parameter.isAnnotationPresent(TabFilter.class)) {
+            return TabFilterType.STARTS_WITH;
+        }
+        return parameter.getAnnotation(TabFilter.class).value();
+    }
+
+    public static final class Impl implements Handler.HandlerParameter<TabFilter, Object, Object> {
+
+        @Override
+        public void check(TabFilter annotation, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            if (index == 0) {
+                throw new UnsupportedOperationException("TabFilter annotation cannot be used on first parameter");
+            }
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/UniqueHandler.java

@@ -0,0 +1,48 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2024  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.Handler;
+import de.steamwar.command.annotations.Unique;
+
+import java.lang.reflect.Parameter;
+
+/**
+ * This special Handler is just for validating the Unique annotation.
+ */
+public final class UniqueHandler {
+
+    public static boolean isPresent(Parameter parameter) {
+        return parameter.isAnnotationPresent(Unique.class);
+    }
+
+    public static final class Impl implements Handler.HandlerParameter<Unique, Object, Object> {
+
+        @Override
+        public void check(Unique annotation, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            if (index == 0) {
+                throw new UnsupportedOperationException("Unique annotation cannot be used on the first parameter");
+            }
+            if (!parameter.getType().isArray() && !parameter.isVarArgs()) {
+                throw new UnsupportedOperationException("Unique annotation cannot be used on non array types");
+            }
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/ValidatorHandler.java

@@ -0,0 +1,94 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.AbstractTypeValidator;
+import de.steamwar.command.Handler;
+import de.steamwar.command.annotations.Validator;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Parameter;
+import java.util.Optional;
+
+public final class ValidatorHandler {
+    
+    public static final class Impl implements Handler.HandlerMethod<Validator>, Handler.HandlerParameter<Validator, Object, Object> {
+
+        @Override
+        public void check(Validator annotation, Method method, DataCheckable dataCheckable) throws Exception {
+            if (method.getParameterCount() != 0) {
+                throw new UnsupportedOperationException("Validator method must have no parameters");
+            }
+            if (!AbstractTypeValidator.class.isAssignableFrom(method.getReturnType())) {
+                throw new UnsupportedOperationException("Validator method must return AbstractValidator");
+            }
+
+            if (annotation.value() != null && !annotation.value().isEmpty()) {
+                return;
+            }
+
+            Optional<Class<?>> genericType = getGenericTypeOfReturn(method);
+            if (annotation.type() == void.class) {
+                if (genericType.isEmpty()) {
+                    throw new UnsupportedOperationException("Please supply a class type to the Validator");
+                }
+            } else {
+                if (genericType.isPresent() && !annotation.type().isAssignableFrom(genericType.get())) {
+                    throw new UnsupportedOperationException("Supplied type does not conform to actual type");
+                }
+            }
+        }
+
+        @Override
+        public int getRunPriority() {
+            return Integer.MIN_VALUE;
+        }
+
+        @Override
+        public void run(Validator annotation, Method method, DataWritable dataWritable) {
+            AbstractTypeValidator<Object, Object> abstractTypeValidator = dataWritable.invoke(method);
+            if (annotation.value() != null && !annotation.value().isEmpty()) {
+                dataWritable.addValidator(annotation.value(), annotation.local(), abstractTypeValidator);
+            } else {
+                Class<?> type = annotation.type();
+                if (type == void.class) type = getGenericTypeOfReturn(method).get();
+                dataWritable.addValidator(type.getName(), annotation.local(), abstractTypeValidator);
+            }
+        }
+
+        @Override
+        public void check(Validator annotation, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            String s = annotation.value() != null && !annotation.value().isEmpty() ? annotation.value() : parameter.getType().getTypeName();
+            if (!dataCheckable.hasValidator(s)) {
+                throw new UnsupportedOperationException("Validator '" + annotation.value() + "' not found");
+            }
+        }
+
+        @Override
+        public AbstractTypeValidator<Object, Object> getValidator(Validator annotation, Parameter parameter, int index, DataReadable dataReadable) {
+            String s = annotation.value() != null && !annotation.value().isEmpty() ? annotation.value() : parameter.getType().getTypeName();
+            AbstractTypeValidator<Object, Object> abstractTypeValidator = dataReadable.getValidator(s);
+            if (abstractTypeValidator == null) {
+                throw new IllegalArgumentException("No validator found for '" + s + "'");
+            }
+            return annotation.invert() ? abstractTypeValidator.not() : abstractTypeValidator;
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/ValuesHandler.java

@@ -0,0 +1,104 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.Handler;
+import de.steamwar.command.PreviousArguments;
+import de.steamwar.command.annotations.Values;
+import de.steamwar.command.mapper.SimpleMapper;
+
+import java.lang.reflect.Parameter;
+import java.util.*;
+
+public final class ValuesHandler {
+    
+    public static final class Impl implements Handler.HandlerParameter<Values, Object, Object> {
+
+        @Override
+        public void check(Values annotation, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            if (index == 0) {
+                throw new UnsupportedOperationException("Values annotation cannot be used on first parameter");
+            }
+            Class<?> type = parameter.getType();
+            if (type == String.class) return;
+            if (type == int.class || type == Integer.class) return;
+            if (type == long.class || type == Long.class) return;
+            if (type == boolean.class || type == Boolean.class) return;
+            throw new UnsupportedOperationException("Values parameter must be String, int, long or boolean");
+        }
+
+        @Override
+        public AbstractTypeMapper<Object, Object> getTypeMapper(Values annotation, Parameter parameter, int index, DataReadable dataReadable, AbstractTypeMapper<Object, Object> parentTypeMapper) {
+            Class<?> type = parameter.getType();
+            if (type == String.class) {
+                return (AbstractTypeMapper) new SimpleMapper(annotation.value());
+            }
+
+            List<String> tabCompletes = new ArrayList<>(Arrays.asList(annotation.value()));
+            if (type == boolean.class || type == Boolean.class) {
+                Set<Integer> falseValues = new HashSet<>();
+                for (int i : annotation.falseValues()) {
+                    falseValues.add(i);
+                }
+                return new AbstractTypeMapper<>() {
+                    @Override
+                    public Object map(Object sender, PreviousArguments previousArguments, String s) {
+                        int index = tabCompletes.indexOf(s);
+                        return index == -1 ? null : !falseValues.contains(index);
+                    }
+
+                    @Override
+                    public Collection<String> tabComplete(Object sender, PreviousArguments previousArguments, String s) {
+                        return tabCompletes;
+                    }
+                };
+            }
+
+            if (type == long.class || type == Long.class) {
+                return new AbstractTypeMapper<>() {
+                    @Override
+                    public Object map(Object sender, PreviousArguments previousArguments, String s) {
+                        long index = tabCompletes.indexOf(s);
+                        return index == -1L ? null : index;
+                    }
+
+                    @Override
+                    public Collection<String> tabComplete(Object sender, PreviousArguments previousArguments, String s) {
+                        return tabCompletes;
+                    }
+                };
+            }
+
+            return new AbstractTypeMapper<>() {
+                @Override
+                public Object map(Object sender, PreviousArguments previousArguments, String s) {
+                    int index = tabCompletes.indexOf(s);
+                    return index == -1 ? null : index;
+                }
+
+                @Override
+                public Collection<String> tabComplete(Object sender, PreviousArguments previousArguments, String s) {
+                    return tabCompletes;
+                }
+            };
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/handler/ValuesReferenceHandler.java

@@ -0,0 +1,159 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2024  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.handler;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.Handler;
+import de.steamwar.command.PreviousArguments;
+import de.steamwar.command.annotations.Name;
+import de.steamwar.command.annotations.Values;
+import de.steamwar.command.mapper.internal.DelegatingMapper;
+import de.steamwar.command.utils.ClassEquality;
+
+import java.lang.reflect.Parameter;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+
+public class ValuesReferenceHandler {
+
+    public static final class Impl implements Handler.HandlerParameter<Values.Reference, Object, Object> {
+
+        @Override
+        public void check(Values.Reference annotation, Parameter parameter, int index, DataCheckable dataCheckable) throws Exception {
+            if (index == 0) {
+                throw new UnsupportedOperationException("Values.Reference annotation cannot be used on first parameter");
+            }
+
+            Class<?> type = parameter.getType();
+            if (type.isArray()) type = type.getComponentType();
+            if (type != int.class && type != Integer.class && type != long.class && type != Long.class && type != String.class) {
+                throw new UnsupportedOperationException("Parameter " + index + " of " + parameter.getDeclaringExecutable() + " is not a String or Int or Long.");
+            }
+
+            Parameter[] parameters = parameter.getDeclaringExecutable().getParameters();
+            for (int i = index - 1; i >= 1; i--) {
+                Parameter toCheck = parameters[i];
+                Name name = toCheck.getAnnotation(Name.class);
+                String parameterName;
+                if (name == null) {
+                    parameterName = toCheck.getName();
+                } else {
+                    parameterName = name.value();
+                }
+                if (!parameterName.equals(annotation.value())) {
+                    continue;
+                }
+                Class<?> toCheckType = toCheck.getType();
+                if (toCheckType.isArray()) toCheckType = toCheckType.getComponentType();
+                if (!ClassEquality.classEquals(type, toCheckType)) {
+                    throw new UnsupportedOperationException("Parameter type being referenced cannot be assigned here!");
+                } else {
+                    return;
+                }
+            }
+            throw new UnsupportedOperationException("Parameter with name '" + annotation.value() + "' does not exist.");
+        }
+
+        @Override
+        public AbstractTypeMapper<Object, Object> getTypeMapper(Values.Reference annotation, Parameter parameter, int index, DataReadable dataReadable, AbstractTypeMapper<Object, Object> parentTypeMapper) {
+            Class<?> type = parameter.getType();
+            if (type.isArray()) type = type.getComponentType();
+
+            String name = annotation.value();
+
+            AbstractTypeMapper<Object, Object> tabCompleter = new AbstractTypeMapper<>() {
+                @Override
+                public Object map(Object sender, PreviousArguments previousArguments, String s) {
+                    return null; // This is not implemented since the delegators will override it
+                }
+
+                @Override
+                public Collection<String> tabComplete(Object sender, PreviousArguments previousArguments, String s) {
+                    Object valueOrValues = previousArguments.getByName(name);
+                    if (valueOrValues instanceof String) {
+                        return Collections.singleton((String) valueOrValues);
+                    }
+                    if (valueOrValues instanceof String[]) {
+                        return Arrays.asList((String[]) valueOrValues);
+                    }
+                    return null;
+                }
+            };
+
+            if (type == String.class) {
+                return new DelegatingMapper<>(tabCompleter, null) {
+                    @Override
+                    public Object map(Object sender, PreviousArguments previousArguments, String s) {
+                        Object valueOrValues = previousArguments.getByName(name);
+                        if (valueOrValues instanceof String) {
+                            if (s.equalsIgnoreCase((String) valueOrValues)) return s;
+                            else return null;
+                        }
+
+                        if (!(valueOrValues instanceof String[])) return null;
+                        for (String t : (String[]) valueOrValues) {
+                            if (s.equalsIgnoreCase(t)) return s;
+                        }
+                        return null;
+                    }
+                };
+            }
+
+            if (type == long.class || type == Long.class) {
+                return new DelegatingMapper<>(tabCompleter, null) {
+                    @Override
+                    public Object map(Object sender, PreviousArguments previousArguments, String s) {
+                        Object valueOrValues = previousArguments.getByName(name);
+                        if (valueOrValues instanceof String) {
+                            if (s.equalsIgnoreCase((String) valueOrValues)) return 0L;
+                            else return null;
+                        }
+
+                        if (!(valueOrValues instanceof String[])) return null;
+                        String[] strings = (String[]) valueOrValues;
+                        for (int i = 0; i < strings.length; i++) {
+                            if (s.equalsIgnoreCase(strings[i])) return (long) i;
+                        }
+                        return null;
+                    }
+                };
+            }
+
+            return new DelegatingMapper<>(tabCompleter, null) {
+                @Override
+                public Object map(Object sender, PreviousArguments previousArguments, String s) {
+                    Object valueOrValues = previousArguments.getByName(name);
+                    if (valueOrValues instanceof String) {
+                        if (s.equalsIgnoreCase((String) valueOrValues)) return 0;
+                        else return null;
+                    }
+
+                    if (!(valueOrValues instanceof String[])) return null;
+                    String[] strings = (String[]) valueOrValues;
+                    for (int i = 0; i < strings.length; i++) {
+                        if (s.equalsIgnoreCase(strings[i])) return i;
+                    }
+                    return null;
+                }
+            };
+        }
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/mapper/BooleanMapper.java

@@ -0,0 +1,41 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.mapper;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.PreviousArguments;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+public class BooleanMapper implements AbstractTypeMapper<Object, Boolean> {
+
+    @Override
+    public Boolean map(Object sender, PreviousArguments previousArguments, String s) {
+        if (s.equalsIgnoreCase("true")) return true;
+        if (s.equalsIgnoreCase("false")) return false;
+        return null;
+    }
+
+    @Override
+    public Collection<String> tabComplete(Object sender, PreviousArguments previousArguments, String s) {
+        return Arrays.asList("true", "false");
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/mapper/EnumMapper.java

@@ -0,0 +1,50 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.mapper;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.PreviousArguments;
+
+import java.util.*;
+
+public class EnumMapper implements AbstractTypeMapper<Object, Enum<?>> {
+
+    private Map<String, Enum<?>> enumMap;
+    private Set<String> tabCompletions = new HashSet<>();
+
+    public EnumMapper(Class<Enum<?>> enumClass) {
+        Map<String, Enum<?>> enumMap = new HashMap<>();
+        for (Enum<?> e : enumClass.getEnumConstants()) {
+            enumMap.put(e.name().toLowerCase(), e);
+            tabCompletions.add(e.name());
+        }
+        this.enumMap = enumMap;
+    }
+
+    @Override
+    public Enum<?> map(Object sender, PreviousArguments previousArguments, String s) {
+        return enumMap.get(s.toLowerCase());
+    }
+
+    @Override
+    public Collection<String> tabComplete(Object sender, PreviousArguments previousArguments, String s) {
+        return tabCompletions;
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/mapper/NumberMapper.java

@@ -0,0 +1,95 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.mapper;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.PreviousArguments;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class NumberMapper implements AbstractTypeMapper<Object, Number> {
+
+    private Function<String, Number> function;
+    private boolean comma;
+
+    public NumberMapper(Function<String, Number> function, boolean comma) {
+        this.function = function;
+        this.comma = comma;
+    }
+
+    @Override
+    public Number map(Object sender, PreviousArguments previousArguments, String s) {
+        if (s.equalsIgnoreCase("nan")) return null;
+        try {
+            return function.apply(s);
+        } catch (NumberFormatException e) {
+            // Ignored
+        }
+        if (!comma) return null;
+        try {
+            return function.apply(s.replace(',', '.'));
+        } catch (NumberFormatException e) {
+            return null;
+        }
+    }
+
+    @Override
+    public Collection<String> tabComplete(Object sender, PreviousArguments previousArguments, String s) {
+        List<String> strings = new ArrayList<>();
+        strings.add(s);
+        for (int i = 0; i < 10; i++) {
+            strings.add(s + i);
+        }
+        strings = strings.stream()
+                .map(t -> {
+                    Number number = map(sender, previousArguments, t);
+                    if (number == null) return null;
+                    String value = number + "";
+                    if (value.endsWith(".0")) return value.substring(0, value.length() - 2);
+                    return value;
+                })
+                .filter(Objects::nonNull)
+                .collect(Collectors.toList());
+        if (comma) {
+            Number number = map(sender, previousArguments, s + ".");
+            if (number != null) {
+                String value = number + "";
+                if (value.endsWith(".0")) {
+                    strings.add(value.substring(0, value.length() - 1));
+                } else {
+                    strings.add(value);
+                }
+            }
+        }
+        if (s.isEmpty()) {
+            strings.add("-");
+        }
+        strings = strings.stream()
+                .distinct()
+                .collect(Collectors.toList());
+        strings.remove("-0");
+        return strings;
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/mapper/OptionEnumMapper.java

@@ -0,0 +1,80 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.mapper;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.OptionEnum;
+import de.steamwar.command.PreviousArguments;
+
+import java.util.*;
+
+public class OptionEnumMapper implements AbstractTypeMapper<Object, Enum<?>> {
+
+    private Class<OptionEnum<?>> enumClass;
+    private List<OptionEnum<?>> optionEnums = new ArrayList<>();
+
+    public <T extends Enum<T> & OptionEnum<T>> OptionEnumMapper(Class<T> enumClass) {
+        this.enumClass = (Class) enumClass;
+
+        for (Enum<?> enumConstant : enumClass.getEnumConstants()) {
+            optionEnums.add((OptionEnum<?>) enumConstant);
+        }
+    }
+
+    private Set<OptionEnum<?>> getRemoved(PreviousArguments previousArguments) {
+        Set<OptionEnum<?>> removed = new HashSet<>();
+        for (OptionEnum<?> optionEnum : previousArguments.getAll(enumClass)) {
+            removed.add(optionEnum);
+            Collections.addAll(removed, (OptionEnum<?>[]) optionEnum.getRemoved());
+        }
+        return removed;
+    }
+
+    @Override
+    public Enum<?> map(Object sender, PreviousArguments previousArguments, String s) {
+        Set<OptionEnum<?>> removed = getRemoved(previousArguments);
+
+        for (OptionEnum<?> optionEnum : optionEnums) {
+            if (removed.contains(optionEnum)) {
+                continue;
+            }
+            List<String> strings = optionEnum.getTabCompletes();
+            for (String string : strings) {
+                if (string.equalsIgnoreCase(s)) {
+                    return (Enum<?>) optionEnum;
+                }
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public Collection<String> tabComplete(Object sender, PreviousArguments previousArguments, String s) {
+        Set<OptionEnum<?>> removed = getRemoved(previousArguments);
+
+        List<String> tabCompletes = new ArrayList<>();
+        for (OptionEnum<?> optionEnum : optionEnums) {
+            if (!removed.contains(optionEnum)) {
+                tabCompletes.addAll(optionEnum.getTabCompletes());
+            }
+        }
+        return tabCompletes;
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/mapper/SimpleMapper.java

@@ -0,0 +1,56 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.mapper;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.PreviousArguments;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class SimpleMapper implements AbstractTypeMapper<Object, String> {
+
+    private List<String> elements;
+    private Set<String> checkElements;
+
+    public SimpleMapper(List<String> elements) {
+        this.elements = elements;
+        this.checkElements = elements.stream()
+                .map(String::toLowerCase)
+                .collect(Collectors.toSet());
+    }
+
+    public SimpleMapper(String... elements) {
+        this(List.of(elements));
+    }
+
+    @Override
+    public String map(Object sender, PreviousArguments previousArguments, String s) {
+        if (checkElements.contains(s.toLowerCase())) return s;
+        return null;
+    }
+
+    @Override
+    public Collection<String> tabComplete(Object sender, PreviousArguments previousArguments, String s) {
+        return elements;
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/mapper/internal/ContainsFilter.java

@@ -0,0 +1,44 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.mapper.internal;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.PreviousArguments;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.stream.Collectors;
+
+public class ContainsFilter<T, K> extends DelegatingMapper<T, K> {
+
+    public ContainsFilter(AbstractTypeMapper<T, K> delegate) {
+        super(delegate, null);
+    }
+
+    @Override
+    public Collection<String> tabComplete(T sender, PreviousArguments previousArguments, String s) {
+        Collection<String> tabCompletes = super.tabComplete(sender, previousArguments, s);
+        if (tabCompletes == null) return Collections.emptyList();
+        String t = s.toLowerCase();
+        return tabCompletes.stream()
+                .filter(tabComplete -> tabComplete.toLowerCase().contains(t))
+                .collect(Collectors.toList());
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/mapper/internal/DelegatingMapper.java

@@ -0,0 +1,57 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.mapper.internal;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.PreviousArguments;
+
+import java.lang.annotation.Annotation;
+import java.util.Collection;
+
+public class DelegatingMapper<K, T> implements AbstractTypeMapper<K, T> {
+
+    protected final AbstractTypeMapper<K, T> delegate;
+    protected final Annotation annotation;
+
+    public DelegatingMapper(AbstractTypeMapper<K, T> delegate, Annotation annotation) {
+        this.delegate = delegate;
+        this.annotation = annotation;
+    }
+
+    @Override
+    public T map(K sender, PreviousArguments previousArguments, String s) {
+        return delegate.map(sender, previousArguments, s);
+    }
+
+    @Override
+    public Collection<String> tabComplete(K sender, PreviousArguments previousArguments, String s) {
+        return delegate.tabComplete(sender, previousArguments, s);
+    }
+
+    @Override
+    public boolean appendNextElementTabCompletions() {
+        return delegate.appendNextElementTabCompletions();
+    }
+
+    @Override
+    public String normalize(K sender, String s) {
+        return delegate.normalize(sender, s);
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/mapper/internal/StartsWithFilter.java

@@ -0,0 +1,43 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.mapper.internal;
+
+import de.steamwar.command.AbstractTypeMapper;
+import de.steamwar.command.PreviousArguments;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.stream.Collectors;
+
+public class StartsWithFilter<T, K> extends DelegatingMapper<T, K> {
+
+    public StartsWithFilter(AbstractTypeMapper<T, K> delegate) {
+        super(delegate, null);
+    }
+
+    @Override
+    public Collection<String> tabComplete(T sender, PreviousArguments previousArguments, String s) {
+        Collection<String> tabCompletes = super.tabComplete(sender, previousArguments, s);
+        if (tabCompletes == null) return Collections.emptyList();
+        return tabCompletes.stream()
+                .filter(tabComplete -> tabComplete.toLowerCase().startsWith(s.toLowerCase()) || s.toLowerCase().startsWith(tabComplete.toLowerCase()))
+                .collect(Collectors.toList());
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/utils/ClassEquality.java

@@ -0,0 +1,47 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2024  SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.utils;
+
+public class ClassEquality {
+
+    public static boolean classEquals(Class<?> first, Class<?> second) {
+        if (first.isPrimitive() && second.isPrimitive()) return first == second;
+        if (!first.isPrimitive() && !second.isPrimitive()) return first.isAssignableFrom(second);
+        first = toPrimitive(first);
+        second = toPrimitive(second);
+        if (first.isPrimitive() && second.isPrimitive()) return first == second;
+        return false;
+    }
+
+    public static Class<?> toPrimitive(Class<?> clazz) {
+        if (clazz == Boolean.class) {
+            return boolean.class;
+        } else if (clazz == Integer.class) {
+            return int.class;
+        } else if (clazz == Long.class) {
+            return long.class;
+        } else if (clazz == Float.class) {
+            return float.class;
+        } else if (clazz == Double.class) {
+            return double.class;
+        }
+        return clazz;
+    }
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/utils/Pair.java

@@ -0,0 +1,30 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.utils;
+
+import lombok.RequiredArgsConstructor;
+import lombok.ToString;
+
+@ToString
+@RequiredArgsConstructor
+public class Pair<A, B> {
+    public final A a;
+    public final B b;
+}

CommandFramework/CommandFrameworkBase/src/de/steamwar/command/utils/Triple.java

@@ -0,0 +1,31 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.utils;
+
+import lombok.RequiredArgsConstructor;
+import lombok.ToString;
+
+@ToString
+@RequiredArgsConstructor
+public class Triple<A, B, C> {
+    public final A a;
+    public final B b;
+    public final C c;
+}

CommandFramework/CommandFrameworkSpigot/build.gradle.kts

@@ -0,0 +1,33 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2024  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+plugins {
+    steamwar.java
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_11
+    targetCompatibility = JavaVersion.VERSION_11
+}
+
+dependencies {
+    implementation(project(":CommandFramework:CommandFrameworkBase", "default"))
+
+    implementation(libs.spigotapi)
+}

CommandFramework/CommandFrameworkSpigot/src/de/steamwar/command/SpigotCommand.java

@@ -0,0 +1,156 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import de.steamwar.command.mapper.GameModeMapper;
+import de.steamwar.command.mapper.PlayerMapper;
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.text.MessageFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.logging.Level;
+
+public class SpigotCommand extends AbstractCommand<CommandSender> {
+
+    static {
+        CommandUtils.addMapper(Player.class, new PlayerMapper());
+        CommandUtils.addMapper(GameMode.class, new GameModeMapper());
+        addExecutorMapper(SpigotCommand.class, CommandSender.class, Function.identity());
+    }
+
+    private Command command;
+
+    /*
+    @Setter
+    private Message message = null;
+     */
+    private List<String> defaultHelpMessages = new ArrayList<>();
+
+    public SpigotCommand(String command, Consumer<CommandLoader<CommandSender>> initializer, String... aliases) {
+        super(command, initializer, aliases);
+    }
+
+    public SpigotCommand(String command, String permission, Consumer<CommandLoader<CommandSender>> initializer, String... aliases) {
+        super(command, permission, initializer, aliases);
+    }
+
+    @Override
+    protected synchronized void initCommand() {
+        this.command = new Command(SpigotCommand.super.command, "", "/" + command, Arrays.asList(aliases)) {
+            @Override
+            public boolean execute(CommandSender sender, String alias, String[] args) {
+                SpigotCommand.this.execute(sender, alias, args);
+                return false;
+            }
+
+            @Override
+            public List<String> tabComplete(CommandSender sender, String alias, String[] args) throws IllegalArgumentException {
+                return SpigotCommand.this.tabComplete(sender, alias, args);
+            }
+        };
+        this.command.setPermission(permission);
+    }
+
+    @Override
+    public void unregister() {
+        SpigotCommandRegistering.unregister(this.command);
+    }
+
+    @Override
+    public void register() {
+        SpigotCommandRegistering.register(this.command);
+    }
+
+    @Override
+    protected void commandSystemError(CommandSender sender, CommandFrameworkException e) {
+        Bukkit.getLogger().log(Level.SEVERE, e.getMessage(), e);
+        // TODO: Core.MESSAGE.sendPrefixless("COMMAND_SYSTEM_ERROR", sender);
+    }
+
+    public void addDefaultHelpMessage(String message) {
+        defaultHelpMessages.add(message);
+    }
+
+    @Override
+    protected void sendMessage(CommandSender sender, String message, Object[] args) {
+        // TODO: this.message.send(message, sender, args);
+        sender.sendMessage(MessageFormat.format(message, args));
+    }
+
+    /* TODO
+    @Register(noTabComplete = true)
+    public void internalHelp(Player p, String... args) {
+        if (message == null) {
+            return;
+        }
+        try {
+            message.sendPrefixless("COMMAND_HELP_HEAD", p, command.getName().substring(0, 1).toUpperCase() + command.getName().substring(1));
+            defaultHelpMessages.forEach(s -> message.sendPrefixless(s, p));
+        } catch (Exception e) {
+            Bukkit.getLogger().log(Level.WARNING, "Failed to send help message", e);
+            return;
+        }
+        AtomicInteger atomicInteger = new AtomicInteger();
+        if (args.length != 0) {
+            commandList.forEach(subCommand -> {
+                List<String> tabCompletes = subCommand.tabComplete(p, args);
+                if (tabCompletes == null || tabCompletes.isEmpty()) {
+                    atomicInteger.incrementAndGet();
+                    return;
+                }
+                boolean hasTabCompletes = tabCompletes.stream()
+                        .anyMatch(s -> s.toLowerCase().startsWith(args[args.length - 1].toLowerCase()));
+                if (hasTabCompletes) {
+                    send(p, subCommand);
+                } else {
+                    atomicInteger.incrementAndGet();
+                }
+            });
+        }
+        if (args.length == 0 || atomicInteger.get() == commandList.size()) {
+            commandList.forEach(subCommand -> {
+                if (subCommand.validator == null || subCommand.validator.validate(p, p, (s, args1) -> {})) {
+                    send(p, subCommand);
+                }
+            });
+        }
+    }
+
+    private void send(Player p, SubCommand<CommandSender> subCommand) {
+        try {
+            for (String s : subCommand.description) {
+                String hover = "§8/§e" + command.getName() + " " + String.join(" ", subCommand.subCommand);
+                String suggest = "/" + command.getName() + " " + String.join(" ", subCommand.subCommand);
+                message.sendPrefixless(s, p, hover, new ClickEvent(ClickEvent.Action.SUGGEST_COMMAND, suggest));
+            }
+        } catch (Exception e) {
+            Bukkit.getLogger().log(Level.WARNING, "Failed to send description of registered method '" + subCommand.method + "' with description '" + subCommand.description + "'", e);
+        }
+    }
+     */
+}

CommandFramework/CommandFrameworkSpigot/src/de/steamwar/command/SpigotCommandFrameworkPlugin.java

@@ -1,7 +1,7 @@
 /*
  *   This file is a part of the SteamWar software.
  *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *   Copyright (C) 2024  SteamWar.de-Serverteam
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Affero General Public License as published by
@@ -19,10 +19,7 @@
 
 package de.steamwar.command;
 
-import java.util.Collection;
-import java.util.function.BiFunction;
-import java.util.function.Function;
+import org.bukkit.plugin.java.JavaPlugin;
 
-public interface SWTypeMapperCreator<T extends AbstractTypeMapper<K, V>, K, V> {
-    T createTypeMapper(Function<String, V> mapper, BiFunction<K, String, Collection<String>> tabCompleter);
+public class SpigotCommandFrameworkPlugin extends JavaPlugin {
 }

CommandFramework/CommandFrameworkSpigot/src/de/steamwar/command/SpigotCommandRegistering.java

@@ -0,0 +1,65 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import lombok.experimental.UtilityClass;
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandMap;
+import org.bukkit.command.SimpleCommandMap;
+
+import java.lang.reflect.Field;
+import java.util.Map;
+
+@UtilityClass
+class SpigotCommandRegistering {
+
+    private static final CommandMap commandMap;
+    private static final Map<String, Command> knownCommandMap;
+
+    static {
+        try {
+            final Field commandMapField = Bukkit.getServer().getClass().getDeclaredField("commandMap");
+            commandMapField.setAccessible(true);
+            commandMap = (CommandMap) commandMapField.get(Bukkit.getServer());
+        } catch (NoSuchFieldException | IllegalAccessException exception) {
+            Bukkit.shutdown();
+            throw new SecurityException("Oh shit. Commands cannot be registered.", exception);
+        }
+        try {
+            final Field knownCommandsField = SimpleCommandMap.class.getDeclaredField("knownCommands");
+            knownCommandsField.setAccessible(true);
+            knownCommandMap = (Map<String, Command>) knownCommandsField.get(commandMap);
+        } catch (NoSuchFieldException | IllegalAccessException exception) {
+            Bukkit.shutdown();
+            throw new SecurityException("Oh shit. Commands cannot be registered.", exception);
+        }
+    }
+
+    static void unregister(Command command) {
+        knownCommandMap.remove(command.getName());
+        command.getAliases().forEach(knownCommandMap::remove);
+        command.unregister(commandMap);
+    }
+
+    static void register(Command command) {
+        commandMap.register("command_framework", command);
+    }
+}

CommandFramework/CommandFrameworkSpigot/src/de/steamwar/command/SpigotTypeMapper.java

@@ -0,0 +1,25 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import org.bukkit.command.CommandSender;
+
+public interface SpigotTypeMapper<T> extends AbstractTypeMapper<CommandSender, T> {
+}

CommandFramework/CommandFrameworkSpigot/src/de/steamwar/command/SpigotTypeSupplier.java

@@ -1,7 +1,7 @@
 /*
  *   This file is a part of the SteamWar software.
  *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *   Copyright (C) 2023  SteamWar.de-Serverteam
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Affero General Public License as published by
@@ -19,18 +19,7 @@
 
 package de.steamwar.command;
 
-import org.junit.Test;
+import org.bukkit.command.CommandSender;
 
-import java.util.List;
-
-import static de.steamwar.AssertionUtils.assertTabCompletes;
-
-public class TypeMapperCommandTest {
-
-    @Test
-    public void testTabComplete() {
-        TypeMapperCommand cmd = new TypeMapperCommand();
-        List<String> strings = cmd.tabComplete("test", "", new String[]{""});
-        assertTabCompletes(strings, "1", "2", "3", "4", "5");
-    }
+public interface SpigotTypeSupplier<T> extends AbstractTypeSupplier<CommandSender, T> {
 }

CommandFramework/CommandFrameworkSpigot/src/de/steamwar/command/SpigotTypeValidator.java

@@ -0,0 +1,25 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command;
+
+import org.bukkit.command.CommandSender;
+
+public interface SpigotTypeValidator<T> extends AbstractTypeValidator<CommandSender, T> {
+}

CommandFramework/CommandFrameworkSpigot/src/de/steamwar/command/mapper/GameModeMapper.java

@@ -0,0 +1,46 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.mapper;
+
+import de.steamwar.command.PreviousArguments;
+import de.steamwar.command.SpigotTypeMapper;
+import org.bukkit.GameMode;
+import org.bukkit.command.CommandSender;
+
+import java.util.Arrays;
+import java.util.Collection;
+
+public class GameModeMapper implements SpigotTypeMapper<GameMode> {
+
+    @Override
+    public GameMode map(CommandSender sender, PreviousArguments previousArguments, String s) {
+        s = s.toLowerCase();
+        if (s.equals("s") || s.equals("survival") || s.equals("0")) return GameMode.SURVIVAL;
+        if (s.equals("c") || s.equals("creative") || s.equals("1")) return GameMode.CREATIVE;
+        if (s.equals("sp") || s.equals("spectator") || s.equals("3")) return GameMode.SPECTATOR;
+        if (s.equals("a") || s.equals("adventure") || s.equals("2")) return GameMode.ADVENTURE;
+        return null;
+    }
+
+    @Override
+    public Collection<String> tabComplete(CommandSender sender, PreviousArguments previousArguments, String s) {
+        return Arrays.asList("s", "survival", "0", "c", "creative", "1", "sp", "spectator", "3", "a", "adventure", "2");
+    }
+}

CommandFramework/CommandFrameworkSpigot/src/de/steamwar/command/mapper/PlayerMapper.java

@@ -0,0 +1,44 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2023  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.command.mapper;
+
+import de.steamwar.command.PreviousArguments;
+import de.steamwar.command.SpigotTypeMapper;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.Collection;
+import java.util.stream.Collectors;
+
+public class PlayerMapper implements SpigotTypeMapper<Player> {
+
+    @Override
+    public Player map(CommandSender sender, PreviousArguments previousArguments, String s) {
+        return Bukkit.getPlayer(s);
+    }
+
+    @Override
+    public Collection<String> tabComplete(CommandSender sender, PreviousArguments previousArguments, String s) {
+        return Bukkit.getOnlinePlayers().stream()
+                .map(Player::getName)
+                .collect(Collectors.toList());
+    }
+}

CommandFramework/CommandFrameworkSpigot/src/plugin.yml

@@ -0,0 +1,4 @@
+name: CommandFramework
+main: de.steamwar.command.SpigotCommandFrameworkPlugin
+version: 1.0
+author: YoyoNow

CommandFramework/CommandFrameworkTests/build.gradle.kts

@@ -0,0 +1,34 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2024  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+plugins {
+    steamwar.java
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_11
+    targetCompatibility = JavaVersion.VERSION_11
+}
+
+dependencies {
+    testImplementation(libs.junit)
+    testImplementation(libs.hamcrest)
+
+    testImplementation(project(":CommandFramework:CommandFrameworkBase", "default"))
+}

CommandFramework/CommandFrameworkTests/testsrc/de/steamwar/AssertionUtils.java

@@ -0,0 +1,124 @@
+/*
+ * This file is a part of the SteamWar software.
+ *
+ * Copyright (C) 2020  SteamWar.de-Serverteam
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero 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 Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar;
+
+import de.steamwar.command.CommandFrameworkException;
+import de.steamwar.command.impl.ExecutionIdentifier;
+import de.steamwar.command.impl.TestCommand;
+import lombok.AllArgsConstructor;
+import lombok.experimental.UtilityClass;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.*;
+
+@UtilityClass
+public class AssertionUtils {
+
+    @AllArgsConstructor
+    public static class SimpleAssertion<T extends TestCommand> {
+
+        private T value;
+
+        public SimpleAssertion<T> assertNoInitialize(String message) {
+            try {
+                value.initialize();
+            } catch (UnsupportedOperationException e) {
+                if (e.getCause() == null) {
+                    assertThat(e.getMessage(), is(message));
+                } else {
+                    assertThat(e.getCause(), instanceOf(UnsupportedOperationException.class));
+                    assertThat(e.getCause().getMessage(), is(message));
+                }
+            } catch (Exception e) {
+                error(value.getClass().getSimpleName() + " had an unexpected error while initializing");
+            }
+            return this;
+        }
+
+        public SimpleAssertion<T> assertExecute(String message, String... arguments) {
+            try {
+                value.execute("", "", arguments);
+                error(value.getClass().getSimpleName() + " was not parsed.");
+            } catch (Exception e) {
+                assertCMDFramework(e, ExecutionIdentifier.class, message);
+            }
+            return this;
+        }
+
+        public SimpleAssertion<T> assertNoExecute(String... arguments) {
+            try {
+                value.execute("", "", arguments);
+            } catch (Exception e) {
+                error(value.getClass().getSimpleName() + " was parsed. It should not have been.", e);
+            }
+            return this;
+        }
+
+        public SimpleAssertion<T> assertTabCompletion(String[] expectedTabCompletions, String... arguments) {
+            return assertTabCompletion("", expectedTabCompletions, arguments);
+        }
+
+        public SimpleAssertion<T> assertTabCompletion(String sender, String[] expectedTabCompletions, String... arguments) {
+            try {
+                List<String> tabCompletions = value.tabComplete(sender, "", arguments);
+                assertTabCompletes(tabCompletions, expectedTabCompletions);
+            } catch (Exception e) {
+                error(value.getClass().getSimpleName() + " tab-completion failed.", e);
+            }
+            return this;
+        }
+    }
+
+    public static SimpleAssertion<TestCommand> with(Object... commandObjects) {
+        return new SimpleAssertion<>(new TestCommand(stringCommandLoader -> {
+            for (Object commandObject : commandObjects) {
+                stringCommandLoader.add(commandObject);
+            }
+        }));
+    }
+
+    public static void error(String message) {
+        throw new AssertionError(message);
+    }
+
+    public static void error(String message, Throwable cause) {
+        throw new AssertionError(message, cause);
+    }
+
+    public static void assertCMDFramework(Exception e, Class<?> clazz, String message) {
+        if (clazz.isInstance(e)) {
+            assertThat(e.getMessage(), is(message));
+        } else {
+            assertThat(e, is(instanceOf(CommandFrameworkException.class)));
+            assertThat(e.getCause().getCause(), is(instanceOf(clazz)));
+            assertThat(e.getCause().getCause().getMessage(), is(message));
+        }
+    }
+
+    public static <T> void assertTabCompletes(List<T> list, T... elements) {
+        assertThat(Arrays.asList(elements) + " -> " + list, list.size(), is(elements.length));
+        if (elements.length > 0) {
+            assertThat(list, containsInAnyOrder(elements));
+        }
+    }
+}