Fixxing Crash Exploits

CHANGELOG/kelp-v0.4.1.md

@@ -0,0 +1,58 @@
+# v0.5.0
+> Release date: unknown
+
+**The hologram and raycasting update**:
+
+* Change `KelpLogger` to be more compact and simple: 
+  * Remove own logging files and folder. During development, this custom folder has not proven as useful and just ate resources that could have been used better.
+  * `KelpLogger` is now a subclass of `java.util.logger.Logger` and therefore Java's default logging methods are used.
+  * Remove `LogLevel` enum as Java's log levels are now used, where `FINE`, `FINER`, `FINEST`, and `CONFIG` are only shown in debug mode.
+  * Properly link loggers to their corresponding kelp applications: `KelpLogger.of(YourPluginMainClass.class).info(...)`
+  * When logging from the core module, use `KelpLogger.of(KelpApplication.class)...`
+  * This way you don't have to let Guice inject the logger for you, reducing boilerplate dependencies. 
+* Add Raycasting library. You can create a new Raycast using `Raycast.create()`. For more info, check the corresponding wiki page.
+* You can now insert components at a specific index in an `InteractiveMessage`, which required to change the component list type from `Collection<...>` to `List<...>`. **If your plugin used `getComponents()`, then you will have to recompile it to update the method signature!** 
+* The raw text (excluding color codes) of `InteractiveMessages` can now be queried using `getRawText()` 
+* Add `ImageMessage` allowing you to display image files in the chat.
+* Gravity can now be disabled for all entities. This is a native feature in newer versions, for 1.8 a workaround has been made by spawning no-gravity armor stands and setting the entity as passenger.  
+* Fix bug that `SlimeEntity` could not be spawned because it could not be cast to a mob/creature in `1.8`.
+* Add `getEntities()` method to `KelpChunk`  
+* Fix bug that `getPlayers()` method of `KelpChunk` threw a `NoSuchFieldError` 
+  * This was because the CraftBukkit API and the NMS code of the spigot server differed and had different method signatures of `entitySlice` (the way how entities within a chunk are represented)
+  * So now the `entitySlice` is accessed via reflection, which might negatively impact performance of methods depending on it (currently `getPlayers` and `getEntities`)
+* Add debug tool to particle library: `ParticleVisualizable`
+  * It can be implemented by any class that can be visualized in the in-game world with particles such as regions or raycasts.
+  * You can apply different color schemes by using another `ParticleVisualizerProfile`
+* Rename `getOuterCorners()` of `KelpRegion` to `getCuboidOuterCorners()`
+  * The cuboid outer corners now have a defined order used by the `visualize` methods of regions
+  * Therefore, there should be no confusion with the cuboid outer corners and custom implementations such as in a `MergerdRegion`
+* You can now get an entities hitbox/bounding box as a `CuboidRegion`
+* You can now get a block's collision or selection bounding box as `CuboidRegion`  
+* Particle effects such as `ParticleLineEffect` are now cloneable and have static factories instead of a separate factory class
+* Remove `CardinalDirection` and replace it with `KelpBlockFace` wherever it was used. It was basically the same as `KelpBlockFace` with lower accuracy and is therefore considered redundant.
+* Create own `Vector3` class offering a version-independent alternative to bukkit's normal `Vector` class.
+* Add a method (`setValue(Class, Object, String, Object)`) to `ReflectionUtil` allowing to set the value of a field declared in any parent class of the given object.
+* You can now compare two entities using `KelpEntity#sameEntity(Object)` offering an alternative to the `equals()` method, which can not be overridden due to language limitations. 
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

core/pom.xml

@@ -81,65 +81,68 @@
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-shade-plugin</artifactId>
       </plugin>
