Migrate to Java 24 and Gradle 8.14.1.

Enhance JavaDocs.

Author: nightm4re94

.github/workflows/build.yml

@@ -29,7 +29,7 @@ jobs:
         uses: actions/setup-java@v4
         with:
           distribution: temurin
-          java-version: 23
+          java-version: 24
 
       - name: Setup Gradle
         uses: gradle/actions/setup-gradle@v4

.github/workflows/gradle-dependency-submission.yml

@@ -17,7 +17,7 @@ jobs:
     - uses: actions/setup-java@v4
       with:
         distribution: temurin
-        java-version: 23
+        java-version: 24
     - name: Generate and submit dependency graph
       uses: gradle/actions/dependency-submission@v4
       with:

.github/workflows/release.yml

@@ -38,7 +38,7 @@ jobs:
         uses: actions/setup-java@v4
         with:
           distribution: temurin
-          java-version: 23
+          java-version: 24
 
       - name: Gradle Setup
         uses: gradle/actions/setup-gradle@v4
@@ -125,7 +125,7 @@ jobs:
         uses: actions/setup-java@v4
         with:
           distribution: temurin
-          java-version: 23
+          java-version: 24
 
       - name: Setup Gradle
         uses: gradle/actions/setup-gradle@v4

build.gradle

@@ -19,6 +19,12 @@ allprojects {
   project.getLogger().lifecycle("Set project '{}' version to '{}'.", project.name, project.version)
 }
 
