the worst bug I encountered in gson 2.10.1

CHANGELOG.md

@@ -4,6 +4,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.5.0] - 2026-01-14
+### Added
+- Added collection skin provider (allows assigning random skins from a predefined set)
+- Added `forceFirstJoinSkinFetch` config option to force skin fetch on first join even if player already has a skin
+
 ## [2.4.3] - 2025-07-25
 ### Fixed
 - Fixed crash on client when loading player head skin (fixes [#63](https://github.com/Suiranoil/SkinRestorer/issues/63) and [#64](https://github.com/Suiranoil/SkinRestorer/issues/64))

CHANGELOG_LATEST.md

@@ -1,3 +1,3 @@
-### Fixed
-- Fixed crash on client when loading player head skin (fixes [#63](https://github.com/Suiranoil/SkinRestorer/issues/63) and [#64](https://github.com/Suiranoil/SkinRestorer/issues/64))
-- Fixed server freeze when loading player head skin
+### Added
+- Added collection skin provider (allows assigning random skins from a predefined set) (see [wiki](https://github.com/Suiranoil/SkinRestorer/wiki/Configuration#providerscollection))
+- Added `forceFirstJoinSkinFetch` config option to force skin fetch on first join even if player already has a skin (see [wiki](https://github.com/Suiranoil/SkinRestorer/wiki/Configuration#forcefirstjoinskinfetch))

build.gradle

@@ -1,6 +1,6 @@
 plugins {
     // see https://fabricmc.net/develop/ for new versions
-    id 'fabric-loom' version '1.10-SNAPSHOT' apply false
+    id 'fabric-loom' version '1.13-SNAPSHOT' apply false
     // see https://projects.neoforged.net/neoforged/moddevgradle for new versions
     id 'net.neoforged.moddev' version '2.0.+' apply false
     // see https://files.minecraftforge.net/net/minecraftforge/gradle/ForgeGradle/ for new versions

common/src/main/java/net/lionarius/skinrestorer/SkinRestorer.java

@@ -1,12 +1,12 @@
 package net.lionarius.skinrestorer;
 
 import com.google.common.base.Throwables;
-import com.mojang.authlib.GameProfile;
 import com.mojang.brigadier.CommandDispatcher;
 import net.lionarius.skinrestorer.command.SkinCommand;
 import net.lionarius.skinrestorer.config.Config;
 import net.lionarius.skinrestorer.config.provider.BuiltInProviderConfig;
 import net.lionarius.skinrestorer.exception.TransparentException;
+import net.lionarius.skinrestorer.mixin.PlayerAccessor;
 import net.lionarius.skinrestorer.platform.Services;
 import net.lionarius.skinrestorer.skin.SkinIO;
 import net.lionarius.skinrestorer.skin.SkinStorage;
@@ -15,7 +15,7 @@ import net.lionarius.skinrestorer.skin.provider.*;
 import net.lionarius.skinrestorer.translation.Translation;
 import net.lionarius.skinrestorer.util.*;
 import net.minecraft.commands.CommandSourceStack;
-import net.minecraft.resources.ResourceLocation;
+import net.minecraft.resources.Identifier;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.level.storage.LevelResource;
@@ -70,8 +70,8 @@ public final class SkinRestorer {
         return Optional.ofNullable(SkinRestorer.providersRegistry.get(name));
     }
     
-    public static ResourceLocation resourceLocation(String name) {
-        return new ResourceLocation(SkinRestorer.MOD_ID, name);
+    public static Identifier resourceLocation(String name) {
+        return Identifier.fromNamespaceAndPath(SkinRestorer.MOD_ID, name);
     }
     
     public static String assetPath(String name) {
@@ -88,6 +88,7 @@ public final class SkinRestorer {
         SkinRestorer.registerDefaultSkinProvider(MojangSkinProvider.PROVIDER_NAME, SkinProvider.MOJANG, SkinRestorer.getConfig().providersConfig().mojang());
         SkinRestorer.registerDefaultSkinProvider(ElyBySkinProvider.PROVIDER_NAME, SkinProvider.ELY_BY, SkinRestorer.getConfig().providersConfig().ely_by());
         SkinRestorer.registerDefaultSkinProvider(MineskinSkinProvider.PROVIDER_NAME, SkinProvider.MINESKIN, SkinRestorer.getConfig().providersConfig().mineskin());
+        SkinRestorer.registerDefaultSkinProvider(CollectionSkinProvider.PROVIDER_NAME, SkinProvider.COLLECTION, SkinRestorer.getConfig().providersConfig().collection());
     }
     
     private static void registerDefaultSkinProvider(String defaultName, SkinProvider provider, BuiltInProviderConfig config) {
@@ -106,25 +107,29 @@ public final class SkinRestorer {
         MojangSkinProvider.reload();
         ElyBySkinProvider.reload();
         MineskinSkinProvider.reload();
+        CollectionSkinProvider.reload();
     }
     
-    public static Collection<ServerPlayer> applySkin(MinecraftServer server, Iterable<GameProfile> targets, SkinValue value, boolean save) {
+    public static Collection<ServerPlayer> applySkin(MinecraftServer server, Iterable<ServerPlayer> targets, SkinValue value, boolean save) {
         var acceptedPlayers = new HashSet<ServerPlayer>();
         
-        for (var profile : targets) {
-            if (!SkinRestorer.getSkinStorage().hasSavedSkin(profile.getId()))
-                value = value.setOriginalValue(PlayerUtils.getPlayerSkin(profile));
+        for (var player : targets) {
+            var profile = player.getGameProfile();
+            var skin = PlayerUtils.getPlayerSkin(profile);
             
-            if (PlayerUtils.areSkinPropertiesEquals(value.value(), PlayerUtils.getPlayerSkin(profile)))
+            if (!SkinRestorer.getSkinStorage().hasSavedSkin(profile.id()))
+                value = value.setOriginalValue(skin);
+            
+            if (PlayerUtils.areSkinPropertiesEquals(value.value(), skin))
                 continue;
             
             if (save)
-                SkinRestorer.getSkinStorage().setSkin(profile.getId(), value);
+                SkinRestorer.getSkinStorage().setSkin(profile.id(), value);
             
-            PlayerUtils.applyRestoredSkin(profile, value.value());
+            var newProfile = PlayerUtils.applyRestoredSkin(profile, value.value());
+            ((PlayerAccessor) player).setGameProfile(newProfile);
             
-            var player = server.getPlayerList().getPlayer(profile.getId());
-            if (player == null)
+            if (player.connection == null)
                 continue;
             
             PlayerUtils.refreshPlayer(player);
@@ -136,13 +141,13 @@ public final class SkinRestorer {
         return acceptedPlayers;
     }
     
-    public static Collection<ServerPlayer> applySkin(MinecraftServer server, Iterable<GameProfile> targets, SkinValue value) {
+    public static Collection<ServerPlayer> applySkin(MinecraftServer server, Iterable<ServerPlayer> targets, SkinValue value) {
         return SkinRestorer.applySkin(server, targets, value, true);
     }
     
     public static CompletableFuture<Result<Collection<ServerPlayer>, String>> setSkinAsync(
             MinecraftServer server,
-            Collection<GameProfile> targets,
+            Collection<ServerPlayer> targets,
             SkinProviderContext context,
             boolean save
     ) {

common/src/main/java/net/lionarius/skinrestorer/command/SkinCommand.java

@@ -1,6 +1,5 @@
 package net.lionarius.skinrestorer.command;
 
-import com.mojang.authlib.GameProfile;
 import com.mojang.brigadier.CommandDispatcher;
 import com.mojang.brigadier.arguments.StringArgumentType;
 import com.mojang.brigadier.builder.ArgumentBuilder;
@@ -16,12 +15,15 @@ import net.lionarius.skinrestorer.skin.provider.SkinProviderContext;
 import net.lionarius.skinrestorer.translation.Translation;
 import net.lionarius.skinrestorer.util.PlayerUtils;
 import net.minecraft.commands.CommandSourceStack;
+import net.minecraft.commands.Commands;
 import net.minecraft.commands.arguments.GameProfileArgument;
 import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.players.NameAndId;
 
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashSet;
+import java.util.Objects;
 import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.function.Supplier;
@@ -54,7 +56,7 @@ public final class SkinCommand {
         
         base.then(
                 literal("config")
-                        .requires(commandSourceStack -> commandSourceStack.hasPermission(4))
+                        .requires(commandSourceStack -> Commands.LEVEL_OWNERS.check(commandSourceStack.permissions()))
                         .then(literal("reload").executes(SkinCommand::configReloadSubcommand))
         );
         
@@ -72,37 +74,41 @@ public final class SkinCommand {
         
         SkinProviderContext context = null;
         var save = true;
-        if (!SkinRestorer.getSkinStorage().hasSavedSkin(profile.getId())) {
-            if (profile.getProperties().containsKey(PlayerUtils.TEXTURES_KEY)) {
+        if (!SkinRestorer.getSkinStorage().hasSavedSkin(profile.id())) {
+            if (profile.properties().containsKey(PlayerUtils.TEXTURES_KEY)) {
                 save = false;
                 context = MojangSkinProvider.skinProviderContextFromProfile(profile);
             }
         } else {
-            context = SkinRestorer.getSkinStorage().getSkin(profile.getId()).toProviderContext();
+            context = SkinRestorer.getSkinStorage().getSkin(profile.id()).toProviderContext();
         }
         
         if (context == null)
             return 0;
         
-        return SkinCommand.setSubcommand(src, Collections.singleton(profile), context, save, false);
+        return SkinCommand.setSubcommand(src, Collections.singleton(new NameAndId(profile)), context, save, false);
     }
     
     private static int resetSubcommand(
             CommandSourceStack src,
-            Collection<GameProfile> targets,
+            Collection<NameAndId> targets,
             boolean setByOperator
     ) {
         var updatedPlayers = new HashSet<ServerPlayer>();
-        for (var profile : targets) {
+        for (var nameAndId : targets) {
             SkinValue skin = null;
-            if (SkinRestorer.getSkinStorage().hasSavedSkin(profile.getId()))
-                skin = SkinRestorer.getSkinStorage().getSkin(profile.getId()).replaceValueWithOriginal();
+            if (SkinRestorer.getSkinStorage().hasSavedSkin(nameAndId.id()))
+                skin = SkinRestorer.getSkinStorage().getSkin(nameAndId.id()).replaceValueWithOriginal();
             
             if (skin == null)
                 continue;
             
-            var updatedPlayer = SkinRestorer.applySkin(src.getServer(), Collections.singleton(profile), skin, false);
-            SkinRestorer.getSkinStorage().deleteSkin(profile.getId());
+            var player = src.getServer().getPlayerList().getPlayer(nameAndId.id());
+            if (player == null)
+                continue;
+            
+            var updatedPlayer = SkinRestorer.applySkin(src.getServer(), Collections.singleton(player), skin, false);
+            SkinRestorer.getSkinStorage().deleteSkin(nameAndId.id());
             
             updatedPlayers.addAll(updatedPlayer);
         }
@@ -118,19 +124,24 @@ public final class SkinCommand {
         if (src.getPlayer() == null)
             return 0;
         
-        return resetSubcommand(src, Collections.singleton(src.getPlayer().getGameProfile()), false);
+        return resetSubcommand(src, Collections.singleton(src.getPlayer().nameAndId()), false);
     }
     
     private static int setSubcommand(
             CommandSourceStack src,
-            Collection<GameProfile> targets,
+            Collection<NameAndId> targets,
             SkinProviderContext context,
             boolean save,
             boolean setByOperator
     ) {
         src.sendSystemMessage(Translation.translatableWithFallback(Translation.COMMAND_SKIN_LOADING_KEY));
         
-        SkinRestorer.setSkinAsync(src.getServer(), targets, context, save).thenAccept(result -> {
+        var profileTargets = targets.stream()
+                .map(nameAndId -> src.getServer().getPlayerList().getPlayer(nameAndId.id()))
+                .filter(Objects::nonNull)
+                .toList();
+        
+        SkinRestorer.setSkinAsync(src.getServer(), profileTargets, context, save).thenAccept(result -> {
             if (result.isError()) {
                 src.sendFailure(Translation.translatableWithFallback(
                         Translation.COMMAND_SKIN_FAILED_KEY,
@@ -149,7 +160,7 @@ public final class SkinCommand {
     
     private static int setSubcommand(
             CommandSourceStack src,
-            Collection<GameProfile> targets,
+            Collection<NameAndId> targets,
             SkinProviderContext context,
             boolean setByOperator
     ) {
@@ -163,7 +174,7 @@ public final class SkinCommand {
         if (src.getPlayer() == null)
             return 0;
         
-        return setSubcommand(src, Collections.singleton(src.getPlayer().getGameProfile()), context, false);
+        return setSubcommand(src, Collections.singleton(src.getPlayer().nameAndId()), context, false);
     }
     
     private static int configReloadSubcommand(CommandContext<CommandSourceStack> context) {
@@ -256,10 +267,10 @@ public final class SkinCommand {
     }
     
     private static RequiredArgumentBuilder<CommandSourceStack, GameProfileArgument.Result> makeTargetsArgument(
-            BiFunction<CommandContext<CommandSourceStack>, Collection<GameProfile>, Integer> consumer
+            BiFunction<CommandContext<CommandSourceStack>, Collection<NameAndId>, Integer> consumer
     ) {
         return argument("targets", GameProfileArgument.gameProfile())
-                .requires(source -> source.hasPermission(2))
+                .requires(source -> Commands.LEVEL_GAMEMASTERS.check(source.permissions()))
                 .executes(context -> consumer.apply(context, GameProfileArgument.getGameProfiles(context, "targets")));
     }
 }

common/src/main/java/net/lionarius/skinrestorer/compat/skinshuffle/SkinShuffleCompatibility.java

@@ -5,7 +5,7 @@ import net.lionarius.skinrestorer.platform.Services;
 import net.lionarius.skinrestorer.skin.SkinValue;
 import net.lionarius.skinrestorer.skin.provider.SkinShuffleSkinProvider;
 import net.lionarius.skinrestorer.util.PlayerUtils;
-import net.minecraft.resources.ResourceLocation;
+import net.minecraft.resources.Identifier;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.level.ServerPlayer;
 
@@ -23,8 +23,8 @@ public class SkinShuffleCompatibility {
         return SkinShuffleCompatibility.SHOULD_APPLY;
     }
     
-    public static ResourceLocation resourceLocation(String name) {
-        return new ResourceLocation(SkinShuffleCompatibility.MOD_ID, name);
+    public static Identifier resourceLocation(String name) {
+        return Identifier.fromNamespaceAndPath(SkinShuffleCompatibility.MOD_ID, name);
     }
     
     public static void onPlayerJoin(ServerPlayer player) {
@@ -43,7 +43,7 @@ public class SkinShuffleCompatibility {
         server.execute(() -> {
             SkinRestorer.applySkin(
                     server,
-                    Collections.singleton(player.getGameProfile()),
+                    Collections.singleton(player),
                     new SkinValue(SkinShuffleSkinProvider.PROVIDER_NAME, null, null, property),
                     !server.usesAuthentication()
             );

common/src/main/java/net/lionarius/skinrestorer/compat/skinshuffle/SkinShuffleHandshakePayload.java

@@ -1,23 +1,19 @@
 package net.lionarius.skinrestorer.compat.skinshuffle;
 
 import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.codec.StreamCodec;
 import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
-import net.minecraft.resources.ResourceLocation;
 import org.jetbrains.annotations.NotNull;
 
 public record SkinShuffleHandshakePayload() implements CustomPacketPayload {
-
+    
     public static final SkinShuffleHandshakePayload INSTANCE = new SkinShuffleHandshakePayload();
-
-    public static final ResourceLocation PACKET_ID = SkinShuffleCompatibility.resourceLocation("handshake");
-
-    @Override
-    public void write(@NotNull FriendlyByteBuf buf) {
-        // NO-OP
-    }
+    
+    public static final CustomPacketPayload.Type<SkinShuffleHandshakePayload> PACKET_ID = new CustomPacketPayload.Type<>(SkinShuffleCompatibility.resourceLocation("handshake"));
+    public static final StreamCodec<FriendlyByteBuf, SkinShuffleHandshakePayload> PACKET_CODEC = StreamCodec.unit(INSTANCE);
     
     @Override
-    public @NotNull ResourceLocation id() {
+    public CustomPacketPayload.@NotNull Type<? extends CustomPacketPayload> type() {
         return PACKET_ID;
     }
 }

common/src/main/java/net/lionarius/skinrestorer/compat/skinshuffle/SkinShuffleSkinRefreshV1Payload.java

@@ -2,14 +2,18 @@ package net.lionarius.skinrestorer.compat.skinshuffle;
 
 import com.mojang.authlib.properties.Property;
 import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.codec.StreamCodec;
 import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
-import net.minecraft.resources.ResourceLocation;
 import org.jetbrains.annotations.NotNull;
 
 public record SkinShuffleSkinRefreshV1Payload(
         Property textureProperty) implements CustomPacketPayload, SkinShuffleSkinRefreshPayload {
     
-    public static final ResourceLocation PACKET_ID = SkinShuffleCompatibility.resourceLocation("refresh");
+    public static final CustomPacketPayload.Type<SkinShuffleSkinRefreshV1Payload> PACKET_ID = new CustomPacketPayload.Type<>(SkinShuffleCompatibility.resourceLocation("refresh"));
+    public static final StreamCodec<FriendlyByteBuf, SkinShuffleSkinRefreshV1Payload> PACKET_CODEC = StreamCodec.of(
+            SkinShuffleSkinRefreshV1Payload::encode,
+            SkinShuffleSkinRefreshV1Payload::decode
+    );
     
     public static void encode(FriendlyByteBuf buf, SkinShuffleSkinRefreshV1Payload value) {
         var textureProperty = value.textureProperty();
@@ -24,12 +28,7 @@ public record SkinShuffleSkinRefreshV1Payload(
     }
     
     @Override
-    public void write(@NotNull FriendlyByteBuf buf) {
-        encode(buf, this);
-    }
-    
-    @Override
-    public @NotNull ResourceLocation id() {
+    public @NotNull CustomPacketPayload.Type<? extends CustomPacketPayload> type() {
         return PACKET_ID;
     }
 }

common/src/main/java/net/lionarius/skinrestorer/compat/skinshuffle/SkinShuffleSkinRefreshV2Payload.java

@@ -2,15 +2,19 @@ package net.lionarius.skinrestorer.compat.skinshuffle;
 
 import com.mojang.authlib.properties.Property;
 import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.codec.StreamCodec;
 import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
-import net.minecraft.resources.ResourceLocation;
 import org.jetbrains.annotations.NotNull;
 
 public record SkinShuffleSkinRefreshV2Payload(
         Property textureProperty) implements CustomPacketPayload, SkinShuffleSkinRefreshPayload {
     
-    public static final ResourceLocation PACKET_ID = SkinShuffleCompatibility.resourceLocation("skin_refresh");
-
+    public static final CustomPacketPayload.Type<SkinShuffleSkinRefreshV2Payload> PACKET_ID = new CustomPacketPayload.Type<>(SkinShuffleCompatibility.resourceLocation("skin_refresh"));
+    public static final StreamCodec<FriendlyByteBuf, SkinShuffleSkinRefreshV2Payload> PACKET_CODEC = StreamCodec.of(
+            SkinShuffleSkinRefreshV2Payload::encode,
+            SkinShuffleSkinRefreshV2Payload::decode
+    );
+    
     public static void encode(FriendlyByteBuf buf, SkinShuffleSkinRefreshV2Payload value) {
         var textureProperty = value.textureProperty();
         
@@ -23,7 +27,7 @@ public record SkinShuffleSkinRefreshV2Payload(
             buf.writeUtf(textureProperty.signature());
         }
     }
-
+    
     public static SkinShuffleSkinRefreshV2Payload decode(FriendlyByteBuf buf) {
         if (buf.readBoolean()) {
             return new SkinShuffleSkinRefreshV2Payload(new Property(buf.readUtf(), buf.readUtf(), buf.readUtf()));
@@ -32,12 +36,7 @@ public record SkinShuffleSkinRefreshV2Payload(
     }
     
     @Override
-    public void write(@NotNull FriendlyByteBuf buf) {
-        encode(buf, this);
-    }
-    
-    @Override
-    public @NotNull ResourceLocation id() {
+    public @NotNull CustomPacketPayload.Type<? extends CustomPacketPayload> type() {
         return PACKET_ID;
     }
 }

common/src/main/java/net/lionarius/skinrestorer/config/Config.java

@@ -22,6 +22,8 @@ public final class Config implements GsonPostProcessable {
     
     private boolean fetchSkinOnFirstJoin = true;
     
+    private boolean forceFirstJoinSkinFetch = false;
+    
     private FirstJoinSkinProvider firstJoinSkinProvider = FirstJoinSkinProvider.MOJANG;
     
     private String proxy = "";
@@ -47,6 +49,10 @@ public final class Config implements GsonPostProcessable {
         return this.fetchSkinOnFirstJoin;
     }
     
+    public boolean forceFirstJoinSkinFetch() {
+        return this.forceFirstJoinSkinFetch;
+    }
+    
     public FirstJoinSkinProvider firstJoinSkinProvider() {
         return this.firstJoinSkinProvider;
     }

common/src/main/java/net/lionarius/skinrestorer/config/FirstJoinSkinProvider.java

@@ -1,6 +1,7 @@
 package net.lionarius.skinrestorer.config;
 
 import com.google.gson.annotations.SerializedName;
+import net.lionarius.skinrestorer.skin.provider.CollectionSkinProvider;
 import net.lionarius.skinrestorer.skin.provider.ElyBySkinProvider;
 import net.lionarius.skinrestorer.skin.provider.MojangSkinProvider;
 
@@ -8,7 +9,9 @@ public enum FirstJoinSkinProvider {
     @SerializedName(value = "MOJANG", alternate = {"mojang"})
     MOJANG(MojangSkinProvider.PROVIDER_NAME),
     @SerializedName(value = "ELY.BY", alternate = {"ely.by", "ELY_BY", "ely_by"})
-    ELY_BY(ElyBySkinProvider.PROVIDER_NAME);
+    ELY_BY(ElyBySkinProvider.PROVIDER_NAME),
+    @SerializedName(value = "COLLECTION", alternate = {"collection"})
+    COLLECTION(CollectionSkinProvider.PROVIDER_NAME);
     
     private final String name;
     

common/src/main/java/net/lionarius/skinrestorer/config/provider/BuiltInProviderConfig.java

@@ -8,8 +8,13 @@ public abstract class BuiltInProviderConfig implements GsonPostProcessable {
     protected String name;
     protected CacheConfig cache;
     
+    
     public BuiltInProviderConfig(String name, CacheConfig cache) {
-        this.enabled = true;
+        this(name, cache, true);
+    }
+    
+    public BuiltInProviderConfig(String name, CacheConfig cache, boolean enabled) {
+        this.enabled = enabled;
         this.name = name;
         this.cache = cache;
     }

common/src/main/java/net/lionarius/skinrestorer/config/provider/ProvidersConfig.java

@@ -1,23 +1,27 @@
 package net.lionarius.skinrestorer.config.provider;
 
 import net.lionarius.skinrestorer.SkinRestorer;
+import net.lionarius.skinrestorer.config.provider.collection.CollectionProviderConfig;
 import net.lionarius.skinrestorer.util.gson.GsonPostProcessable;
 
 public final class ProvidersConfig implements GsonPostProcessable {
     public static final ProvidersConfig DEFAULT = new ProvidersConfig(
             new MojangProviderConfig(),
             new ElyByProviderConfig(),
-            new MineskinProviderConfig()
+            new MineskinProviderConfig(),
+            new CollectionProviderConfig()
     );
     
     private MojangProviderConfig mojang;
     private ElyByProviderConfig ely_by;
     private MineskinProviderConfig mineskin;
+    private CollectionProviderConfig collection;
     
-    public ProvidersConfig(MojangProviderConfig mojang, ElyByProviderConfig ely_by, MineskinProviderConfig mineskin) {
+    public ProvidersConfig(MojangProviderConfig mojang, ElyByProviderConfig ely_by, MineskinProviderConfig mineskin, CollectionProviderConfig collection) {
         this.mojang = mojang;
         this.ely_by = ely_by;
         this.mineskin = mineskin;
+        this.collection = collection;
     }
     
     public MojangProviderConfig mojang() {
@@ -32,6 +36,10 @@ public final class ProvidersConfig implements GsonPostProcessable {
         return this.mineskin;
     }
     
+    public CollectionProviderConfig collection() {
+        return this.collection;
+    }
+    
     @Override
     public void gsonPostProcess() {
         if (this.mojang == null) {
@@ -48,5 +56,10 @@ public final class ProvidersConfig implements GsonPostProcessable {
             SkinRestorer.LOGGER.warn("Mineskin provider config is null, using default");
             this.mineskin = ProvidersConfig.DEFAULT.mineskin();
         }
+        
+        if (this.collection == null) {
+            SkinRestorer.LOGGER.warn("Collection provider config is null, using default");
+            this.collection = ProvidersConfig.DEFAULT.collection();
+        }
     }
 }

common/src/main/java/net/lionarius/skinrestorer/config/provider/collection/CollectionProviderConfig.java

@@ -0,0 +1,32 @@
+package net.lionarius.skinrestorer.config.provider.collection;
+
+import com.google.gson.annotations.JsonAdapter;
+import net.lionarius.skinrestorer.config.provider.BuiltInProviderConfig;
+import net.lionarius.skinrestorer.config.provider.CacheConfig;
+import net.lionarius.skinrestorer.skin.provider.CollectionSkinProvider;
+import net.lionarius.skinrestorer.util.gson.GsonPostProcessable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public final class CollectionProviderConfig extends BuiltInProviderConfig implements GsonPostProcessable {
+    private static final CacheConfig DEFAULT_CACHE_VALUE = new CacheConfig(true, 604800);
+    
+    @JsonAdapter(CollectionSkinSourceListDeserializer.class)
+    private List<CollectionSkinSource> sources = new ArrayList<>();
+    
+    public CollectionProviderConfig() {
+        super(CollectionSkinProvider.PROVIDER_NAME, DEFAULT_CACHE_VALUE, false);
+    }
+    
+    public List<CollectionSkinSource> sources() {
+        return this.sources;
+    }
+    
+    @Override
+    public void gsonPostProcess() {
+        if (this.sources == null) {
+            this.sources = new ArrayList<>();
+        }
+    }
+}

common/src/main/java/net/lionarius/skinrestorer/config/provider/collection/CollectionSkinFile.java

@@ -0,0 +1,60 @@
+package net.lionarius.skinrestorer.config.provider.collection;
+
+import net.lionarius.skinrestorer.SkinRestorer;
+import net.lionarius.skinrestorer.skin.SkinVariant;
+import net.lionarius.skinrestorer.util.gson.GsonPostProcessable;
+import org.jetbrains.annotations.Nullable;
+
+import java.net.URI;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+public final class CollectionSkinFile implements CollectionSkinSource, GsonPostProcessable {
+    private String path = "";
+    private SkinVariant variant = SkinVariant.CLASSIC;
+    
+    @Override
+    public @Nullable URI uri() {
+        if (this.path.isEmpty())
+            return null;
+        
+        try {
+            var filePath = SkinRestorer.getConfigDir().resolve(this.path);
+            
+            if (!Files.exists(filePath)) {
+                SkinRestorer.LOGGER.warn("Skin file does not exist: {}", this.path);
+                return null;
+            }
+            
+            if (!Files.isRegularFile(filePath)) {
+                SkinRestorer.LOGGER.warn("Skin path is not a file: {}", this.path);
+                return null;
+            }
+            
+            if (!this.path.toLowerCase().endsWith(".png")) {
+                SkinRestorer.LOGGER.warn("Skin file is not a PNG file: {}", this.path);
+                return null;
+            }
+            
+            return filePath.toUri();
+        } catch (Exception e) {
+            SkinRestorer.LOGGER.warn("Invalid file path: {}", this.path, e);
+            return null;
+        }
+    }
+    
+    @Override
+    public SkinVariant variant() {
+        return this.variant;
+    }
+    
+    @Override
+    public void gsonPostProcess() {
+        if (this.path == null) {
+            this.path = "";
+        }
+        if (this.variant == null) {
+            this.variant = SkinVariant.CLASSIC;
+        }
+    }
+}

common/src/main/java/net/lionarius/skinrestorer/config/provider/collection/CollectionSkinSource.java

@@ -0,0 +1,12 @@
+package net.lionarius.skinrestorer.config.provider.collection;
+
+import net.lionarius.skinrestorer.skin.SkinVariant;
+import org.jetbrains.annotations.Nullable;
+
+import java.net.URI;
+
+public interface CollectionSkinSource {
+    @Nullable URI uri();
+    
+    SkinVariant variant();
+}

common/src/main/java/net/lionarius/skinrestorer/config/provider/collection/CollectionSkinSourceListDeserializer.java

@@ -0,0 +1,35 @@
+package net.lionarius.skinrestorer.config.provider.collection;
+
+import com.google.gson.*;
+
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.List;
+
+public class CollectionSkinSourceListDeserializer implements JsonSerializer<List<CollectionSkinSource>>, JsonDeserializer<List<CollectionSkinSource>> {
+    @Override
+    public JsonElement serialize(List<CollectionSkinSource> src, Type typeOfT, JsonSerializationContext context) {
+        return context.serialize(src, List.class);
+    }
+    
+    @Override
+    public List<CollectionSkinSource> deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
+            throws JsonParseException {
+        List<CollectionSkinSource> sources = new ArrayList<>();
+        
+        if (json.isJsonArray()) {
+            for (JsonElement element : json.getAsJsonArray()) {
+                if (element.isJsonObject()) {
+                    JsonObject obj = element.getAsJsonObject();
+                    if (obj.has("url")) {
+                        sources.add(context.deserialize(obj, CollectionSkinUrl.class));
+                    } else if (obj.has("path")) {
+                        sources.add(context.deserialize(obj, CollectionSkinFile.class));
+                    }
+                }
+            }
+        }
+        
+        return sources;
+    }
+}

common/src/main/java/net/lionarius/skinrestorer/config/provider/collection/CollectionSkinUrl.java

@@ -0,0 +1,41 @@
+package net.lionarius.skinrestorer.config.provider.collection;
+
+import net.lionarius.skinrestorer.SkinRestorer;
+import net.lionarius.skinrestorer.skin.SkinVariant;
+import net.lionarius.skinrestorer.util.gson.GsonPostProcessable;
+import org.jetbrains.annotations.Nullable;
+
+import java.net.URI;
+
+public final class CollectionSkinUrl implements CollectionSkinSource, GsonPostProcessable {
+    private String url = "";
+    private SkinVariant variant = SkinVariant.CLASSIC;
+    
+    @Override
+    public @Nullable URI uri() {
+        try {
+            if (this.url.isEmpty())
+                return null;
+            
+            return new URI(this.url);
+        } catch (Exception e) {
+            SkinRestorer.LOGGER.warn("Invalid URI: {}", this.url, e);
+            return null;
+        }
+    }
+    
+    @Override
+    public SkinVariant variant() {
+        return this.variant;
+    }
+    
+    @Override
+    public void gsonPostProcess() {
+        if (this.url == null) {
+            this.url = "";
+        }
+        if (this.variant == null) {
+            this.variant = SkinVariant.CLASSIC;
+        }
+    }
+}

common/src/main/java/net/lionarius/skinrestorer/mixin/GameProfileCacheAccessor.java

@@ -1,14 +0,0 @@
-package net.lionarius.skinrestorer.mixin;
-
-import net.minecraft.server.players.GameProfileCache;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.gen.Accessor;
-
-import java.util.Map;
-
-@Mixin(GameProfileCache.class)
-public interface GameProfileCacheAccessor {
-    
-    @Accessor
-    Map<String, GameProfileCache.GameProfileInfo> getProfilesByName();
-}

common/src/main/java/net/lionarius/skinrestorer/mixin/PlayerAccessor.java

@@ -0,0 +1,15 @@
+package net.lionarius.skinrestorer.mixin;
+
+import com.mojang.authlib.GameProfile;
+import net.minecraft.world.entity.player.Player;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Mutable;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+
+@Mixin(Player.class)
+public interface PlayerAccessor {
+    @Accessor("gameProfile")
+    @Mutable
+    void setGameProfile(GameProfile properties);
+}

common/src/main/java/net/lionarius/skinrestorer/mixin/PlayerListMixin.java

@@ -57,6 +57,6 @@ public abstract class PlayerListMixin {
     @Unique
     private static void skinrestorer$tryApplySkin(MinecraftServer server, ServerPlayer player) {
         if (SkinRestorer.getSkinStorage().hasSavedSkin(player.getUUID()))
-            SkinRestorer.applySkin(server, Collections.singleton(player.getGameProfile()), SkinRestorer.getSkinStorage().getSkin(player.getUUID()));
+            SkinRestorer.applySkin(server, Collections.singleton(player), SkinRestorer.getSkinStorage().getSkin(player.getUUID()));
     }
 }

common/src/main/java/net/lionarius/skinrestorer/mixin/ServerLoginPacketListenerImplMixin.java

@@ -2,6 +2,7 @@ package net.lionarius.skinrestorer.mixin;
 
 import com.mojang.authlib.GameProfile;
 import net.lionarius.skinrestorer.SkinRestorer;
+import net.lionarius.skinrestorer.config.FirstJoinSkinProvider;
 import net.lionarius.skinrestorer.skin.SkinValue;
 import net.lionarius.skinrestorer.skin.provider.SkinProviderContext;
 import net.lionarius.skinrestorer.util.PlayerUtils;
@@ -27,7 +28,7 @@ public abstract class ServerLoginPacketListenerImplMixin {
     private CompletableFuture<Void> skinrestorer$pendingSkin;
     
     @Inject(method = "verifyLoginAndFinishConnectionSetup", at = @At(value = "INVOKE",
-                                                                     target = "Lnet/minecraft/server/players/PlayerList;canPlayerLogin(Ljava/net/SocketAddress;Lcom/mojang/authlib/GameProfile;)Lnet/minecraft/network/chat/Component;"),
+                                                                     target = "Lnet/minecraft/server/players/PlayerList;canPlayerLogin(Ljava/net/SocketAddress;Lnet/minecraft/server/players/NameAndId;)Lnet/minecraft/network/chat/Component;"),
             cancellable = true)
     public void waitForSkin(CallbackInfo ci) {
         if (skinrestorer$pendingSkin == null) {
@@ -37,14 +38,14 @@ public abstract class ServerLoginPacketListenerImplMixin {
                 assert profile != null;
                 var originalSkin = PlayerUtils.getPlayerSkin(profile);
                 
-                if (SkinRestorer.getSkinStorage().hasSavedSkin(profile.getId())) {
+                if (SkinRestorer.getSkinStorage().hasSavedSkin(profile.id())) {
                     if (originalSkin != null) { // update to the latest official skin
-                        var value = SkinRestorer.getSkinStorage().getSkin(profile.getId());
-                        SkinRestorer.getSkinStorage().setSkin(profile.getId(), value.setOriginalValue(originalSkin));
+                        var value = SkinRestorer.getSkinStorage().getSkin(profile.id());
+                        SkinRestorer.getSkinStorage().setSkin(profile.id(), value.setOriginalValue(originalSkin));
                     }
                     
                     if (SkinRestorer.getConfig().refreshSkinOnJoin()) {
-                        var currentSkin = SkinRestorer.getSkinStorage().getSkin(profile.getId());
+                        var currentSkin = SkinRestorer.getSkinStorage().getSkin(profile.id());
                         var context = currentSkin.toProviderContext();
                         
                         skinrestorer$fetchSkin(profile, context);
@@ -53,10 +54,16 @@ public abstract class ServerLoginPacketListenerImplMixin {
                     return null;
                 }
                 
-                if (originalSkin == null && SkinRestorer.getConfig().fetchSkinOnFirstJoin()) {
+                var config = SkinRestorer.getConfig();
+                var provider = config.firstJoinSkinProvider();
+                
+                var shouldFetch = (originalSkin == null && config.fetchSkinOnFirstJoin()) ||
+                                      (originalSkin != null && config.forceFirstJoinSkinFetch() && provider != FirstJoinSkinProvider.MOJANG);
+                
+                if (shouldFetch) {
                     var context = new SkinProviderContext(
-                            SkinRestorer.getConfig().firstJoinSkinProvider().getName(),
-                            profile.getName(),
+                            provider.getName(),
+                            profile.name(),
                             null
                     );
                     skinrestorer$fetchSkin(profile, context);
@@ -72,7 +79,7 @@ public abstract class ServerLoginPacketListenerImplMixin {
     
     @Unique
     private static void skinrestorer$fetchSkin(GameProfile profile, SkinProviderContext context) {
-        SkinRestorer.LOGGER.debug("Fetching {}'s skin", profile.getName());
+        SkinRestorer.LOGGER.debug("Fetching {}'s skin", profile.name());
         
         var result = SkinRestorer.getProvider(context.name()).map(
                 provider -> provider.fetchSkin(context.argument(), context.variant())
@@ -80,7 +87,7 @@ public abstract class ServerLoginPacketListenerImplMixin {
         
         if (!result.isError()) {
             var value = SkinValue.fromProviderContextWithValue(context, result.getSuccessValue().orElse(null));
-            SkinRestorer.getSkinStorage().setSkin(profile.getId(), value);
+            SkinRestorer.getSkinStorage().setSkin(profile.id(), value);
         } else {
             SkinRestorer.LOGGER.warn("Failed to fetch skin '{}:{}'", context.name(), context.argument(), result.getErrorValue());
         }

common/src/main/java/net/lionarius/skinrestorer/mixin/SkullBlockEntityMixin.java

@@ -1,66 +0,0 @@
-package net.lionarius.skinrestorer.mixin;
-
-import com.mojang.authlib.GameProfile;
-import net.lionarius.skinrestorer.SkinRestorer;
-import net.lionarius.skinrestorer.util.PlayerUtils;
-import net.minecraft.Util;
-import net.minecraft.server.Services;
-import net.minecraft.server.players.GameProfileCache;
-import net.minecraft.world.level.block.entity.SkullBlockEntity;
-import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.Shadow;
-import org.spongepowered.asm.mixin.Unique;
-import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-
-import java.util.Locale;
-import java.util.Optional;
-import java.util.UUID;
-import java.util.concurrent.CompletableFuture;
-import java.util.function.BooleanSupplier;
-
-@Mixin(SkullBlockEntity.class)
-public abstract class SkullBlockEntityMixin {
-    
-    @Shadow
-    private static GameProfileCache profileCache;
-    
-    @Inject(method = "fetchGameProfile", at = @At("HEAD"),
-            cancellable = true)
-    private static void fetchProfileByName(String name, CallbackInfoReturnable<CompletableFuture<Optional<GameProfile>>> cir) {
-        if (profileCache == null)
-            return;
-        
-        if (name == null)
-            return;
-        
-        var profileOpt = Optional.<GameProfile>empty();
-        var gameProfileInfo = ((GameProfileCacheAccessor) profileCache).getProfilesByName().get(name.toLowerCase(Locale.ROOT));
-        
-        if (gameProfileInfo != null)
-            profileOpt = Optional.of(gameProfileInfo.getProfile());
-        
-        skinrestorer$replaceSkin(profileOpt, cir);
-    }
-    
-    @Unique
-    private static void skinrestorer$replaceSkin(Optional<GameProfile> profileOpt, CallbackInfoReturnable<CompletableFuture<Optional<GameProfile>>> cir) {
-        if (SkinRestorer.getMinecraftServer() == null)
-            return;
-        
-        if (profileOpt.isEmpty())
-            return;
-        
-        var profile = PlayerUtils.cloneGameProfile(profileOpt.get());
-        
-        if (SkinRestorer.getSkinStorage().hasSavedSkin(profile.getId())) {
-            cir.setReturnValue(CompletableFuture.supplyAsync(() -> {
-                var skin = SkinRestorer.getSkinStorage().getSkin(profile.getId(), false);
-                PlayerUtils.applyRestoredSkin(profile, skin.value());
-                
-                return Optional.of(profile);
-            }, Util.backgroundExecutor()));
-        }
-    }
-}

common/src/main/java/net/lionarius/skinrestorer/skin/SkinVariant.java

@@ -1,8 +1,11 @@
 package net.lionarius.skinrestorer.skin;
 
+import com.google.gson.annotations.SerializedName;
+
 public enum SkinVariant {
-    
+    @SerializedName(value = "classic", alternate = {"CLASSIC"})
     CLASSIC("classic"),
+    @SerializedName(value = "slim", alternate = {"SLIM"})
     SLIM("slim");
     
     private final String name;

common/src/main/java/net/lionarius/skinrestorer/skin/provider/CollectionSkinProvider.java

@@ -0,0 +1,91 @@
+package net.lionarius.skinrestorer.skin.provider;
+
+import com.google.common.cache.CacheBuilder;
+import com.google.common.cache.CacheLoader;
+import com.google.common.cache.LoadingCache;
+import com.google.common.util.concurrent.UncheckedExecutionException;
+import com.mojang.authlib.properties.Property;
+import it.unimi.dsi.fastutil.Pair;
+import net.lionarius.skinrestorer.SkinRestorer;
+import net.lionarius.skinrestorer.config.provider.collection.CollectionSkinSource;
+import net.lionarius.skinrestorer.skin.SkinVariant;
+import net.lionarius.skinrestorer.util.Result;
+import org.jetbrains.annotations.NotNull;
+
+import java.net.URI;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.TimeUnit;
+
+public final class CollectionSkinProvider implements SkinProvider {
+    
+    public static final String PROVIDER_NAME = "collection";
+    
+    private static LoadingCache<Integer, Optional<Property>> SKIN_CACHE;
+    
+    private static List<Pair<URI, SkinVariant>> COLLECTION_SKINS;
+    
+    public static void reload() {
+        COLLECTION_SKINS = loadCollectionSkins();
+        
+        createCache();
+    }
+    
+    private static List<Pair<URI, SkinVariant>> loadCollectionSkins() {
+        List<Pair<URI, SkinVariant>> skins = new ArrayList<>();
+        
+        var config = SkinRestorer.getConfig().providersConfig().collection();
+        
+        for (CollectionSkinSource source : config.sources()) {
+            var uri = source.uri();
+            if (uri != null) {
+                skins.add(Pair.of(uri, source.variant()));
+            }
+        }
+        
+        return skins;
+    }
+    
+    private static void createCache() {
+        var config = SkinRestorer.getConfig().providersConfig().collection();
+        var time = config.cache().enabled() ? config.cache().duration() : 0;
+        
+        SKIN_CACHE = CacheBuilder.newBuilder()
+                .expireAfterWrite(time, TimeUnit.SECONDS)
+                .build(new CacheLoader<>() {
+                    @Override
+                    public @NotNull Optional<Property> load(@NotNull Integer key) throws Exception {
+                        var skinEntry = COLLECTION_SKINS.get(key);
+                        return MineskinSkinProvider.loadSkin(skinEntry.first(), skinEntry.second());
+                    }
+                });
+    }
+    
+    @Override
+    public String getArgumentName() {
+        return "seed";
+    }
+    
+    @Override
+    public boolean hasVariantSupport() {
+        return false;
+    }
+    
+    @Override
+    public Result<Optional<Property>, Exception> fetchSkin(String argument, SkinVariant variant) {
+        if (COLLECTION_SKINS.isEmpty()) {
+            return Result.error(new IllegalStateException("No collection skins configured"));
+        }
+        
+        var skinIndex = Math.abs(argument.hashCode()) % COLLECTION_SKINS.size();
+        
+        try {
+            return Result.success(SKIN_CACHE.get(skinIndex));
+        } catch (UncheckedExecutionException e) {
+            return Result.error((Exception) e.getCause());
+        } catch (Exception e) {
+            return Result.error(e);
+        }
+    }
+}

common/src/main/java/net/lionarius/skinrestorer/skin/provider/ElyBySkinProvider.java

@@ -9,7 +9,11 @@ import com.mojang.authlib.properties.Property;
 import com.mojang.authlib.yggdrasil.response.MinecraftProfilePropertiesResponse;
 import net.lionarius.skinrestorer.SkinRestorer;
 import net.lionarius.skinrestorer.skin.SkinVariant;
-import net.lionarius.skinrestorer.util.*;
+import net.lionarius.skinrestorer.util.JsonUtils;
+import net.lionarius.skinrestorer.util.PlayerUtils;
+import net.lionarius.skinrestorer.util.Result;
+import net.lionarius.skinrestorer.util.WebUtils;
+import net.minecraft.util.StringUtil;
 import org.jetbrains.annotations.NotNull;
 
 import java.io.IOException;
@@ -67,7 +71,7 @@ public final class ElyBySkinProvider implements SkinProvider {
     @Override
     public Result<Optional<Property>, Exception> fetchSkin(String username, SkinVariant variant) {
         try {
-            if (!StringUtils.isValidPlayerName(username))
+            if (!StringUtil.isValidPlayerName(username))
                 throw new IllegalArgumentException("invalid username");
             
             var usernameLowerCase = username.toLowerCase(Locale.ROOT);
@@ -102,6 +106,6 @@ public final class ElyBySkinProvider implements SkinProvider {
         if (response.statusCode() != 200)
             throw new IllegalArgumentException("no profile with name " + username);
         
-        return JsonUtils.fromJson(response.body(), MinecraftProfilePropertiesResponse.class).toProfile();
+        return JsonUtils.fromJson(response.body(), MinecraftProfilePropertiesResponse.class).profile();
     }
 }

common/src/main/java/net/lionarius/skinrestorer/skin/provider/MineskinSkinProvider.java

@@ -22,6 +22,8 @@ import org.mineskin.response.QueueResponse;
 
 import java.net.InetSocketAddress;
 import java.net.URI;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.time.Duration;
 import java.util.Optional;
 import java.util.concurrent.TimeUnit;
@@ -94,13 +96,18 @@ public final class MineskinSkinProvider implements SkinProvider {
         }
     }
     
-    private static Optional<Property> loadSkin(URI uri, SkinVariant variant) throws Exception {
+    static Optional<Property> loadSkin(URI uri, SkinVariant variant) throws Exception {
         var mineskinVariant = switch (variant) {
             case CLASSIC -> Variant.CLASSIC;
             case SLIM -> Variant.SLIM;
         };
         
-        var request = GenerateRequest.url(uri)
+        var request = "file".equals(uri.getScheme())
+                ? GenerateRequest.upload(Files.newInputStream(Path.of(uri)))
+                .variant(mineskinVariant)
+                .name("skinrestorer-skin")
+                .visibility(Visibility.UNLISTED)
+                : GenerateRequest.url(uri)
                 .variant(mineskinVariant)
                 .name("skinrestorer-skin")
                 .visibility(Visibility.UNLISTED);

common/src/main/java/net/lionarius/skinrestorer/skin/provider/MojangSkinProvider.java

@@ -8,12 +8,17 @@ import com.mojang.authlib.*;
 import com.mojang.authlib.properties.Property;
 import com.mojang.authlib.yggdrasil.YggdrasilEnvironment;
 import com.mojang.authlib.yggdrasil.response.MinecraftProfilePropertiesResponse;
+import com.mojang.authlib.yggdrasil.response.NameAndId;
 import com.mojang.util.UndashedUuid;
 import net.lionarius.skinrestorer.SkinRestorer;
 import net.lionarius.skinrestorer.exception.TransparentException;
 import net.lionarius.skinrestorer.skin.SkinVariant;
-import net.lionarius.skinrestorer.util.*;
-import net.minecraft.server.players.GameProfileCache;
+import net.lionarius.skinrestorer.util.JsonUtils;
+import net.lionarius.skinrestorer.util.PlayerUtils;
+import net.lionarius.skinrestorer.util.Result;
+import net.lionarius.skinrestorer.util.WebUtils;
+import net.minecraft.server.players.CachedUserNameToIdResolver;
+import net.minecraft.util.StringUtil;
 import org.jetbrains.annotations.NotNull;
 
 import java.io.IOException;
@@ -27,13 +32,11 @@ import java.util.concurrent.TimeUnit;
 public final class MojangSkinProvider implements SkinProvider {
     
     public static final String PROVIDER_NAME = "mojang";
-    
+    public static final String PROFILE_CACHE_FILENAME = "mojang_profile_cache.json";
     private static final Environment ENVIRONMENT;
     private static final URI SERVICES_SERVER_URI;
     private static final URI SESSION_SERVER_URI;
-    
-    public static final String PROFILE_CACHE_FILENAME = "mojang_profile_cache.json";
-    private static final GameProfileCache PROFILE_CACHE;
+    private static final CachedUserNameToIdResolver PROFILE_CACHE;
     
     private static LoadingCache<UUID, Optional<Property>> SKIN_CACHE;
     
@@ -47,11 +50,24 @@ public final class MojangSkinProvider implements SkinProvider {
             throw new IllegalArgumentException(e);
         }
         
-        PROFILE_CACHE = new GameProfileCache((names, callback) -> {
-            for (var name : names) {
+        PROFILE_CACHE = new CachedUserNameToIdResolver(new GameProfileRepository() {
+            @Override
+            public void findProfilesByNames(String[] names, ProfileLookupCallback callback) {
+                for (var name : names) {
+                    try {
+                        var profile = MojangSkinProvider.getProfile(name);
+                        callback.onProfileLookupSucceeded(profile.name(), profile.id());
+                    } catch (IOException e) {
+                        throw new TransparentException(e);
+                    }
+                }
+            }
+            
+            @Override
+            public Optional<NameAndId> findProfileByName(String name) {
                 try {
                     var profile = MojangSkinProvider.getProfile(name);
-                    callback.onProfileLookupSucceeded(profile);
+                    return Optional.of(new NameAndId(profile.id(), profile.name()));
                 } catch (IOException e) {
                     throw new TransparentException(e);
                 }
@@ -78,7 +94,7 @@ public final class MojangSkinProvider implements SkinProvider {
     }
     
     public static SkinProviderContext skinProviderContextFromProfile(GameProfile gameProfile) {
-        return new SkinProviderContext(MojangSkinProvider.PROVIDER_NAME, gameProfile.getName(), null);
+        return new SkinProviderContext(MojangSkinProvider.PROVIDER_NAME, gameProfile.name(), null);
     }
     
     @Override
@@ -94,14 +110,14 @@ public final class MojangSkinProvider implements SkinProvider {
     @Override
     public Result<Optional<Property>, Exception> fetchSkin(String username, SkinVariant variant) {
         try {
-            if (!StringUtils.isValidPlayerName(username))
+            if (!StringUtil.isValidPlayerName(username))
                 throw new IllegalArgumentException("invalid username");
             
             var cachedProfile = MojangSkinProvider.PROFILE_CACHE.get(username);
             if (cachedProfile.isEmpty())
                 throw new IllegalArgumentException("no profile found for " + username);
             
-            return Result.success(SKIN_CACHE.get(cachedProfile.get().getId()));
+            return Result.success(SKIN_CACHE.get(cachedProfile.get().id()));
         } catch (UncheckedExecutionException e) {
             return Result.error((Exception) e.getCause());
         } catch (Exception e) {
@@ -116,7 +132,7 @@ public final class MojangSkinProvider implements SkinProvider {
         return Optional.ofNullable(textures);
     }
     
-    private static GameProfile getProfile(final String name) throws IOException {
+    private static NameAndId getProfile(final String name) throws IOException {
         var request = HttpRequest.newBuilder()
                 .uri(MojangSkinProvider.SERVICES_SERVER_URI
                         .resolve("/minecraft/profile/lookup/name/")
@@ -131,7 +147,7 @@ public final class MojangSkinProvider implements SkinProvider {
         if (response.statusCode() != 200)
             throw new IllegalArgumentException("no profile with name " + name);
         
-        return JsonUtils.fromJson(response.body(), GameProfile.class);
+        return JsonUtils.fromJson(response.body(), NameAndId.class);
     }
     
     private static GameProfile getProfileWithProperties(UUID uuid) throws IOException {
@@ -149,6 +165,6 @@ public final class MojangSkinProvider implements SkinProvider {
         if (response.statusCode() != 200)
             throw new IllegalArgumentException("no profile with uuid " + uuid);
         
-        return JsonUtils.fromJson(response.body(), MinecraftProfilePropertiesResponse.class).toProfile();
+        return JsonUtils.fromJson(response.body(), MinecraftProfilePropertiesResponse.class).profile();
     }
 }

common/src/main/java/net/lionarius/skinrestorer/skin/provider/SkinProvider.java

@@ -13,6 +13,7 @@ public interface SkinProvider {
     MojangSkinProvider MOJANG = new MojangSkinProvider();
     ElyBySkinProvider ELY_BY = new ElyBySkinProvider();
     MineskinSkinProvider MINESKIN = new MineskinSkinProvider();
+    CollectionSkinProvider COLLECTION = new CollectionSkinProvider();
     SkinShuffleSkinProvider SKIN_SHUFFLE = new SkinShuffleSkinProvider();
     
     Set<String> BUILTIN_PROVIDER_NAMES = ImmutableSet.of(
@@ -20,6 +21,7 @@ public interface SkinProvider {
             MojangSkinProvider.PROVIDER_NAME,
             ElyBySkinProvider.PROVIDER_NAME,
             MineskinSkinProvider.PROVIDER_NAME,
+            CollectionSkinProvider.PROVIDER_NAME,
             SkinShuffleSkinProvider.PROVIDER_NAME
     );
     

common/src/main/java/net/lionarius/skinrestorer/util/JsonUtils.java

@@ -4,7 +4,6 @@ import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
-import com.mojang.authlib.GameProfile;
 import com.mojang.authlib.properties.Property;
 import com.mojang.authlib.properties.PropertyMap;
 import com.mojang.util.UUIDTypeAdapter;
@@ -22,7 +21,6 @@ public final class JsonUtils {
             .registerTypeAdapterFactory(new PostProcessingEnabler())
             .registerTypeAdapter(UUID.class, new UUIDTypeAdapter())
             .registerTypeAdapter(PropertyMap.class, new PropertyMap.Serializer())
-            .registerTypeAdapter(GameProfile.class, new GameProfile.Serializer())
             .setPrettyPrinting()
             .create();
     

common/src/main/java/net/lionarius/skinrestorer/util/PlayerUtils.java

@@ -1,12 +1,13 @@
 package net.lionarius.skinrestorer.util;
 
 import com.google.common.collect.Iterables;
+import com.google.common.collect.LinkedHashMultimap;
 import com.google.gson.JsonObject;
 import com.mojang.authlib.GameProfile;
 import com.mojang.authlib.properties.Property;
+import com.mojang.authlib.properties.PropertyMap;
 import com.mojang.authlib.yggdrasil.response.MinecraftProfilePropertiesResponse;
 import net.lionarius.skinrestorer.mixin.ChunkMapAccessor;
-import net.lionarius.skinrestorer.mixin.TrackedEntityAccessorInvoker;
 import net.minecraft.network.chat.Component;
 import net.minecraft.network.protocol.game.*;
 import net.minecraft.server.level.ChunkMap;
@@ -39,7 +40,7 @@ public final class PlayerUtils {
     }
     
     public static void refreshPlayer(ServerPlayer player) {
-        ServerLevel serverLevel = player.serverLevel();
+        ServerLevel serverLevel = player.level();
         PlayerList playerList = serverLevel.getServer().getPlayerList();
         ChunkMap chunkMap = serverLevel.getChunkSource().chunkMap;
         
@@ -67,7 +68,12 @@ public final class PlayerUtils {
         }
         
         if (!player.isDeadOrDying()) {
-            player.connection.send(new ClientboundRespawnPacket(player.createCommonSpawnInfo(serverLevel), ClientboundRespawnPacket.KEEP_ALL_DATA));
+            player.connection.send(new ClientboundBundlePacket(
+                    List.of(
+                            new ClientboundRespawnPacket(player.createCommonSpawnInfo(serverLevel), ClientboundRespawnPacket.KEEP_ALL_DATA),
+                            new ClientboundGameEventPacket(ClientboundGameEventPacket.LEVEL_CHUNKS_LOAD_START, 0)
+                    )
+            ));
             player.connection.teleport(player.getX(), player.getY(), player.getZ(), player.getYRot(), player.getXRot());
             player.connection.send(new ClientboundSetEntityMotionPacket(player));
             var vehicle = player.getVehicle();
@@ -81,32 +87,37 @@ public final class PlayerUtils {
             playerList.sendPlayerPermissionLevel(player);
             playerList.sendLevelInfo(player, serverLevel);
             playerList.sendAllPlayerInfo(player);
-            PlayerUtils.sendActivePlayerEffects(player);
+            playerList.sendActivePlayerEffects(player);
         }
     }
     
     private static void sendActivePlayerEffects(ServerPlayer player) {
         for (var effect : player.getActiveEffects()) {
-            player.connection.send(new ClientboundUpdateMobEffectPacket(player.getId(), effect));
+            player.connection.send(new ClientboundUpdateMobEffectPacket(player.getId(), effect, false));
         }
     }
     
     public static GameProfile cloneGameProfile(GameProfile profile) {
-        var newProfile = new GameProfile(profile.getId(), profile.getName());
-        newProfile.getProperties().putAll(profile.getProperties());
+        var newProfile = new GameProfile(profile.id(), profile.name());
+        newProfile.properties().putAll(profile.properties());
         
         return newProfile;
     }
     
     public static Property getPlayerSkin(GameProfile profile) {
-        return Iterables.getFirst(profile.getProperties().get(TEXTURES_KEY), null);
+        return Iterables.getFirst(profile.properties().get(TEXTURES_KEY), null);
     }
     
-    public static void applyRestoredSkin(GameProfile profile, Property skin) {
-        profile.getProperties().removeAll(TEXTURES_KEY);
+    public static GameProfile applyRestoredSkin(GameProfile profile, Property skin) {
+        var propertiesMap = profile.properties();
         
-        if (skin != null)
-            profile.getProperties().put(TEXTURES_KEY, skin);
+        var newProperties = LinkedHashMultimap.create(propertiesMap);
+        newProperties.removeAll(TEXTURES_KEY);
+        if (skin != null) {
+            newProperties.put(TEXTURES_KEY, skin);
+        }
+        
+        return new GameProfile(profile.id(), profile.name(), new PropertyMap(newProperties));
     }
     
     public static boolean areSkinPropertiesEquals(Property x, Property y) {
@@ -130,7 +141,7 @@ public final class PlayerUtils {
     
     public static GameProfile toProfile(MinecraftProfilePropertiesResponse response) {
         final GameProfile profile = new GameProfile(response.id(), response.name());
-        profile.getProperties().putAll(response.properties());
+        profile.properties().putAll(response.properties());
         return profile;
     }
 }

common/src/main/resources/META-INF/accesstransformer.cfg

@@ -1 +0,0 @@
-public net.minecraft.server.players.GameProfileCache$GameProfileInfo

common/src/main/resources/skinrestorer.accesswidener

@@ -1,3 +1 @@
 accessWidener v2 named
-
-accessible class net/minecraft/server/players/GameProfileCache$GameProfileInfo

common/src/main/resources/skinrestorer.mixins.json

@@ -7,11 +7,10 @@
     "refmap": "${mod_id}.refmap.json",
     "mixins": [
         "ChunkMapAccessor",
+        "PlayerAccessor",
         "PlayerListMixin",
         "ServerLoginPacketListenerImplMixin",
-        "TrackedEntityAccessorInvoker",
-        "SkullBlockEntityMixin",
-        "GameProfileCacheAccessor"
+        "TrackedEntityAccessorInvoker"
     ],
     "injectors": {
         "defaultRequire": 1

fabric/gradle.properties

@@ -1,6 +1,6 @@
 # Fabric, see https://fabricmc.net/develop/ for new versions
 fabric_loader_version=0.15.0
-fabric_api_version=0.89.0+1.20.2
+fabric_api_version=0.139.4+1.21.11
 
 optional_dependencies=fabric-api
 additional_modloaders=quilt

fabric/src/main/java/net/lionarius/skinrestorer/fabric/compat/skinshuffle/SkinShuffleCompatibility.java

@@ -1,17 +1,14 @@
 package net.lionarius.skinrestorer.fabric.compat.skinshuffle;
 
-import net.fabricmc.fabric.api.networking.v1.PacketSender;
+import net.fabricmc.fabric.api.networking.v1.PayloadTypeRegistry;
 import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents;
 import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
 import net.lionarius.skinrestorer.SkinRestorer;
+import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleHandshakePayload;
 import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleSkinRefreshPayload;
 import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleSkinRefreshV1Payload;
 import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleSkinRefreshV2Payload;
 import net.lionarius.skinrestorer.fabric.SkinRestorerFabric;
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.server.MinecraftServer;
-import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.server.network.ServerGamePacketListenerImpl;
 
 public final class SkinShuffleCompatibility {
     
@@ -23,24 +20,18 @@ public final class SkinShuffleCompatibility {
             return;
         }
         
+        PayloadTypeRegistry.playS2C().register(SkinShuffleHandshakePayload.PACKET_ID, SkinShuffleHandshakePayload.PACKET_CODEC);
+        PayloadTypeRegistry.playC2S().register(SkinShuffleSkinRefreshV1Payload.PACKET_ID, SkinShuffleSkinRefreshV1Payload.PACKET_CODEC);
+        PayloadTypeRegistry.playC2S().register(SkinShuffleSkinRefreshV2Payload.PACKET_ID, SkinShuffleSkinRefreshV2Payload.PACKET_CODEC);
+        
         ServerPlayConnectionEvents.JOIN.register((handler, sender, server) -> net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleCompatibility.onPlayerJoin(handler.getPlayer()));
         
-        ServerPlayNetworking.registerGlobalReceiver(SkinShuffleSkinRefreshV1Payload.PACKET_ID, SkinShuffleCompatibility::handleSkinRefreshV1Packet);
+        ServerPlayNetworking.registerGlobalReceiver(SkinShuffleSkinRefreshV1Payload.PACKET_ID, SkinShuffleCompatibility::handleSkinRefreshPacket);
         
-        ServerPlayNetworking.registerGlobalReceiver(SkinShuffleSkinRefreshV2Payload.PACKET_ID, SkinShuffleCompatibility::handleSkinRefreshV2Packet);
+        ServerPlayNetworking.registerGlobalReceiver(SkinShuffleSkinRefreshV2Payload.PACKET_ID, SkinShuffleCompatibility::handleSkinRefreshPacket);
     }
     
-    private static void handleSkinRefreshV1Packet(MinecraftServer server, ServerPlayer player, ServerGamePacketListenerImpl listener, FriendlyByteBuf buf, PacketSender sender) {
-        var payload = SkinShuffleSkinRefreshV1Payload.decode(buf);
-        SkinShuffleCompatibility.handleSkinRefreshPacket(payload, server, player);
-    }
-    
-    private static void handleSkinRefreshV2Packet(MinecraftServer server, ServerPlayer player, ServerGamePacketListenerImpl listener, FriendlyByteBuf buf, PacketSender sender) {
-        var payload = SkinShuffleSkinRefreshV2Payload.decode(buf);
-        SkinShuffleCompatibility.handleSkinRefreshPacket(payload, server, player);
-    }
-    
-    private static void handleSkinRefreshPacket(SkinShuffleSkinRefreshPayload payload, MinecraftServer server, ServerPlayer player) {
-        net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleCompatibility.handleSkinRefresh(server, player, payload);
+    private static void handleSkinRefreshPacket(SkinShuffleSkinRefreshPayload payload, ServerPlayNetworking.Context context) {
+        net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleCompatibility.handleSkinRefresh(SkinRestorer.getMinecraftServer(), context.player(), payload);
     }
 }

fabric/src/main/java/net/lionarius/skinrestorer/fabric/mixin/MinecraftServerMixin.java

@@ -11,7 +11,7 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 public abstract class MinecraftServerMixin {
     
     @Inject(method = "runServer",
-            at = @At(value = "INVOKE", target = "Lnet/minecraft/Util;getMillis()J", ordinal = 0))
+            at = @At(value = "INVOKE", target = "Lnet/minecraft/util/Util;getNanos()J", ordinal = 0))
     private void onServerStarted(CallbackInfo ci) {
         SkinRestorer.Events.onServerStarted((MinecraftServer) (Object) this);
     }

fabric/src/main/java/net/lionarius/skinrestorer/fabric/platform/FabricCompatibilityHelper.java

@@ -1,6 +1,5 @@
 package net.lionarius.skinrestorer.fabric.platform;
 
-import net.fabricmc.fabric.api.networking.v1.PacketByteBufs;
 import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
 import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleHandshakePayload;
 import net.lionarius.skinrestorer.platform.services.CompatibilityHelper;
@@ -9,6 +8,6 @@ import net.minecraft.server.level.ServerPlayer;
 public final class FabricCompatibilityHelper implements CompatibilityHelper {
     @Override
     public void skinShuffle_sendHandshake(ServerPlayer player) {
-        ServerPlayNetworking.send(player, SkinShuffleHandshakePayload.PACKET_ID, PacketByteBufs.empty());
+        ServerPlayNetworking.send(player, SkinShuffleHandshakePayload.INSTANCE);
     }
 }

forge/build.gradle

@@ -17,19 +17,19 @@ mixin {
 
 jarJar.enable()
 
-tasks.named('jar') {
-    archiveClassifier = 'thin'
-}
-
 tasks.named('jarJar') {
     archiveClassifier = ''
 }
 
+jar.finalizedBy('jarJar')
+
 minecraft {
     mappings channel: 'parchment', version: "${parchment_minecraft}-${parchment_version}-${minecraft_version}"
 
     copyIdeResources = true //Calls processResources when in dev
 
+    reobf = false // Forge 1.20.6+ uses official mappings at runtime, so we shouldn't reobf from official to SRG
+
     // Automatically enable forge AccessTransformers if the file exists
     // This location is hardcoded in Forge and can not be changed.
     // https://github.com/MinecraftForge/MinecraftForge/blob/be1698bb1554f9c8fa2f58e32b9ab70bc4385e60/fmlloader/src/main/java/net/minecraftforge/fml/loading/moddiscovery/ModFile.java#L123
@@ -43,6 +43,7 @@ minecraft {
             workingDirectory rootProject.file('run/client')
             ideaModule "${rootProject.name}.${project.name}.main"
             taskName 'Client'
+            property 'eventbus.api.strictRuntimeChecks', 'true'
             mods {
                 modClientRun {
                     source sourceSets.main
@@ -54,6 +55,7 @@ minecraft {
             workingDirectory rootProject.file('run/server')
             ideaModule "${rootProject.name}.${project.name}.main"
             taskName 'Server'
+            property 'eventbus.api.strictRuntimeChecks', 'true'
             mods {
                 modServerRun {
                     source sourceSets.main
@@ -66,6 +68,8 @@ minecraft {
 dependencies {
     minecraft "net.minecraftforge:forge:${forge_minecraft_version}-${forge_version}"
 
+    annotationProcessor('net.minecraftforge:eventbus-validator:7.0-beta.7')
+    
     annotationProcessor('org.spongepowered:mixin:0.8.5-SNAPSHOT:processor')
     implementation('net.sf.jopt-simple:jopt-simple:5.0.4') { version { strictly '5.0.4' } }
 

forge/gradle.properties

@@ -1,5 +1,5 @@
 # Forge, see https://files.minecraftforge.net/net/minecraftforge/forge/ for new versions
-forge_version=48.0.0
-forge_loader_version_range=[48,)
+forge_version=61.0.0
+forge_loader_version_range=[61,)
 # Forge sometimes skips minor minecraft versions (like 1.20.5)
-forge_minecraft_version=1.20.2
+forge_minecraft_version=1.21.11

forge/src/main/java/net/lionarius/skinrestorer/forge/SkinRestorerForge.java

@@ -5,7 +5,7 @@ import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleCompatibility;
 import net.minecraftforge.event.RegisterCommandsEvent;
 import net.minecraftforge.event.server.ServerStartedEvent;
 import net.minecraftforge.event.server.ServerStoppedEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.eventbus.api.listener.SubscribeEvent;
 import net.minecraftforge.fml.common.Mod;
 
 @Mod(SkinRestorer.MOD_ID)

forge/src/main/java/net/lionarius/skinrestorer/forge/compat/skinshuffle/SkinShuffleCompatibility.java

@@ -1,13 +1,13 @@
 package net.lionarius.skinrestorer.forge.compat.skinshuffle;
 
-import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.entity.player.PlayerEvent;
 
 public final class SkinShuffleCompatibility {
     
     private SkinShuffleCompatibility() {}
     
     public static void initialize() {
-        MinecraftForge.EVENT_BUS.register(SkinShuffleGameEventHandler.class);
+        PlayerEvent.PlayerLoggedInEvent.BUS.addListener(SkinShuffleGameEventHandler::onPlayerLoggedIn);
         
         SkinShufflePacketHandler.initialize();
     }

forge/src/main/java/net/lionarius/skinrestorer/forge/compat/skinshuffle/SkinShuffleGameEventHandler.java

@@ -3,13 +3,11 @@ package net.lionarius.skinrestorer.forge.compat.skinshuffle;
 import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleCompatibility;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraftforge.event.entity.player.PlayerEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
 
 public final class SkinShuffleGameEventHandler {
     
     private SkinShuffleGameEventHandler() {}
     
-    @SubscribeEvent
     public static void onPlayerLoggedIn(PlayerEvent.PlayerLoggedInEvent event) {
         SkinShuffleCompatibility.onPlayerJoin((ServerPlayer) event.getEntity());
     }

forge/src/main/java/net/lionarius/skinrestorer/forge/compat/skinshuffle/SkinShufflePacketHandler.java

@@ -1,60 +1,45 @@
 package net.lionarius.skinrestorer.forge.compat.skinshuffle;
 
-import io.netty.buffer.Unpooled;
+import net.lionarius.skinrestorer.SkinRestorer;
 import net.lionarius.skinrestorer.compat.skinshuffle.*;
 import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleCompatibility;
 import net.minecraft.network.Connection;
-import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
 import net.minecraftforge.event.network.CustomPayloadEvent;
+import net.minecraftforge.network.Channel;
 import net.minecraftforge.network.ChannelBuilder;
-import net.minecraftforge.network.EventNetworkChannel;
 
 public class SkinShufflePacketHandler {
-
-    private static final EventNetworkChannel HANDSHAKE_INSTANCE = ChannelBuilder
-            .named(SkinShuffleHandshakePayload.PACKET_ID)
+    private static final Channel<CustomPacketPayload> INSTANCE = ChannelBuilder
+            .named(SkinRestorer.resourceLocation("skin_shuffle_compat"))
             .optional()
-            .eventNetworkChannel();
+            .payloadChannel()
+            .any()
+            .clientbound()
+            .add(SkinShuffleHandshakePayload.PACKET_ID, SkinShuffleHandshakePayload.PACKET_CODEC, (payload, context) -> {
+            })
+            .serverbound()
+            .add(SkinShuffleSkinRefreshV1Payload.PACKET_ID, SkinShuffleSkinRefreshV1Payload.PACKET_CODEC, SkinShufflePacketHandler::handleSkinRefreshPacket)
+            .add(SkinShuffleSkinRefreshV2Payload.PACKET_ID, SkinShuffleSkinRefreshV2Payload.PACKET_CODEC, SkinShufflePacketHandler::handleSkinRefreshPacket)
+            .build();
     
-    private static final EventNetworkChannel SKIN_REFRESH_V1_INSTANCE = ChannelBuilder
-            .named(SkinShuffleSkinRefreshV1Payload.PACKET_ID)
-            .optional()
-            .eventNetworkChannel()
-            .addListener(SkinShufflePacketHandler::skinRefreshV1Listener);
+    private SkinShufflePacketHandler() {
+    }
     
-    private static final EventNetworkChannel SKIN_REFRESH_V2_INSTANCE = ChannelBuilder
-            .named(SkinShuffleSkinRefreshV2Payload.PACKET_ID)
-            .optional()
-            .eventNetworkChannel()
-            .addListener(SkinShufflePacketHandler::skinRefreshV2Listener);
-
     protected static void initialize() {
         // NO-OP
     }
     
-    private SkinShufflePacketHandler() {
-    }
-
     public static void sendHandshake(Connection connection) {
-        HANDSHAKE_INSTANCE.send(new FriendlyByteBuf(Unpooled.buffer(0, 0)), connection);
+        INSTANCE.send(SkinShuffleHandshakePayload.INSTANCE, connection);
     }
     
-    private static void skinRefreshV1Listener(CustomPayloadEvent event) {
-        var payload = SkinShuffleSkinRefreshV1Payload.decode(event.getPayload());
-        handleSkinRefreshPacket(payload, event.getSource());
-    }
-
-    private static void skinRefreshV2Listener(CustomPayloadEvent event) {
-        var payload = SkinShuffleSkinRefreshV2Payload.decode(event.getPayload());
-        handleSkinRefreshPacket(payload, event.getSource());
-    }
-
     private static void handleSkinRefreshPacket(SkinShuffleSkinRefreshPayload payload, CustomPayloadEvent.Context context) {
         var sender = context.getSender();
         
         if (!context.isServerSide() || sender == null)
             return;
         
-        SkinShuffleCompatibility.handleSkinRefresh(sender.getServer(), sender, payload);
+        SkinShuffleCompatibility.handleSkinRefresh(SkinRestorer.getMinecraftServer(), sender, payload);
     }
 }

gradle.properties

@@ -1,14 +1,14 @@
 # Project
 group=net.lionarius
-java_version=17
+java_version=21
 
 # Common
-minecraft_version=1.20.2
-minecraft_version_list=1.20.2
-minecraft_version_range=1.20.2
+minecraft_version=1.21.11
+minecraft_version_list=1.21.11
+minecraft_version_range=[1.21.11, 1.22)
 mod_id=skinrestorer
 mod_name=SkinRestorer
-mod_version=2.4.3
+mod_version=2.5.0
 mod_author=Lionarius
 mod_homepage=https://modrinth.com/mod/skinrestorer
 mod_sources=https://github.com/Suiranoil/SkinRestorer
@@ -18,11 +18,11 @@ credits=
 description=A server-side mod for managing skins.
 
 # Dependencies
-mineskin_client_version=3.0.6-SNAPSHOT
+mineskin_client_version=3.2.1-SNAPSHOT
 
 # ParchmentMC mappings, see https://parchmentmc.org/docs/getting-started#choose-a-version for new versions
-parchment_minecraft=1.20.2
-parchment_version=2023.12.10
+parchment_minecraft=1.21.11
+parchment_version=2025.12.20
 
 # Publishing
 curseforge_id=443823

neoforge/build.gradle

@@ -55,6 +55,4 @@ dependencies {
             prefer mineskin_client_version
         }
     }
-
-    additionalRuntimeClasspath "org.mineskin:java-client:${mineskin_client_version}"
 }

neoforge/gradle.properties

@@ -1,3 +1,3 @@
 # NeoForge, see https://projects.neoforged.net/neoforged/neoforge for new versions
-neoforge_version=20.2.3-beta
-neoforge_loader_version_range=[1,)
+neoforge_version=21.11.0-beta
+neoforge_loader_version_range=[4,)

neoforge/src/main/java/net/lionarius/skinrestorer/neoforge/SkinRestorerNeoForge.java

@@ -3,13 +3,14 @@ package net.lionarius.skinrestorer.neoforge;
 import net.lionarius.skinrestorer.SkinRestorer;
 import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleCompatibility;
 import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.fml.common.EventBusSubscriber;
 import net.neoforged.fml.common.Mod;
 import net.neoforged.neoforge.event.RegisterCommandsEvent;
 import net.neoforged.neoforge.event.server.ServerStartedEvent;
 import net.neoforged.neoforge.event.server.ServerStoppedEvent;
 
 @Mod(SkinRestorer.MOD_ID)
-@Mod.EventBusSubscriber(modid = SkinRestorer.MOD_ID)
+@EventBusSubscriber(modid = SkinRestorer.MOD_ID)
 public final class SkinRestorerNeoForge {
     
     public SkinRestorerNeoForge() {

neoforge/src/main/java/net/lionarius/skinrestorer/neoforge/compat/skinshuffle/SkinShuffleCompatibility.java

@@ -1,5 +1,7 @@
 package net.lionarius.skinrestorer.neoforge.compat.skinshuffle;
 
+import net.lionarius.skinrestorer.SkinRestorer;
+import net.neoforged.fml.ModList;
 import net.neoforged.neoforge.common.NeoForge;
 
 public final class SkinShuffleCompatibility {
@@ -9,6 +11,7 @@ public final class SkinShuffleCompatibility {
     public static void initialize() {
         NeoForge.EVENT_BUS.register(SkinShuffleGameEventHandler.class);
         
-        SkinShufflePacketHandler.initialize();
+        final var mod = ModList.get().getModContainerById(SkinRestorer.MOD_ID).get();
+        mod.getEventBus().register(SkinShuffleModEventHandler.class);
     }
 }

neoforge/src/main/java/net/lionarius/skinrestorer/neoforge/compat/skinshuffle/SkinShuffleModEventHandler.java

@@ -0,0 +1,32 @@
+package net.lionarius.skinrestorer.neoforge.compat.skinshuffle;
+
+import net.lionarius.skinrestorer.SkinRestorer;
+import net.lionarius.skinrestorer.compat.skinshuffle.*;
+import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleCompatibility;
+import net.minecraft.server.level.ServerPlayer;
+import net.neoforged.bus.api.SubscribeEvent;
+import net.neoforged.neoforge.network.event.RegisterPayloadHandlersEvent;
+import net.neoforged.neoforge.network.handling.IPayloadContext;
+import net.neoforged.neoforge.network.registration.HandlerThread;
+
+public final class SkinShuffleModEventHandler {
+    private SkinShuffleModEventHandler() {}
+    
+    @SubscribeEvent
+    public static void onRegisterPayloadHandlers(RegisterPayloadHandlersEvent event) {
+        final var registrar = event.registrar("1").optional().executesOn(HandlerThread.NETWORK);
+        
+        registrar
+                .playToClient(SkinShuffleHandshakePayload.PACKET_ID, SkinShuffleHandshakePayload.PACKET_CODEC,
+                        (payload, context) -> {})
+                .playToServer(SkinShuffleSkinRefreshV1Payload.PACKET_ID, SkinShuffleSkinRefreshV1Payload.PACKET_CODEC,
+                        SkinShuffleModEventHandler::handleSkinRefreshPacket)
+                .playToServer(SkinShuffleSkinRefreshV2Payload.PACKET_ID, SkinShuffleSkinRefreshV2Payload.PACKET_CODEC,
+                        SkinShuffleModEventHandler::handleSkinRefreshPacket);
+    }
+    
+    private static void handleSkinRefreshPacket(SkinShuffleSkinRefreshPayload payload, IPayloadContext context) {
+        var player = (ServerPlayer) context.player();
+        SkinShuffleCompatibility.handleSkinRefresh(SkinRestorer.getMinecraftServer(), player, payload);
+    }
+}

neoforge/src/main/java/net/lionarius/skinrestorer/neoforge/compat/skinshuffle/SkinShufflePacketHandler.java

@@ -1,55 +0,0 @@
-package net.lionarius.skinrestorer.neoforge.compat.skinshuffle;
-
-import net.lionarius.skinrestorer.compat.skinshuffle.SkinShuffleCompatibility;
-import net.lionarius.skinrestorer.compat.skinshuffle.*;
-import net.neoforged.neoforge.network.NetworkConstants;
-import net.neoforged.neoforge.network.NetworkEvent;
-import net.neoforged.neoforge.network.NetworkRegistry;
-import net.neoforged.neoforge.network.event.EventNetworkChannel;
-
-public final class SkinShufflePacketHandler {
-    private SkinShufflePacketHandler() {
-    }
-    
-    // there is no need for handshake channel but register it to not allow other mods to use it
-    private static final EventNetworkChannel HANDSHAKE_INSTANCE = NetworkRegistry.ChannelBuilder
-            .named(SkinShuffleHandshakePayload.PACKET_ID)
-            .serverAcceptedVersions(NetworkRegistry.acceptMissingOr("1"))
-            .clientAcceptedVersions(NetworkRegistry.acceptMissingOr("1"))
-            .networkProtocolVersion(() -> NetworkConstants.NETVERSION)
-            .eventNetworkChannel();
-    
-    private static final EventNetworkChannel SKIN_REFRESH_V1_INSTANCE = NetworkRegistry.ChannelBuilder
-            .named(SkinShuffleSkinRefreshV1Payload.PACKET_ID)
-            .serverAcceptedVersions(NetworkRegistry.acceptMissingOr("1"))
-            .clientAcceptedVersions(NetworkRegistry.acceptMissingOr("1"))
-            .networkProtocolVersion(() -> NetworkConstants.NETVERSION)
-            .eventNetworkChannel();
-    
-    private static final EventNetworkChannel SKIN_REFRESH_V2_INSTANCE = NetworkRegistry.ChannelBuilder
-            .named(SkinShuffleSkinRefreshV2Payload.PACKET_ID)
-            .serverAcceptedVersions(NetworkRegistry.acceptMissingOr("1"))
-            .clientAcceptedVersions(NetworkRegistry.acceptMissingOr("1"))
-            .networkProtocolVersion(() -> NetworkConstants.NETVERSION)
-            .eventNetworkChannel();
-    
-    static void initialize() {
-        SKIN_REFRESH_V1_INSTANCE.addListener(SkinShufflePacketHandler::skinRefreshV1Listener);
-        SKIN_REFRESH_V2_INSTANCE.addListener(SkinShufflePacketHandler::skinRefreshV2Listener);
-    }
-    
-    private static void skinRefreshV1Listener(NetworkEvent.ServerCustomPayloadEvent event) {
-        var payload = SkinShuffleSkinRefreshV1Payload.decode(event.getPayload());
-        handleSkinRefreshPacket(payload, event.getSource());
-    }
-    
-    private static void skinRefreshV2Listener(NetworkEvent.ServerCustomPayloadEvent event) {
-        var payload = SkinShuffleSkinRefreshV2Payload.decode(event.getPayload());
-        handleSkinRefreshPacket(payload, event.getSource());
-    }
-    
-    private static void handleSkinRefreshPacket(SkinShuffleSkinRefreshPayload payload, NetworkEvent.Context context) {
-        var player = context.getSender();
-        SkinShuffleCompatibility.handleSkinRefresh(player.getServer(), player, payload);
-    }
-}

neoforge/src/main/java/net/lionarius/skinrestorer/neoforge/platform/NeoForgeCompatibilityHelper.java

@@ -10,6 +10,6 @@ public final class NeoForgeCompatibilityHelper implements CompatibilityHelper {
     @Override
     public void skinShuffle_sendHandshake(ServerPlayer player) {
         // we can't use the packet distributor here because neoforge doesn't support sending packets to non-neoforge players
-        player.connection.connection.send(new ClientboundCustomPayloadPacket(SkinShuffleHandshakePayload.INSTANCE));
+        player.connection.getConnection().send(new ClientboundCustomPayloadPacket(SkinShuffleHandshakePayload.INSTANCE));
     }
 }

neoforge/src/main/resources/META-INF/neoforge.mods.toml

@@ -17,14 +17,14 @@ config = "${mod_id}.mixins.json"
 
 [[dependencies.${mod_id}]]
 modId = "neoforge"
-mandatory = true
+type = "required"
 versionRange = "[${neoforge_version},)"
 ordering = "NONE"
 side = "BOTH"
 
 [[dependencies.${mod_id}]]
 modId = "minecraft"
-mandatory = true
+type = "required"
 versionRange = "${minecraft_version_range}"
 ordering = "NONE"
 side = "BOTH"

settings.gradle

@@ -71,4 +71,4 @@ rootProject.name = 'skin-restorer'
 include('common')
 include('fabric')
 include('forge')
-//include('neoforge')
+include('neoforge')