Combine 1.8.9 and 1.12.2 legacy versions in the same repository

build.gradle.kts

@@ -13,78 +13,87 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import dev.architectury.pack200.java.Pack200Adapter
-
 plugins {
     id("java")
-    alias(libs.plugins.ggEssentialLoom)
     alias(libs.plugins.spotless)
+    alias(libs.plugins.ggEssentialLoom) apply false
 }
 
-val modId = providers.gradleProperty("mod_id")
-val versionText = providers.gradleProperty("mod_version")
-val mavenGroup = providers.gradleProperty("maven_group")
+val groupTextProvider = providers.gradleProperty("maven_group")
+val versionTextProvider = providers.gradleProperty("mod_version")
+val modIdProvider = providers.gradleProperty("mod_id")
 
-version = versionText.get()
-group = mavenGroup.get()
+allprojects {
+    group = groupTextProvider.get()
+    version = versionTextProvider.get()
 
-base {
-    archivesName.set(modId)
+    repositories {
+        mavenCentral()
+    }
 }
 
-repositories {
-    mavenCentral()
-}
+subprojects {
+    apply(plugin = "java")
+    apply(plugin = rootProject.libs.plugins.spotless.get().pluginId)
 
-dependencies {
-    minecraft(libs.minecraft)
-    mappings(libs.mcpMappings)
-    forge(libs.forge)
-}
-
-loom {
-    forge {
-        pack200Provider.set(Pack200Adapter())
-        // accessTransformer("src/main/resources/META-INF/${modId.get()}_at.cfg")
+    val computedVersion = if (path.startsWith(":versions:")) {
+        "${versionTextProvider.get()}+$name"
+    } else {
+        versionTextProvider.get()
     }
-}
 
-java {
-    toolchain.languageVersion.set(JavaLanguageVersion.of(8))
-}
+    version = computedVersion
 
-tasks {
-    withType<JavaCompile> {
-        options.encoding = Charsets.UTF_8.name()
+    extra["versionText"] = computedVersion
+    extra["modIdText"] = modIdProvider.get()
+
+    base {
+        archivesName.set(modIdProvider.get())
     }
 
-    withType<ProcessResources> {
-        // https://github.com/gradle/gradle/issues/861
-        inputs.property("version", versionText.get())
-        inputs.property("mc_version", libs.versions.minecraft.get())
-        inputs.property("mod_id", modId.get())
-
-        filesMatching("mcmod.info") {
-            expand(
-                mapOf(
-                    "version" to versionText.get(),
-                    "mc_version" to libs.versions.minecraft.get(),
-                    "mod_id" to modId.get()
-                )
-            )
-        }
+    project(":versions").childProjects.values.forEach { versionProject ->
+        versionProject.apply(plugin = rootProject.libs.plugins.ggEssentialLoom.get().pluginId)
     }
 
-    jar {
-        from(layout.projectDirectory) {
-            include("LICENSE", "NOTICE")
+    java {
+        toolchain {
+            languageVersion.set(JavaLanguageVersion.of(8))
         }
     }
-}
 
-sourceSets {
-    main {
-        output.setResourcesDir(java.classesDirectory)
+    tasks {
+        withType<JavaCompile> {
+            options.encoding = Charsets.UTF_8.name()
+        }
+
+        withType<Jar> {
+            from(rootProject.layout.projectDirectory) {
+                include("LICENSE", "NOTICE")
+            }
+
+            manifest {
+                attributes(
+                    "Specification-Title" to rootProject.name,
+                    "Specification-Version" to versionTextProvider.get(),
+                    "Implementation-Title" to rootProject.name,
+                    "Implementation-Version" to versionTextProvider.get()
+                )
+            }
+
+            plugins.withId(rootProject.libs.plugins.ggEssentialLoom.get().pluginId) {
+                val remapJarTask = named("remapJar")
+
+                register<Copy>("copyRemappedJars") {
+                    dependsOn(remapJarTask)
+                    from(remapJarTask.map { it.outputs.files })
+                    into(rootProject.layout.buildDirectory.dir("libs"))
+                }
+
+                named("build") {
+                    finalizedBy("copyRemappedJars")
+                }
+            }
+        }
     }
 }
 
@@ -103,3 +112,9 @@ spotless {
         trimTrailingWhitespace()
     }
 }
+
+tasks {
+    named<Jar>("jar").configure {
+        enabled = false
+    }
+}

common/build.gradle.kts

@@ -0,0 +1,13 @@
+import org.gradle.kotlin.dsl.libs
+
+base {
+    archivesName.set("common")
+}
+
+@Suppress("VulnerableLibrariesLocal") // some libs need to stay at the game versions
+dependencies {
+    compileOnly(rootProject.libs.jetbrainsJavaAnnotations)
+    compileOnly(rootProject.libs.gson)
+    compileOnly(rootProject.libs.log4j)
+    compileOnly(rootProject.libs.guava)
+}

common/src/main/java/io/github/communityradargg/forgemod/command/CheckSubcommand.java

@@ -0,0 +1,134 @@
+/*
+ * Copyright 2024 - present CommunityRadarGG <https://community-radar.de/>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.github.communityradargg.forgemod.command;
+
+import io.github.communityradargg.forgemod.list.RadarListEntry;
+import io.github.communityradargg.forgemod.util.CommonHandler;
+import io.github.communityradargg.forgemod.util.Messages;
+import io.github.communityradargg.forgemod.util.PlayerInfo;
+import io.github.communityradargg.forgemod.util.RadarMessage;
+import java.util.Optional;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Holds the logic of the check subcommand.
+ */
+public class CheckSubcommand implements Subcommand {
+    private final CommonHandler commonHandler;
+    private final String[] args;
+
+    /**
+     * Constructs a {@link CheckSubcommand}.
+     *
+     * @param commonHandler The common handler.
+     * @param args The args.
+     */
+    public CheckSubcommand(final @NotNull CommonHandler commonHandler, final @NotNull String[] args) {
+        this.commonHandler = commonHandler;
+        this.args = args;
+    }
+
+    @Override
+    public void run() {
+        if (args.length != 2) {
+            // missing arguments
+            commonHandler.addMessageToChat(new RadarMessage.RadarMessageBuilder(Messages.MISSING_ARGS)
+                    .build().getMessage());
+            return;
+        }
+
+        if (args[1].equalsIgnoreCase("*")) {
+            // check all argument
+            handleCheckAllSubcommand();
+            return;
+        }
+        handleCheckPlayerSubcommand(args);
+    }
+
+    /**
+     * Handles the check - player subcommand.
+     *
+     * @param args The arguments passed to the main command.
+     */
+    private void handleCheckPlayerSubcommand(final @NotNull String[] args) {
+        commonHandler.addMessageToChat(new RadarMessage.RadarMessageBuilder(Messages.INPUT_PROCESSING)
+                .build().getMessage());
+        commonHandler.getUuidByPlayerName(commonHandler, args[1]).thenAccept(checkPlayerOptional -> {
+            if (!checkPlayerOptional.isPresent()) {
+                // player uuid could not be fetched
+                commonHandler.addMessageToChat(new RadarMessage.RadarMessageBuilder(Messages.Check.FAILED)
+                        .build().getMessage());
+                return;
+            }
+
+            final Optional<RadarListEntry> entryOptional = commonHandler.getListManager().getRadarListEntry(checkPlayerOptional.get());
+            if (!entryOptional.isPresent()) {
+                // player uuid is on no list
+                commonHandler.addMessageToChat(new RadarMessage.RadarMessageBuilder(Messages.Check.FAILED)
+                        .build().getMessage());
+                return;
+            }
+
+            final RadarListEntry entry = entryOptional.get();
+            commonHandler.addMessageToChat(new RadarMessage.RadarMessageBuilder(Messages.Check.FOUND + "\n" + Messages.Check.CHECK_ENTRY)
+                    .replaceWithColorCodes("{prefix}", commonHandler.getListManager().getPrefix(entry.uuid()))
+                    .replace("{name}", entry.name())
+                    .replace("{cause}", entry.cause())
+                    .replace("{entryCreationDate}", commonHandler.formatDateTime(entry.entryCreationDate()))
+                    .replace("{entryUpdateDate}", commonHandler.formatDateTime(entry.entryUpdateDate()))
+                    .build().getMessage());
+        });
+    }
+
+    /**
+     * Handles the check - all subcommand.
+     */
+    private void handleCheckAllSubcommand() {
+        boolean anyPlayerFound = false;
+        for (final PlayerInfo playerInfo : commonHandler.getWorldPlayers()) {
+            if (playerInfo.getUuid() == null) {
+                continue;
+            }
+
+            final Optional<RadarListEntry> listEntryOptional = commonHandler.getListManager()
+                    .getRadarListEntry(playerInfo.getUuid());
+            if (!listEntryOptional.isPresent()) {
+                // player uuid is on no list
+                continue;
+            }
+
+            if (!anyPlayerFound) {
+                commonHandler.addMessageToChat(new RadarMessage.RadarMessageBuilder(Messages.Check.EVERYONE)
+                        .build().getMessage());
+                anyPlayerFound = true;
+            }
+
+            final RadarListEntry entry = listEntryOptional.get();
+            commonHandler.addMessageToChat(new RadarMessage.RadarMessageBuilder(Messages.Check.CHECK_ENTRY)
+                    .replaceWithColorCodes("{prefix}", commonHandler.getListManager().getPrefix(entry.uuid()))
+                    .replace("{name}", entry.name())
+                    .replace("{cause}", entry.cause())
+                    .replace("{entryCreationDate}", commonHandler.formatDateTime(entry.entryCreationDate()))
+                    .replace("{entryUpdateDate}", commonHandler.formatDateTime(entry.entryUpdateDate()))
+                    .build().getMessage());
+        }
+
+        if (!anyPlayerFound) {
+            commonHandler.addMessageToChat(new RadarMessage.RadarMessageBuilder(Messages.Check.NOT_FOUND)
+                    .build().getMessage());
+        }
+    }
+}

src/main/java/io/github/communityradargg/forgemod/command/HelpSubcommand.java → common/src/main/java/io/github/communityradargg/forgemod/command/HelpSubcommand.java

@@ -15,35 +15,31 @@
  */
 package io.github.communityradargg.forgemod.command;
 
-import io.github.communityradargg.forgemod.CommunityRadarMod;
+import io.github.communityradargg.forgemod.util.CommonHandler;
 import io.github.communityradargg.forgemod.util.Messages;
 import io.github.communityradargg.forgemod.util.RadarMessage;
-import net.minecraft.entity.player.EntityPlayer;
 import org.jetbrains.annotations.NotNull;
 
 /**
  * Holds the logic of the help subcommand.
  */
 public class HelpSubcommand implements Subcommand {
-    private final CommunityRadarMod communityRadarMod;
-    private final EntityPlayer player;
+    private final CommonHandler commonHandler;
 
     /**
      * Constructs a {@link HelpSubcommand}.
      *
-     * @param communityRadarMod The mod main class instance.
-     * @param player The player.
+     * @param commonHandler The common handler
      */
-    public HelpSubcommand(final @NotNull CommunityRadarMod communityRadarMod, final @NotNull EntityPlayer player) {
-        this.communityRadarMod = communityRadarMod;
-        this.player = player;
+    public HelpSubcommand(final @NotNull CommonHandler commonHandler) {
+        this.commonHandler = commonHandler;
     }
 
     @Override
     public void run() {
-        player.addChatComponentMessage(new RadarMessage.RadarMessageBuilder(Messages.HELP)
-                .replace("{code_version}", communityRadarMod.getVersion())
+        commonHandler.addMessageToChat(new RadarMessage.RadarMessageBuilder(Messages.HELP)
+                .replace("{code_version}", commonHandler.getVersion())
                 .excludePrefix()
-                .build().toChatComponentText());
+                .build().getMessage());
     }
 }