Merge branch 'master' into feature/renderer

Author: Avanatiker

build.gradle.kts

@@ -1,5 +1,11 @@
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 import net.fabricmc.loom.task.RemapJarTask
+import java.util.*
+
+val targets = listOf("META-INF/*.toml", "fabric.mod.json")
+val replacements = file("gradle.properties").inputStream().use { stream ->
+    Properties().apply { load(stream) }
+}.map { (k, v) -> k.toString() to v.toString() }.toMap()
 
 val modId = property("mod_id").toString()
 val modVersion = property("mod_version").toString()
@@ -13,7 +19,7 @@ plugins {
     kotlin("jvm") version "1.9.23"
     id("org.jetbrains.dokka") version "1.9.20"
     id("architectury-plugin") version "3.4-SNAPSHOT"
-    id("dev.architectury.loom") version "1.5-SNAPSHOT" apply false
+    id("dev.architectury.loom") version "1.6-SNAPSHOT" apply false
     id("com.github.johnrengelman.shadow") version "8.1.1" apply false
 }
 
@@ -30,15 +36,12 @@ subprojects {
         "mappings"("net.fabricmc:yarn:$yarnMappings:v2")
     }
 
-    repositories {
-        maven("https://babbaj.github.io/maven/")
-    }
-
     if (path == ":common") return@subprojects
 
     apply(plugin = "com.github.johnrengelman.shadow")
 
     val versionWithMCVersion = "$modVersion+$minecraftVersion"