-        <plugin>
-            <groupId>org.jetbrains.kotlin</groupId>
-            <artifactId>kotlin-maven-plugin</artifactId>
-            <version>${kotlin.version}</version>
-            <executions>
-                <execution>
-                    <id>kotlin-compile</id>
-                    <phase>process-sources</phase>
-                    <goals>
-                        <goal>compile</goal>
-                    </goals>
-                </execution>
-                <execution>
-                    <id>test-compile</id>
-                    <phase>test-compile</phase>
-                    <goals>
-                        <goal>test-compile</goal>
-                    </goals>
-                </execution>
-            </executions>
-            <configuration>
-              <jvmTarget>1.8</jvmTarget>
-              <sourceDirs>
-                <sourceDir>${project.basedir}/src/main/java</sourceDir>
-              </sourceDirs>
-            </configuration>
-        </plugin>
-        <plugin>
-          <groupId>org.apache.maven.plugins</groupId>
-          <artifactId>maven-compiler-plugin</artifactId>
-          <version>3.8.1</version>
-            <executions>
-                <execution>
-                    <id>java-compile</id>
-                    <phase>compile</phase>
-                    <goals>
-                        <goal>compile</goal>
-                    </goals>
-                </execution>
-                <execution>
-                    <id>testCompile</id>
-                    <phase>test-compile</phase>
-                    <goals>
-                        <goal>testCompile</goal>
-                    </goals>
-                </execution>
-              <execution>
-                <id>compile</id>
-                <phase>compile</phase>
+      <plugin>
+        <groupId>org.jetbrains.kotlin</groupId>
+        <artifactId>kotlin-maven-plugin</artifactId>
+        <version>${kotlin.version}</version>
+        <executions>
+            <execution>
+                <id>kotlin-compile</id>
+                <phase>process-sources</phase>
                 <goals>
-                  <goal>compile</goal>
+                    <goal>compile</goal>
                 </goals>
-              </execution>
-            </executions>
-            <configuration>
-            <source>8</source>
-            <target>8</target>
-          </configuration>
+            </execution>
+            <execution>
+                <id>test-compile</id>
+                <phase>test-compile</phase>
+                <goals>
+                    <goal>test-compile</goal>
+                </goals>
+            </execution>
+        </executions>
+        <configuration>
+          <jvmTarget>1.8</jvmTarget>
+          <sourceDirs>
+            <sourceDir>${project.basedir}/src/main/java</sourceDir>
+          </sourceDirs>
+        </configuration>
         </plugin>
+      <plugin>
+        <groupId>org.apache.maven.plugins</groupId>
+        <artifactId>maven-compiler-plugin</artifactId>
+        <version>3.5.1</version>
+        <executions>
+          <!-- Replacing default-compile as it is treated specially by maven -->
+          <execution>
+            <id>default-compile</id>
+            <phase>none</phase>
+          </execution>
+          <!-- Replacing default-testCompile as it is treated specially by maven -->
+          <execution>
+            <id>default-testCompile</id>
+            <phase>none</phase>
+          </execution>
+          <execution>
+            <id>java-compile</id>
+            <phase>compile</phase>
+            <goals>
+              <goal>compile</goal>
+            </goals>
+          </execution>
+          <execution>
+            <id>java-test-compile</id>
+            <phase>test-compile</phase>
+            <goals>
+              <goal>testCompile</goal>
+            </goals>
+          </execution>
+        </executions>
+        <configuration>
+          <source>8</source>
+          <target>8</target>
+        </configuration>
+      </plugin>
     </plugins>
 
     <resources>

core/src/main/java/de/dseelp/kommon/command/CommandBuilder.kt

@@ -66,10 +66,6 @@ class CommandBuilder<S: Any>(
         childs += CommandBuilder<S>(argument = argument).apply(block).build()
     }
 
