Merge branch '1.21.5' into improvement/documentation2

Author: beanbag44

src/main/java/com/lambda/mixin/render/CapeFeatureRendererMixin.java

@@ -33,9 +33,12 @@
 public class CapeFeatureRendererMixin {
     @ModifyExpressionValue(method = "render(Lnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;ILnet/minecraft/client/render/entity/state/PlayerEntityRenderState;FF)V", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/util/SkinTextures;capeTexture()Lnet/minecraft/util/Identifier;"))
     Identifier renderCape(Identifier original, MatrixStack matrixStack, VertexConsumerProvider vertexConsumerProvider, int i, PlayerEntityRenderState player, float f, float g) {
-        var entity = Lambda.getMc().world.getEntityById(player.id);
-        if (!Capes.INSTANCE.isEnabled() || !CapeManager.INSTANCE.containsKey(entity.getUuid())) return original;
+        var entry = Lambda.getMc().getNetworkHandler().getPlayerListEntry(player.name);
+        if (entry == null) return original;
 
-        return Identifier.of("lambda", CapeManager.INSTANCE.get(entity.getUuid()));
+        var profile = entry.getProfile();
+        if (!Capes.INSTANCE.isEnabled() || !CapeManager.INSTANCE.getCache().containsKey(profile.getId())) return original;
+
+        return Identifier.of("lambda", CapeManager.INSTANCE.getCache().get(profile.getId()));
     }
 }

src/main/java/com/lambda/mixin/render/ElytraFeatureRendererMixin.java

@@ -17,37 +17,44 @@
 
 package com.lambda.mixin.render;
 
+import com.lambda.Lambda;
+import com.lambda.module.modules.client.Capes;
 import com.lambda.module.modules.render.NoRender;
-import com.llamalad7.mixinextras.injector.ModifyReturnValue;
+import com.lambda.network.CapeManager;
+import com.llamalad7.mixinextras.injector.wrapmethod.WrapMethod;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import net.minecraft.client.render.VertexConsumerProvider;
 import net.minecraft.client.render.entity.feature.ElytraFeatureRenderer;
 import net.minecraft.client.render.entity.state.BipedEntityRenderState;
+import net.minecraft.client.render.entity.state.PlayerEntityRenderState;
 import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.util.Identifier;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 @Mixin(ElytraFeatureRenderer.class)
 public class ElytraFeatureRendererMixin<T extends LivingEntity> {
-    @ModifyReturnValue(method = "getTexture(Lnet/minecraft/client/render/entity/state/BipedEntityRenderState;)Lnet/minecraft/util/Identifier;", at = @At("TAIL"))
-    private static Identifier getTexture(Identifier original, BipedEntityRenderState state) {
-        // FixMe: fuck you mojang
-        /*var entity = StreamSupport.stream(Lambda.getMc().world.getEntities().spliterator(), false)
-                        .filter(e -> e.getDisplayName() == state.displayName)
-                        .findFirst().get();
+    @WrapOperation(method = "render(Lnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;ILnet/minecraft/client/render/entity/state/BipedEntityRenderState;FF)V", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/entity/feature/ElytraFeatureRenderer;getTexture(Lnet/minecraft/client/render/entity/state/BipedEntityRenderState;)Lnet/minecraft/util/Identifier;"))
+    Identifier injectElytra(BipedEntityRenderState state, Operation<Identifier> original) {
+        if (!(state instanceof PlayerEntityRenderState))
+            return original.call(state);
 
-        if (!Capes.INSTANCE.isEnabled() || !CapeManager.INSTANCE.containsKey(entity.getUuid())) return original;
+        var entry = Lambda.getMc().getNetworkHandler().getPlayerListEntry(((PlayerEntityRenderState) state).name);
+        if (entry == null) return original.call(state);
 
-        return Identifier.of("lambda", CapeManager.INSTANCE.get(entity.getUuid()));*/
+        var profile = entry.getProfile();
 
-        return original;
+        if (!Capes.INSTANCE.isEnabled() || !CapeManager.INSTANCE.getCache().containsKey(profile.getId()))
+            return original.call(state);
+
+        return Identifier.of("lambda", CapeManager.INSTANCE.getCache().get(profile.getId()));
     }
 
-    @Inject(method = "render(Lnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;ILnet/minecraft/client/render/entity/state/BipedEntityRenderState;FF)V", at = @At("HEAD"), cancellable = true)
-    private void injectRender(MatrixStack matrixStack, VertexConsumerProvider vertexConsumerProvider, int i, BipedEntityRenderState bipedEntityRenderState, float f, float g, CallbackInfo ci) {
-        if (NoRender.INSTANCE.isEnabled() && NoRender.getNoElytra()) ci.cancel();
+    @WrapMethod(method = "render(Lnet/minecraft/client/util/math/MatrixStack;Lnet/minecraft/client/render/VertexConsumerProvider;ILnet/minecraft/client/render/entity/state/BipedEntityRenderState;FF)V")
+    private void injectRender(MatrixStack matrixStack, VertexConsumerProvider vertexConsumerProvider, int i, BipedEntityRenderState bipedEntityRenderState, float f, float g, Operation<Void> original) {
+        if (NoRender.INSTANCE.isDisabled() && !NoRender.getNoElytra())
+            original.call(matrixStack, vertexConsumerProvider, i, bipedEntityRenderState, f, g);
     }
 }

src/main/kotlin/com/lambda/command/commands/CapeCommand.kt

@@ -38,7 +38,7 @@ object CapeCommand : LambdaCommand(
         required(literal("set")) {
             required(string("id")) { id ->
                 suggests { _, builder ->
-                    CapeManager.capeList
+                    CapeManager.availableCapes
                         .forEach { builder.suggest(it) }
 
                     builder.buildFuture()

src/main/kotlin/com/lambda/network/CapeManager.kt

@@ -19,15 +19,16 @@ package com.lambda.network
 
 import com.lambda.Lambda.LOG
 import com.lambda.Lambda.mc
-import com.lambda.context.SafeContext
+import com.lambda.config.Configurable
+import com.lambda.config.configurations.SecretsConfig
 import com.lambda.core.Loadable
 import com.lambda.event.events.WorldEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
 import com.lambda.network.api.v1.endpoints.getCape
 import com.lambda.network.api.v1.endpoints.getCapes
 import com.lambda.network.api.v1.endpoints.setCape
+import com.lambda.threading.runGameScheduled
 import com.lambda.threading.runIO
-import com.lambda.threading.runSafe
 import com.lambda.util.FileUtils.createIfNotExists
 import com.lambda.util.FileUtils.downloadCompare
 import com.lambda.util.FileUtils.downloadIfNotPresent
@@ -44,25 +45,19 @@ import org.lwjgl.BufferUtils
 import java.util.*
 import java.util.concurrent.ConcurrentHashMap
 import kotlin.concurrent.fixedRateTimer
-import kotlin.io.path.extension
-import kotlin.io.path.inputStream
-import kotlin.io.path.nameWithoutExtension
-import kotlin.io.path.walk
 import kotlin.time.Duration.Companion.hours
 import kotlin.time.Duration.Companion.seconds
 
-@Suppress("JavaIoSerializableObjectMustHaveReadResolve")
-object CapeManager : ConcurrentHashMap<UUID, String>(), Loadable {
-    // We want to cache images to reduce class B requests
-    private val images = capes.walk()
-        .filter { it.extension == "png" }
-        .associate { it.nameWithoutExtension to NativeImageBackedTexture({ it.nameWithoutExtension }, read(it.inputStream())) }
-        .onEach { (key, value) -> mc.textureManager.registerTexture(key.asIdentifier, value) }
+object CapeManager : Configurable(SecretsConfig), Loadable {
+    override val name: String = "capes"
 
+    var currentCape by setting("cape", "")
+        .onValueChangeUnsafe { _, to -> updateCape(to) }
+
+    val cache = ConcurrentHashMap<UUID, String>()
     private val fetchQueue = mutableListOf<UUID>()
 
-    // We want to cache the cape list to reduce class B requests
-    val capeList = runBlocking {
+    val availableCapes = runBlocking {
         capes.resolveFile("capes.txt")
             .isOlderThan(24.hours) {
                 it.downloadIfNotPresent("${LambdaAPI.capes}.txt")
@@ -74,26 +69,15 @@ object CapeManager : ConcurrentHashMap<UUID, String>(), Loadable {
             }
             .createIfNotExists()
             .readText()
-            .split("\n")
+            .split(Regex("\\s+"))
     }
 
-    /**
-     * Sets the current player's cape
-     *
-     * @param block Lambda called once the coroutine completes, it contains the throwable if any
-     */
     fun updateCape(cape: String, block: (Throwable?) -> Unit = {}) = runIO {
         setCape(cape).getOrThrow()
-
-        runSafe { fetchCape(player.uuid) }
+        fetchCape(mc.gameProfile.id)
     }.invokeOnCompletion { block(it) }
 
-    /**
-     * Fetches the cape of the given player id
-     *
-     * @param block Lambda called once the coroutine completes, it contains the throwable if any
-     */
-    fun SafeContext.fetchCape(uuid: UUID, block: (Throwable?) -> Unit = {}) = runIO {
+    fun fetchCape(uuid: UUID, block: (Throwable?) -> Unit = {}) = runIO {
         val cape = getCape(uuid).getOrNull() ?: return@runIO
 
         val bytes = capes.resolveFile("${cape.id}.png")
@@ -107,12 +91,12 @@ object CapeManager : ConcurrentHashMap<UUID, String>(), Loadable {
 
         val image = read(NativeImage.Format.RGBA, buffer)
 
-        mc.textureManager.registerTexture(cape.id.asIdentifier, NativeImageBackedTexture({ cape.id }, image))
+        runGameScheduled { mc.textureManager.registerTexture(cape.id.asIdentifier, NativeImageBackedTexture({ cape.id }, image)) }
 
-        put(uuid, cape.id)
+        cache[uuid] = cape.id
     }.invokeOnCompletion { block(it) }
 
-    override fun load() = "Loaded ${images.size} cached capes and ${capeList.size} remote capes"
+    override fun load() = "Loaded ${availableCapes.size} capes"
 
     init {
         fixedRateTimer(
@@ -124,7 +108,7 @@ object CapeManager : ConcurrentHashMap<UUID, String>(), Loadable {
 
             runBlocking {
                 getCapes(fetchQueue)
-                    .onSuccess { it.forEach { cape -> put(cape.uuid, cape.id) } }
+                    .onSuccess { it.forEach { cape -> cache[cape.uuid] = cape.id } }
 
                 fetchQueue.clear()
             }