+java {
+  toolchain {
+    languageVersion = JavaLanguageVersion.of(24)
+  }
+}
+
 nexusPublishing {
   useStaging.set(isTaggedRevision(project.version))
   repositories {

gradle/wrapper/gradle-wrapper.jar

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.13-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

gradle/wrapper/gradle-wrapper.properties

@@ -114,7 +114,7 @@ case "$( uname )" in                #(
   NONSTOP* )        nonstop=true ;;
 esac
 
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+CLASSPATH="\\\"\\\""
 
 
 # Determine the Java command to use to start the JVM.
@@ -213,7 +213,7 @@ DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \
         -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
         "$@"
 
 # Stop when "xargs" is not available.

gradlew

@@ -70,11 +70,11 @@ goto fail
 :execute
 @rem Setup the command line
 
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+set CLASSPATH=
 
 
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
 
 :end
 @rem End local scope for the variables with windows NT shell

gradlew.bat

@@ -2,21 +2,44 @@
 
 import de.gurkenlabs.litiengine.Game;
 import de.gurkenlabs.litiengine.entities.ICombatEntity;
-
-import java.awt.*;
+import java.awt.Shape;
 import java.util.Collection;
 import java.util.List;
 import java.util.function.BiPredicate;
 
+/**
+ * A custom targeting strategy that allows defining a specific condition for selecting targets.
+ *
+ * <p>This strategy uses a {@link BiPredicate} to determine whether a combat entity
+ * should be targeted based on the executor and the potential target. It supports multi-targeting and sorting by distance.
+ */
 public class CustomTargetingStrategy extends TargetingStrategy {
 
   private final BiPredicate<ICombatEntity, ICombatEntity> targetingCondition;
 
+  /**
+   * Creates a new {@code CustomTargetingStrategy} with the specified targeting condition.
+   *
+   * @param customPredicate The condition to determine valid targets. It takes the executor and a potential target as arguments and returns
+   *                        {@code true} if the target is valid.
+   * @param multiTarget     Whether the strategy supports targeting multiple entities.
+   * @param sortByDistance  Whether the targets should be sorted by their distance to the executor.
+   */
   public CustomTargetingStrategy(BiPredicate<ICombatEntity, ICombatEntity> customPredicate, boolean multiTarget, boolean sortByDistance) {
     super(multiTarget, sortByDistance);
     this.targetingCondition = customPredicate;
   }
 
+  /**
+   * Finds the targets within the specified impact area based on the targeting condition.
+   *
+   * <p>If the targeting condition or the game environment is not available, this method
+   * returns an empty collection.
+   *
+   * @param impactArea The area in which to search for targets.
+   * @param executor   The combat entity executing the ability.
+   * @return A collection of combat entities that match the targeting condition.
+   */
   @Override
   public Collection<ICombatEntity> findTargetsInternal(Shape impactArea, ICombatEntity executor) {
     if (targetingCondition == null || Game.world() == null || Game.world().environment() == null) {

litiengine/src/main/java/de/gurkenlabs/litiengine/abilities/targeting/CustomTargetingStrategy.java

@@ -9,20 +9,65 @@
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
+/**
+ * The {@code CustomMapObjectLoader} class extends the {@link MapObjectLoader} class to provide custom functionality for loading map objects into
+ * entities.
+ *
+ * <p>This class uses a functional interface {@code ConstructorInvocation} to dynamically
+ * invoke constructors of entity classes based on the provided {@link IMapObject} and {@link Environment}. It supports various constructor signatures
+ * and prioritizes them based on their parameter types.
+ *
+ * <p>It also overrides the {@code load} method to handle the creation and initialization
+ * of entities from map objects.
+ */
 public final class CustomMapObjectLoader extends MapObjectLoader {
   private static final Logger log = Logger.getLogger(CustomMapObjectLoader.class.getName());
   private final ConstructorInvocation invoke;
 
+  /**
+   * A functional interface for invoking constructors of entity classes.
+   *
+   * <p>This interface defines a single method {@code invoke}, which dynamically
+   * creates an instance of an {@link IEntity} using the provided {@link Environment} and {@link IMapObject}.
+   */
   @FunctionalInterface
   interface ConstructorInvocation {
     IEntity invoke(Environment environment, IMapObject mapObject) throws InvocationTargetException, IllegalAccessException, InstantiationException;
   }
 
+  /**
+   * Constructs a new {@code CustomMapObjectLoader} instance with the specified map object type and constructor invocation logic.
+   *
+   * <p>This constructor initializes the loader with a specific map object type and a functional
+   * interface for dynamically invoking constructors of entity classes.
+   *
+   * @param mapObjectType the type of the map object to be handled by this loader
+   * @param invocation    the {@link ConstructorInvocation} functional interface used to create entities
+   */
   CustomMapObjectLoader(String mapObjectType, ConstructorInvocation invocation) {
     super(mapObjectType);
     this.invoke = invocation;
   }
 
+  /**
+   * Finds the most suitable constructor for the specified entity type.
+   *
+   * <p>This method iterates through all constructors of the given entity class and determines
+   * the best match based on the parameter types. It prioritizes constructors in the following order:
+   * <ol>
+   *   <li>Constructor with parameters {@link Environment} and {@link IMapObject}</li>
+   *   <li>Constructor with parameters {@link IMapObject} and {@link Environment}</li>
+   *   <li>Constructor with a single {@link IMapObject} parameter</li>
+   *   <li>Constructor with a single {@link Environment} parameter</li>
+   *   <li>Default (no-argument) constructor</li>
+   * </ol>
+   *
+   * <p>If multiple constructors match, the one with the highest priority is selected.
+   *
+   * @param entityType the class of the entity for which a constructor is to be found
+   * @return a {@link ConstructorInvocation} functional interface for invoking the selected constructor, or {@code null} if no suitable constructor is
+   * uctor is found
+   */
   static ConstructorInvocation findConstructor(Class<? extends IEntity> entityType) {
     ConstructorInvocation inv = null;
 
@@ -65,7 +110,7 @@ public Collection<IEntity> load(Environment environment, IMapObject mapObject) {
     IEntity entity;
     try {
       entity = invoke.invoke(environment, mapObject);
-    } catch (ReflectiveOperationException e) {
+    } catch (ReflectiveOperationException _) {
       log.log(Level.SEVERE, "map object {} failed to load", mapObject.getId());
       return entities;
     }