-    /*fun argument(argument: Argument<*>) {
-        arguments+=argument
-    }*/
-
     fun build(): CommandNode<S> {
         if (name == null && argument == null) throw IllegalStateException("An command node must have a name or an argument!")
         if (target != null && childs.isNotEmpty()) throw IllegalStateException("Cannot forward a node with children")
@@ -81,7 +77,7 @@ class CommandBuilder<S: Any>(
         this.apply(block)
     }
 
-    fun <I: Any, O: Any?> map(name: String, mapper: CommandContext<S>.(input: I) -> O) {
+    fun <I : Any, O : Any?> map(name: String, mapper: CommandContext<S>.(input: I) -> O) {
         @Suppress("UNCHECKED_CAST")
         mappers = mappers + (name to mapper as CommandContext<S>.(input: Any) -> Any?)
     }
@@ -90,4 +86,14 @@ class CommandBuilder<S: Any>(
         private set
 }
 
-fun <T: Any> command(name: String, block: CommandBuilder<T>.() -> Unit): CommandNode<T> = CommandBuilder<T>(name).apply(block).build()
+@Deprecated(
+    message = "This deprecated in favor of literal and will be removed in the future",
+    replaceWith = ReplaceWith("literal(name, block)")
+)
+fun <S : Any> command(name: String, block: CommandBuilder<S>.() -> Unit): CommandNode<S> = literal(name, block)
+
+fun <S : Any> literal(name: String, block: CommandBuilder<S>.() -> Unit): CommandNode<S> =
+    CommandBuilder<S>(name).apply(block).build()
+
+fun <T : Any> argument(argument: Argument<T, *>, block: CommandBuilder<T>.() -> Unit): CommandNode<T> =
+    CommandBuilder<T>(argument = argument).apply(block).build()

core/src/main/java/de/dseelp/kommon/command/CommandDispatcher.kt

@@ -1,6 +1,7 @@
 package de.dseelp.kommon.command
 
 import de.dseelp.kommon.command.arguments.ParsedArgument
+import java.util.*
 
 /**
  * @author DSeeLP
@@ -14,7 +15,7 @@ class CommandDispatcher<S : Any> {
     }
 
     fun register(name: String, block: CommandBuilder<S>.() -> Unit) {
-        register(command(name, block))
+        register(literal(name, block))
     }
 
     fun register(builder: JavaCommandBuilder<S>) {
@@ -27,12 +28,12 @@ class CommandDispatcher<S : Any> {
     }
 
     fun getNode(name: String, useAliases: Boolean = false): CommandNode<S>? {
-        val lowercaseName = name.toLowerCase()
+        val lowercaseName = name.toLowerCase(Locale.getDefault())
         for (node in nodes) {
-            if (node.name!!.toLowerCase() == lowercaseName) return node
+            if (node.name!!.toString().toLowerCase(Locale.getDefault()) == lowercaseName) return node
             if (useAliases) {
                 for (alias in node.aliases) {
-                    if (alias.toLowerCase() == lowercaseName) return node
+                    if (alias.toLowerCase(Locale.getDefault()) == lowercaseName) return node
                 }
             }
         }
@@ -255,14 +256,13 @@ class CommandDispatcher<S : Any> {
         if (newArgs.isEmpty()) {
             val strings = mutableSetOf<String>()
             node.childs
+                .filter { it.checkAccess.invoke(context) }
                 .mapNotNull { it.argumentIdentifier }
                 .map { it.complete(context, current) }
                 .forEach { strings.addAll(it) }
-            node.childs.filter { it.argumentIdentifier == null }.forEach { strings.addAll(it.aliases + it.name!!) }
+            node.childs.filter { it.checkAccess.invoke(context) }.filter { it.argumentIdentifier == null }.forEach { strings.addAll(it.aliases + it.name!!) }
             return strings.toTypedArray()
         }
         return arrayOf()
     }
-
-
 }

core/src/main/java/de/dseelp/kommon/command/JavaBuilderConstants.java

@@ -1,6 +1,9 @@
 package de.dseelp.kommon.command;
 
 import de.dseelp.kommon.command.arguments.*;
+import kotlin.jvm.functions.Function1;
+
+import java.util.UUID;
 
 /**
  * @author DSeeLP
@@ -32,13 +35,41 @@ public static IntArgument integerArgument(String name) {
         return new IntArgument(name);
     }
 
+    public static IntArgument integerArgument(String name, Function1<CommandContext, Integer[]> completer) {
+        return new IntArgument(name, completer);
+    }
+
+    public static DoubleArgument doubleArgument(String name) {
+        return new DoubleArgument(name);
+    }
+
+    public static DoubleArgument doubleArgument(String name, Function1<CommandContext, Double[]> completer) {
+        return new DoubleArgument(name, completer);
+    }
+
+    public static LongArgument longArgument(String name) {
+        return new LongArgument(name);
+    }
+
+    public static LongArgument longArgument(String name, Function1<CommandContext, Long[]> completer) {
+        return new LongArgument(name, completer);
+    }
+
 
     public static UUIDArgument uniqueIdArgument(String name) {
         return new UUIDArgument(name);
     }
 
+    public static UUIDArgument uniqueIdArgument(String name, Function1<CommandContext, UUID[]> completer) {
+        return new UUIDArgument(name, completer);
+    }
+
 
     public static StringArgument stringArgument(String name) {
         return new StringArgument(name);
     }
+
+    public static StringArgument stringArgument(String name, Function1<CommandContext, String[]> completer) {
+        return new StringArgument(name, completer);
+    }
 }

core/src/main/java/de/dseelp/kommon/command/arguments/BooleanArgument.kt

@@ -5,13 +5,17 @@ import de.dseelp.kommon.command.CommandContext
 /**
  * @author DSeeLP
  */
-class BooleanArgument<S: Any>(name: String, trueString: String = "true", falseString: String = "false") : Argument<S, Boolean>(name) {
-    constructor(name: String): this(name, trueString = "true")
-
+class BooleanArgument<S : Any> @JvmOverloads constructor(
+    name: String,
+    trueString: String = "true",
+    falseString: String = "false"
+) : Argument<S, Boolean>(name) {
     override fun get(value: String): Boolean? = value.toBooleanOrNull()
     override fun getErrorMessage(): String = "%s is not a boolean"
     private val possibleValues = arrayOf(trueString, falseString)
-    override fun complete(context: CommandContext<S>, value: String): Array<String> = possibleValues.filter { value.toLowerCase().startsWith(it) }.toTypedArray()
+    override fun complete(context: CommandContext<S>, value: String): Array<String> =
+        possibleValues.filter { it.toLowerCase().startsWith(value) }.toTypedArray()
 }
 
-fun String.toBooleanOrNull(trueString: String = "true", falseString: String = "false"): Boolean? = if (toLowerCase() == trueString) true else if (toLowerCase() == falseString) false else null
+fun String.toBooleanOrNull(trueString: String = "true", falseString: String = "false"): Boolean? =
+    if (toLowerCase() == trueString) true else if (toLowerCase() == falseString) false else null

core/src/main/java/de/dseelp/kommon/command/arguments/DoubleArgument.kt

@@ -5,8 +5,12 @@ import de.dseelp.kommon.command.CommandContext
 /**
  * @author DSeeLP
  */
-class DoubleArgument<S: Any>(name: String) : Argument<S, Double>(name) {
+class DoubleArgument<S : Any> @JvmOverloads constructor(
+    name: String,
+    val completer: CommandContext<S>.() -> Array<Double> = { arrayOf() }
+) : Argument<S, Double>(name) {
     override fun get(value: String): Double? = value.toDoubleOrNull()
     override fun getErrorMessage(): String = "%s is not an Double"
-    override fun complete(context: CommandContext<S>, value: String): Array<String> = arrayOf()
+    override fun complete(context: CommandContext<S>, value: String): Array<String> =
+        completer.invoke(context).map { it.toString() }.filter { value.startsWith(it, true) }.toTypedArray()
 }

core/src/main/java/de/dseelp/kommon/command/arguments/IntArgument.kt

@@ -5,10 +5,14 @@ import de.dseelp.kommon.command.CommandContext
 /**
  * @author DSeeLP
  */
-class IntArgument<S: Any>(name: String, val completer: CommandContext<S>.() -> Array<Int> = { arrayOf() }) : Argument<S, Int>(name) {
-    constructor(name: String): this(name, { arrayOf() })
+class IntArgument<S : Any> @JvmOverloads constructor(
+    name: String,
+    val completer: CommandContext<S>.() -> Array<Int> = { arrayOf() }
+) :
+    Argument<S, Int>(name) {
 
     override fun get(value: String): Int? = value.toIntOrNull()
     override fun getErrorMessage(): String = "%s is not an Integer"
-    override fun complete(context: CommandContext<S>, value: String): Array<String> = completer.invoke(context).map { it.toString() }.filter { value.startsWith(it, true) }.toTypedArray()
+    override fun complete(context: CommandContext<S>, value: String): Array<String> =
+        completer.invoke(context).map { it.toString() }.filter { value.startsWith(it, true) }.toTypedArray()
 }