+
     tasks {
         val shadowCommon by configurations.creating {
             isCanBeConsumed = false
@@ -61,6 +64,13 @@ subprojects {
         jar {
             enabled = false
         }
+
+        processResources {
+            // Replaces placeholders in the mod info files
+            filesMatching(targets) {
+                expand(replacements)
+            }
+        }
     }
 }
 
@@ -79,7 +89,9 @@ allprojects {
         maven("https://jitpack.io")
         maven("https://maven.shedaniel.me/") { name = "Architectury" }
         maven("https://maven.terraformersmc.com/releases/")
+        maven("https://babbaj.github.io/maven/")
 
+        // Allow the use of local libraries
         flatDir {
             dirs(libs)
         }

common/build.gradle.kts

@@ -1,15 +1,13 @@
-import java.util.Properties
-
 val fabricLoaderVersion = property("fabric_loader_version").toString()
 val mixinExtrasVersion = property("mixinextras_version").toString()
 val kotlinVersion = property("kotlin_version").toString()
 val kotlinxCoroutinesVersion = property("kotlinx_coroutines_version").toString()
 
-architectury { common("fabric", "forge", "neoforge", "quilt") }
+architectury { common("fabric", "forge", "neoforge") }
 
 loom {
     silentMojangMappingsLicense()
-    accessWidenerPath.set(File("src/main/resources/lambda.accesswidener"))
+    accessWidenerPath = File("src/main/resources/lambda.accesswidener")
 }
 
 repositories {
@@ -33,16 +31,9 @@ dependencies {
 }
 
 tasks {
+    // Prevent recursive libraries
     remapJar {
         enabled = false
     }
-
-    processResources {
-        Properties().apply {
-            load(project.rootProject.file("gradle.properties").inputStream())
-        }.forEach { key, value ->
-            inputs.property(key.toString(), value)
-        }
-    }
 }
 

common/src/main/java/com/lambda/mixin/entity/ClientPlayerEntityMixin.java

@@ -61,6 +61,11 @@ void processMovement(Input input, boolean slowDown, float slowDownFactor) {
         EventFlow.post(new MovementEvent.InputUpdate(input, slowDown, slowDownFactor));
     }
 
+    @Redirect(method = "tickMovement", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/network/ClientPlayerEntity;isSprinting()Z"))
+    boolean isSprinting(ClientPlayerEntity entity) {
+        return EventFlow.post(new MovementEvent.Sprint(entity.isSprinting())).getSprint();
+    }
+
     @Inject(method = "sendMovementPackets", at = @At(value = "HEAD"), cancellable = true)
     void sendBegin(CallbackInfo ci) {
         ci.cancel();

common/src/main/kotlin/com/lambda/brigadier/argument/MiscArguments.kt

@@ -0,0 +1,109 @@
+/*
+ * Copyright 2023 The Quilt Project
+ *
+ * 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.
+ */
+
+/*
+ * Preserve binary compatibility when moving extensions between files
+ */
+@file:JvmMultifileClass
+@file:JvmName("ArgumentsKt")
+
+package com.lambda.brigadier.argument
+
+import com.lambda.brigadier.*
+import com.lambda.brigadier.assumeSourceNotUsed
+import com.mojang.brigadier.arguments.ArgumentType
+import com.mojang.brigadier.arguments.IntegerArgumentType
+
+import com.mojang.brigadier.builder.LiteralArgumentBuilder
+import net.minecraft.command.argument.TimeArgumentType
+import net.minecraft.command.argument.UuidArgumentType
+import java.util.*
+
+/**
+ * Descriptor for a literal argument.
+ *
+ * Separate from [DefaultArgumentDescriptor]
+ * to stand out more in type hints.
+ */
+object LiteralDescriptor : ArgumentDescriptor<ArgumentType<*>>
+
+/**
+ * Reads the integer value in ticks from the
+ * argument in the receiver [ArgumentReader].
+ */
+@JvmName("valueTimeArg")
+@BrigadierDsl
+fun DefaultArgumentReader<TimeArgumentType>.value(): Int {
+    return IntegerArgumentType.getInteger(context, name)
+} // TimeArgumentType does not provide an accessor, defaulting to int
+
+/**
+ * Reads the [UUID] value from the
+ * argument in the receiver [ArgumentReader].
+ *
+ * @see UuidArgumentType.getUuid
+ */
+@JvmName("valueUuidArg")
+@BrigadierDsl
+fun DefaultArgumentReader<UuidArgumentType>.value(): UUID {
+    return UuidArgumentType.getUuid(context.assumeSourceNotUsed(), name)
+}
+
+/**
+ * Creates a time argument with [name] as the parameter name.
+ *
+ * @see TimeArgumentType.time
+ */
+@BrigadierDsl
+fun <S> time(
+    name: String,
+    minimumTicks: Int = 0
+): DefaultArgumentConstructor<S, TimeArgumentType> {
+    return argument(name, TimeArgumentType.time(minimumTicks))
+}
+
+/**
+ * Creates a UUID argument with [name] as the parameter name.
+ */
+@BrigadierDsl
+fun <S> uuid(
+    name: String
+): RequiredArgumentConstructor<
+        S,
+        DefaultArgumentDescriptor<
+                UuidArgumentType>
+        > {
+    return argument(name, UuidArgumentType.uuid())
+}
+
+/**
+ * Creates a literal argument with [name] as the literal.
+ *
+ * Like other arguments, literal arguments create accessors,
+ * which can be checked for presence of [optional] literals.
+ * However, [ArgumentReader]s produced from those accessors
+ * serve no purpose due to the argument not having a value.
+ */
+@BrigadierDsl
+fun <S> literal(
+    name: String
+): ArgumentConstructor<
+        S,
+        LiteralArgumentBuilder<S>,
+        LiteralDescriptor
+        > {
+    return ArgumentConstructor(LiteralArgumentBuilder.literal(name), name, LiteralDescriptor)
+}

common/src/main/kotlin/com/lambda/command/CommandManager.kt

@@ -31,19 +31,9 @@ object CommandManager : Configurable(LambdaConfig), Loadable {
     val prefix by setting("prefix", ';')
 
     val commands = mutableSetOf<LambdaCommand>()
-    private val dispatcher by lazy { CommandDispatcher<CommandSource>() }
+    val dispatcher by lazy { CommandDispatcher<CommandSource>() }
     private const val ERROR_PADDING = 10
 
-    fun register(
-        command: String,
-        vararg alias: String,
-        action: LiteralArgumentBuilder<CommandSource>.() -> Unit,
-    ) {
-        (listOf(command) + alias).forEach {
-            dispatcher.register(it, action)
-        }
-    }
-
     fun executeCommand(command: String) {
         runSafe {
             val isolatedCommand = command.drop(1)

common/src/main/kotlin/com/lambda/command/LambdaCommand.kt

@@ -1,5 +1,25 @@
 package com.lambda.command
 
+import com.lambda.command.CommandManager.dispatcher
 import com.lambda.util.Nameable
+import com.lambda.util.primitives.extension.CommandBuilder
+import com.mojang.brigadier.builder.LiteralArgumentBuilder
+import net.minecraft.command.CommandSource
 
-interface LambdaCommand : Nameable
+abstract class LambdaCommand(
+    final override val name: String,
+    val aliases: Set<String> = emptySet(),
+    val usage: String = "",
+    val description: String = "",
+) : Nameable {
+    // ToDo: Include usage and description in the help command
+    init {
+        (listOf(name) + aliases).forEach {
+            val argument = LiteralArgumentBuilder.literal<CommandSource>(it)
+            argument.create()
+            dispatcher.register(argument)
+        }
+    }
+
+    abstract fun CommandBuilder.create()
+}

common/src/main/kotlin/com/lambda/command/commands/ConfigCommand.kt

@@ -1,46 +1,30 @@
 package com.lambda.command.commands
 
-import com.lambda.brigadier.CommandResult.Companion.failure
-import com.lambda.brigadier.CommandResult.Companion.success
-import com.lambda.brigadier.argument.string
-import com.lambda.brigadier.argument.value
-import com.lambda.brigadier.argument.word
-import com.lambda.brigadier.executeWithResult
-import com.lambda.brigadier.optional
+import com.lambda.brigadier.argument.literal
+import com.lambda.brigadier.execute
 import com.lambda.brigadier.required
-import com.lambda.command.CommandManager.register
 import com.lambda.command.LambdaCommand
 import com.lambda.config.Configuration
+import com.lambda.util.primitives.extension.CommandBuilder
 
-object ConfigCommand : LambdaCommand {
-    override val name = "config"
-
-    init {
-        register(name, "cfg") {
-            required(word("action")) { action ->
-                val actions = listOf("save", "load")
-
-                suggests { _, builder ->
-                    actions.forEach {
-                        builder.suggest(it)
-                    }
-                    builder.buildFuture()
+object ConfigCommand : LambdaCommand(
+    name = "config",
+    aliases = setOf("cfg"),
+    usage = "config <save|load>",
+    description = "Save or load the configuration files"
+) {
+    override fun CommandBuilder.create() {
+        required(literal("save")) {
+            execute {
+                Configuration.configurations.forEach {
+                    it.trySave()
                 }
-
-                executeWithResult {
-                    val action = action().value()
-                    if (action !in actions) {
-                        return@executeWithResult failure("Invalid action $action. Did you mean ${actions.joinToString()}?")
-                    }
-
-                    Configuration.configurations.forEach {
-                        when (action) {
-                            "save" -> it.trySave()
-                            else -> it.tryLoad()
-                        }
-                    }
-
-                    success()
+            }
+        }
+        required(literal("load")) {
+            execute {
+                Configuration.configurations.forEach {
+                    it.tryLoad()
                 }
             }
         }