Fabric Wiki

User Tools

Site Tools

Trace: • Persistent State
tutorial:persistent_states

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
tutorial:persistent_states [2025/03/12 16:59] – fixed the "Simple Message" code to work with "fabricloader": ">=0.16.10" and "minecraft": "~1.21.4" lakazatongtutorial:persistent_states [2025/07/28 20:33] (current) – Begin update to 1.21.5 the...why...even...how
Line 64: Line 64:
         PlayerBlockBreakEvents.AFTER.register((world, player, pos, state, entity) -> {         PlayerBlockBreakEvents.AFTER.register((world, player, pos, state, entity) -> {
             if (state.getBlock() == Blocks.GRASS_BLOCK || state.getBlock() == Blocks.DIRT) {             if (state.getBlock() == Blocks.GRASS_BLOCK || state.getBlock() == Blocks.DIRT) {
-                totalDirtBlocksBroken += 1; +                // Send a packet to the client
                 MinecraftServer server = world.getServer();                 MinecraftServer server = world.getServer();
- 
                 assert server != null;                 assert server != null;
 +
 +                // Increment the amount of dirt blocks that have been broken
 +                totalDirtBlocksBroken += 1;
 +
                 ServerPlayerEntity playerEntity = server.getPlayerManager().getPlayer(player.getUuid());                 ServerPlayerEntity playerEntity = server.getPlayerManager().getPlayer(player.getUuid());
                 server.execute(() -> {                 server.execute(() -> {
Line 91: Line 93:
 import net.minecraft.text.Text; import net.minecraft.text.Text;
  
-public class PCBModClient implements ClientModInitializer {+public class ExampleModClient implements ClientModInitializer {
     private static void handleDirtBrokenPayload(DirtBrokenPayload payload, ClientPlayNetworking.Context context) {     private static void handleDirtBrokenPayload(DirtBrokenPayload payload, ClientPlayNetworking.Context context) {
         ClientPlayerEntity player = context.client().player;         ClientPlayerEntity player = context.client().player;
Line 100: Line 102:
     @Override     @Override
     public void onInitializeClient() {     public void onInitializeClient() {
-        ClientPlayNetworking.registerGlobalReceiver(DirtBrokenPayload.ID, PCBModClient::handleDirtBrokenPayload);+        ClientPlayNetworking.registerGlobalReceiver(DirtBrokenPayload.ID, ExampleModClient::handleDirtBrokenPayload);
     }     }
 } }
Line 117: Line 119:
 <code java> <code java>
 import net.minecraft.nbt.NbtCompound; import net.minecraft.nbt.NbtCompound;
 +import net.minecraft.registry.RegistryWrapper;
 import net.minecraft.server.MinecraftServer; import net.minecraft.server.MinecraftServer;
 +import net.minecraft.server.world.ServerWorld;
 import net.minecraft.world.PersistentState; import net.minecraft.world.PersistentState;
-import net.minecraft.world.PersistentStateManager; 
 import net.minecraft.world.World; import net.minecraft.world.World;
  
Line 125: Line 128:
  
     public Integer totalDirtBlocksBroken = 0;     public Integer totalDirtBlocksBroken = 0;
- 
-    @Override 
-    public NbtCompound writeNbt(NbtCompound nbt) { 
-        nbt.putInt("totalDirtBlocksBroken", totalDirtBlocksBroken); 
-        return nbt; 
-    } 
 } }
 </code> </code>
  
-Note: ''**writeNbt**'' must be implemented when extending ''**PersistentState**''. In the function, you get passed in an ''**NbtCompound**'' which we are supposed to pack with the data we want saved to disk. In our case, we moved the ''**public Integer totalDirtBlocksBroken**'' variable we had created earlier into this file.+Note:  you must provide a `Codec` for your state when extending  `**PersistentState**`. The `Codec` will translate the state to and from nbt when saving and loading from the disk. In our case, we moved the  `**public Integer totalDirtBlocksBroken**`  variable we had created earlier into this file.
  
-  * ''**NbtCompound**'' doesn't just store ''**Integers**''. It has functions for strings, arrays, bools, floats, importantly other ''**NbtCompound**'''s as you'll see soon enough, and even arbitrary bytes. That means, if you want to store some ''**SuperCustomClass**'', what you should do is create a ''**new NbtCompound**'' and pack that new ''**NbtCompound**'' with the fields of your ''**SuperCustomClass**'' and then store it in the main ''**NbtCompound**'' you get passed in. (We're about to do just that!) +-   `Codec`s  doesn't just store  `**Integers**`. Default `Codec`s are provided for for strings, bools, floats, and other primitive building blocks, and you can write your own for custom types. That means, if you want to store some  `**SuperCustomClass**`, what you should do is create a  `**Codec**` for that class, and use that codec in the codec for your state class.
- +
-Next add the following functions to that same file:+
  
 <code java> <code java>
Line 145: Line 140:
     // ... (Previously written code)     // ... (Previously written code)
  
-    public static StateSaverAndLoader createFromNbt(NbtCompound tag, RegistryWrapper.WrapperLookup registryLookup) { +    private StateSaverAndLoader() {
-        StateSaverAndLoader state = new StateSaverAndLoader(); +
-        state.totalDirtBlocksBroken = tag.getInt("totalDirtBlocksBroken"); +
-        return state;+
     }     }
-     +  
-    public static StateSaverAndLoader createNew() { +    private StateSaverAndLoader(int totalDirtBlocksBroken) { 
-        StateSaverAndLoader state = new StateSaverAndLoader(); +        this.totalDirtBlocksBroken = totalDirtBlocksBroken;
-        state.totalDirtBlocksBroken = 0; +
-        return state;+
     }     }
 + 
 +    private int getTotalDirtBlocksBroken() {
 +        return totalDirtBlocksBroken;
 +    }
 + 
 +    private static final Codec<StateSaverAndLoader> CODEC = Codec.INT.fieldOf("totalDirtBlocksBroken").codec().xmap(
 +            StateSaverAndLoader::new, // create a new 'StateSaverAndLoader' from the stored number
 +            StateSaverAndLoader::getTotalDirtBlocksBroken // return the number from the 'StateSaverAndLoader' to be saved
 +    );
 } }
 </code> </code>
- 
-First function does the opposite of ''**writeNbt**''. It takes in an ''**NbtCompound**'' (the same one we wrote in ''**writeNbt**'') and a ''**RegistryWrapper.WrapperLookup**'', creates a brand ''**new StateSaverAndLoader**'' and stuffs it with the data inside the ''**NbtCompound**''. 
- 
-  * Note: how we pull out the int we stored earlier with ''**getInt**'' and how the string we pass in is the same one we used in ''**writeNbt**''. 
- 
-Second function refreshing variables ''**totalDirtBlocksBroken**'' to avoid transfering data from another world to new one. 
- 
 Now we just need to add one more utility function which hooks everything up together. This function will take a ''**MinecraftServer**'' and from it, get the ''**PersistentStateManager**''. ''**PersistentStateManager**'' has a function ''**getOrCreate**'' which will use our ''**MOD_ID**'' as a key to see if it has an instance of our ''**StateSaverAndLoader**'' or if it needs to create one. If it needs to create one, it'll call the function we just wrote ''**createFromNbt**'' passing in the previously saved-to-disk ''**NbtCompound**'' and a ''**RegistryWrapper.WrapperLookup**''. Ultimately the function returns the ''**StateSaverAndLoader**'' for the given ''**MinecraftServer**''. Now we just need to add one more utility function which hooks everything up together. This function will take a ''**MinecraftServer**'' and from it, get the ''**PersistentStateManager**''. ''**PersistentStateManager**'' has a function ''**getOrCreate**'' which will use our ''**MOD_ID**'' as a key to see if it has an instance of our ''**StateSaverAndLoader**'' or if it needs to create one. If it needs to create one, it'll call the function we just wrote ''**createFromNbt**'' passing in the previously saved-to-disk ''**NbtCompound**'' and a ''**RegistryWrapper.WrapperLookup**''. Ultimately the function returns the ''**StateSaverAndLoader**'' for the given ''**MinecraftServer**''.
  
Line 172: Line 164:
     // ... (Previously written code)     // ... (Previously written code)
  
-    private static Type<StateSaverAndLoader> type = new Type<>( +    private static final PersistentStateType<StateSaverAndLoader> type = new PersistentStateType<>( 
-            StateSaverAndLoader::createNew, // If there's no 'StateSaverAndLoader' yet create one and refresh variables +            (String) ExampleMod.MOD_ID, 
-            StateSaverAndLoader::createFromNbt, // If there is a 'StateSaverAndLoader' NBT, parse it with 'createFromNbt'+            StateSaverAndLoader::new, // If there's no 'StateSaverAndLoader' yet create one and refresh variables 
 +            CODEC, // If there is a 'StateSaverAndLoader' NBT, parse it with 'CODEC'
             null // Supposed to be an 'DataFixTypes' enum, but we can just pass null             null // Supposed to be an 'DataFixTypes' enum, but we can just pass null
     );     );
Line 180: Line 173:
     public static StateSaverAndLoader getServerState(MinecraftServer server) {     public static StateSaverAndLoader getServerState(MinecraftServer server) {
         // (Note: arbitrary choice to use 'World.OVERWORLD' instead of 'World.END' or 'World.NETHER'.  Any work)         // (Note: arbitrary choice to use 'World.OVERWORLD' instead of 'World.END' or 'World.NETHER'.  Any work)
-        PersistentStateManager persistentStateManager = server.getWorld(World.OVERWORLD).getPersistentStateManager();+        ServerWorld serverWorld = server.getWorld(World.OVERWORLD); 
 +        assert serverWorld != null;
  
         // The first time the following 'getOrCreate' function is called, it creates a brand new 'StateSaverAndLoader' and         // The first time the following 'getOrCreate' function is called, it creates a brand new 'StateSaverAndLoader' and
         // stores it inside the 'PersistentStateManager'. The subsequent calls to 'getOrCreate' pass in the saved         // stores it inside the 'PersistentStateManager'. The subsequent calls to 'getOrCreate' pass in the saved
-        // 'StateSaverAndLoader' NBT on disk to our function 'StateSaverAndLoader::createFromNbt'. +        // 'StateSaverAndLoader' NBT on disk to the codec in our type, using the codec to decode the nbt into our state 
-        StateSaverAndLoader state = persistentStateManager.getOrCreate(type, ExampleMod.MOD_ID);+        StateSaverAndLoader state = serverWorld.getPersistentStateManager().getOrCreate(type);
  
-        // If state is not marked dirty, when Minecraft closes, 'writeNbt' won't be called and therefore nothing will be saved.+        // If state is not marked dirty, nothing will be saved when Minecraft closes.
         // Technically it's 'cleaner' if you only mark state as dirty when there was actually a change, but the vast majority         // Technically it's 'cleaner' if you only mark state as dirty when there was actually a change, but the vast majority
         // of mod writers are just going to be confused when their data isn't being saved, and so it's best just to 'markDirty' for them.         // of mod writers are just going to be confused when their data isn't being saved, and so it's best just to 'markDirty' for them.
Line 202: Line 196:
  
 <code java> <code java>
-import net.minecraft.nbt.NbtCompound;+import com.mojang.serialization.Codec; 
 import net.minecraft.server.MinecraftServer; import net.minecraft.server.MinecraftServer;
 +import net.minecraft.server.world.ServerWorld;
 import net.minecraft.world.PersistentState; import net.minecraft.world.PersistentState;
-import net.minecraft.world.PersistentStateManager;+import net.minecraft.world.PersistentStateType;
 import net.minecraft.world.World; import net.minecraft.world.World;
  
Line 212: Line 208:
     public Integer totalDirtBlocksBroken = 0;     public Integer totalDirtBlocksBroken = 0;
  
-    @Override +    private StateSaverAndLoader() {
-    public NbtCompound writeNbt(NbtCompound nbt) { +
-        nbt.putInt("totalDirtBlocksBroken", totalDirtBlocksBroken); +
-        return nbt;+
     }     }
  
-    public static StateSaverAndLoader createFromNbt(NbtCompound tag, RegistryWrapper.WrapperLookup registryLookup) { +    private StateSaverAndLoader(int totalDirtBlocksBroken) { 
-        StateSaverAndLoader state = new StateSaverAndLoader(); +        this.totalDirtBlocksBroken = totalDirtBlocksBroken;
-        state.totalDirtBlocksBroken = tag.getInt("totalDirtBlocksBroken"); +
-        return state;+
     }     }
-     + 
-    public static StateSaverAndLoader createNew() { +    private int getTotalDirtBlocksBroken() { 
-        StateSaverAndLoader state = new StateSaverAndLoader(); +        return totalDirtBlocksBroken;
-        state.totalDirtBlocksBroken = 0; +
-        return state;+
     }     }
  
-    private static Type<StateSaverAndLoader> type = new Type<>( +    private static final Codec<StateSaverAndLoader> CODEC = Codec.INT.fieldOf("totalDirtBlocksBroken").codec().xmap( 
-            StateSaverAndLoader::createNew, // If there's no 'StateSaverAndLoader' yet create one and refresh variables +            StateSaverAndLoader::new, // create a new 'StateSaverAndLoader' from the stored number 
-            StateSaverAndLoader::createFromNbt, // If there is a 'StateSaverAndLoader' NBT, parse it with 'createFromNbt'+            StateSaverAndLoader::getTotalDirtBlocksBroken // return the number from the 'StateSaverAndLoader' to be saved 
 +    ); 
 + 
 +    private static final PersistentStateType<StateSaverAndLoader> type = new PersistentStateType<>( 
 +            (String) ExampleMod.MOD_ID, 
 +            StateSaverAndLoader::new, // If there's no 'StateSaverAndLoader' yet create one and refresh variables 
 +            CODEC, // If there is a 'StateSaverAndLoader' NBT, parse it with 'CODEC'
             null // Supposed to be an 'DataFixTypes' enum, but we can just pass null             null // Supposed to be an 'DataFixTypes' enum, but we can just pass null
     );     );
Line 238: Line 233:
     public static StateSaverAndLoader getServerState(MinecraftServer server) {     public static StateSaverAndLoader getServerState(MinecraftServer server) {
         // (Note: arbitrary choice to use 'World.OVERWORLD' instead of 'World.END' or 'World.NETHER'.  Any work)         // (Note: arbitrary choice to use 'World.OVERWORLD' instead of 'World.END' or 'World.NETHER'.  Any work)
-        PersistentStateManager persistentStateManager = server.getWorld(World.OVERWORLD).getPersistentStateManager();+        ServerWorld serverWorld = server.getWorld(World.OVERWORLD); 
 +        assert serverWorld != null;
  
         // The first time the following 'getOrCreate' function is called, it creates a brand new 'StateSaverAndLoader' and         // The first time the following 'getOrCreate' function is called, it creates a brand new 'StateSaverAndLoader' and
         // stores it inside the 'PersistentStateManager'. The subsequent calls to 'getOrCreate' pass in the saved         // stores it inside the 'PersistentStateManager'. The subsequent calls to 'getOrCreate' pass in the saved
-        // 'StateSaverAndLoader' NBT on disk to our function 'StateSaverAndLoader::createFromNbt'. +        // 'StateSaverAndLoader' NBT on disk to the codec in our type, using the codec to decode the nbt into our state 
-        StateSaverAndLoader state = persistentStateManager.getOrCreate(type, ExampleMod.MOD_ID);+        StateSaverAndLoader state = serverWorld.getPersistentStateManager().getOrCreate(type);
  
-        // If state is not marked dirty, when Minecraft closes, 'writeNbt' won't be called and therefore nothing will be saved.+        // If state is not marked dirty, nothing will be saved when Minecraft closes.
         // Technically it's 'cleaner' if you only mark state as dirty when there was actually a change, but the vast majority         // Technically it's 'cleaner' if you only mark state as dirty when there was actually a change, but the vast majority
         // of mod writers are just going to be confused when their data isn't being saved, and so it's best just to 'markDirty' for them.         // of mod writers are just going to be confused when their data isn't being saved, and so it's best just to 'markDirty' for them.
Line 262: Line 258:
 import net.fabricmc.api.ModInitializer; import net.fabricmc.api.ModInitializer;
 import net.fabricmc.fabric.api.event.player.PlayerBlockBreakEvents; import net.fabricmc.fabric.api.event.player.PlayerBlockBreakEvents;
-import net.fabricmc.fabric.api.networking.v1.PacketByteBufs; +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.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
 import net.minecraft.block.Blocks; import net.minecraft.block.Blocks;
-import net.minecraft.network.PacketByteBuf; 
 import net.minecraft.server.MinecraftServer; import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.network.ServerPlayerEntity; import net.minecraft.server.network.ServerPlayerEntity;
-import net.minecraft.util.Identifier; 
  
 public class ExampleMod implements ModInitializer { public class ExampleMod implements ModInitializer {
  
-    public static final String MOD_ID = "your_unique_mod_id_change_me_please";+    public static final String MOD_ID = "examplemod";
  
-    public static final Identifier DIRT_BROKEN = new Identifier(MOD_ID, "dirt_broken");+    public void onInitialize() { 
 +        PayloadTypeRegistry.playS2C().register(DirtBrokenPayload.ID, DirtBrokenPayload.CODEC);
  
-    @Override 
-    public void onInitialize() { 
         PlayerBlockBreakEvents.AFTER.register((world, player, pos, state, entity) -> {         PlayerBlockBreakEvents.AFTER.register((world, player, pos, state, entity) -> {
             if (state.getBlock() == Blocks.GRASS_BLOCK || state.getBlock() == Blocks.DIRT) {             if (state.getBlock() == Blocks.GRASS_BLOCK || state.getBlock() == Blocks.DIRT) {
-                StateSaverAndLoader serverState = StateSaverAndLoader.getServerState(world.getServer()); 
-                // Increment the amount of dirt blocks that have been broken 
-                serverState.totalDirtBlocksBroken += 1; 
- 
                 // Send a packet to the client                 // Send a packet to the client
                 MinecraftServer server = world.getServer();                 MinecraftServer server = world.getServer();
 +                assert server != null;
  
-                PacketByteBuf data = PacketByteBufs.create(); +                // Increment the amount of dirt blocks that have been broken 
-                data.writeInt(serverState.totalDirtBlocksBroken);+                StateSaverAndLoader serverState = StateSaverAndLoader.getServerState(server); 
 +                serverState.totalDirtBlocksBroken += 1;
  
                 ServerPlayerEntity playerEntity = server.getPlayerManager().getPlayer(player.getUuid());                 ServerPlayerEntity playerEntity = server.getPlayerManager().getPlayer(player.getUuid());
                 server.execute(() -> {                 server.execute(() -> {
-                    ServerPlayNetworking.send(playerEntity, DIRT_BROKEN, data);+                    assert playerEntity != null; 
 +                    ServerPlayNetworking.send(playerEntity, new DirtBrokenPayload(serverState.totalDirtBlocksBroken));
                 });                 });
             }             }
Line 377: Line 368:
 public class ExampleMod implements ModInitializer { public class ExampleMod implements ModInitializer {
  
-    public static final String MOD_ID = "your_unique_mod_id_change_me_please";+    public static final String MOD_ID = "examplemod";
  
     public static final Identifier DIRT_BROKEN = new Identifier(MOD_ID, "dirt_broken");     public static final Identifier DIRT_BROKEN = new Identifier(MOD_ID, "dirt_broken");
Line 385: Line 376:
         PlayerBlockBreakEvents.AFTER.register((world, player, pos, state, entity) -> {         PlayerBlockBreakEvents.AFTER.register((world, player, pos, state, entity) -> {
             if (state.getBlock() == Blocks.GRASS_BLOCK || state.getBlock() == Blocks.DIRT) {             if (state.getBlock() == Blocks.GRASS_BLOCK || state.getBlock() == Blocks.DIRT) {
-                StateSaverAndLoader serverState = StateSaverAndLoader.getServerState(world.getServer());+                // Send a packet to the client 
 +                MinecraftServer server = world.getServer(); 
 +                assert server != null; 
 +                 
 +                StateSaverAndLoader serverState = StateSaverAndLoader.getServerState(server);
                 // Increment the amount of dirt blocks that have been broken                 // Increment the amount of dirt blocks that have been broken
                 serverState.totalDirtBlocksBroken += 1;                 serverState.totalDirtBlocksBroken += 1;
Line 391: Line 386:
                 PlayerData playerState = StateSaverAndLoader.getPlayerState(player);                 PlayerData playerState = StateSaverAndLoader.getPlayerState(player);
                 playerState.dirtBlocksBroken += 1;                 playerState.dirtBlocksBroken += 1;
- 
-                // Send a packet to the client 
-                MinecraftServer server = world.getServer(); 
  
                 PacketByteBuf data = PacketByteBufs.create();                 PacketByteBuf data = PacketByteBufs.create();
Line 612: Line 604:
 public class ExampleMod implements ModInitializer { public class ExampleMod implements ModInitializer {
  
-    public static final String MOD_ID = "your_unique_mod_id_change_me_please";+    public static final String MOD_ID = "examplemod";
  
     public static final Identifier DIRT_BROKEN = new Identifier(MOD_ID, "dirt_broken");     public static final Identifier DIRT_BROKEN = new Identifier(MOD_ID, "dirt_broken");
Line 631: Line 623:
         PlayerBlockBreakEvents.AFTER.register((world, player, pos, state, entity) -> {         PlayerBlockBreakEvents.AFTER.register((world, player, pos, state, entity) -> {
             if (state.getBlock() == Blocks.GRASS_BLOCK || state.getBlock() == Blocks.DIRT) {             if (state.getBlock() == Blocks.GRASS_BLOCK || state.getBlock() == Blocks.DIRT) {
-                StateSaverAndLoader serverState = StateSaverAndLoader.getServerState(world.getServer());+                // Send a packet to the client 
 +                MinecraftServer server = world.getServer(); 
 +                assert server != null; 
 +                 
 +                StateSaverAndLoader serverState = StateSaverAndLoader.getServerState(server);
                 // Increment the amount of dirt blocks that have been broken                 // Increment the amount of dirt blocks that have been broken
                 serverState.totalDirtBlocksBroken += 1;                 serverState.totalDirtBlocksBroken += 1;
Line 637: Line 633:
                 PlayerData playerState = StateSaverAndLoader.getPlayerState(player);                 PlayerData playerState = StateSaverAndLoader.getPlayerState(player);
                 playerState.dirtBlocksBroken += 1;                 playerState.dirtBlocksBroken += 1;
- 
-                // Send a packet to the client 
-                MinecraftServer server = world.getServer(); 
  
                 PacketByteBuf data = PacketByteBufs.create();                 PacketByteBuf data = PacketByteBufs.create();
Line 879: Line 872:
 public class ExampleMod implements ModInitializer { public class ExampleMod implements ModInitializer {
  
-    public static final String MOD_ID = "your_unique_mod_id_change_me_please";+    public static final String MOD_ID = "examplemod";
  
     public static final Identifier DIRT_BROKEN = new Identifier(MOD_ID, "dirt_broken");     public static final Identifier DIRT_BROKEN = new Identifier(MOD_ID, "dirt_broken");
Line 898: Line 891:
         PlayerBlockBreakEvents.AFTER.register((world, player, pos, state, entity) -> {         PlayerBlockBreakEvents.AFTER.register((world, player, pos, state, entity) -> {
             if (state.getBlock() == Blocks.GRASS_BLOCK || state.getBlock() == Blocks.DIRT) {             if (state.getBlock() == Blocks.GRASS_BLOCK || state.getBlock() == Blocks.DIRT) {
-                StateSaverAndLoader serverState = StateSaverAndLoader.getServerState(world.getServer());+                // Send a packet to the client 
 +                MinecraftServer server = world.getServer(); 
 +                assert server != null; 
 +                 
 +                StateSaverAndLoader serverState = StateSaverAndLoader.getServerState(server);
                 // Increment the amount of dirt blocks that have been broken                 // Increment the amount of dirt blocks that have been broken
                 serverState.totalDirtBlocksBroken += 1;                 serverState.totalDirtBlocksBroken += 1;
Line 904: Line 901:
                 PlayerData playerState = StateSaverAndLoader.getPlayerState(player);                 PlayerData playerState = StateSaverAndLoader.getPlayerState(player);
                 playerState.dirtBlocksBroken += 1;                 playerState.dirtBlocksBroken += 1;
- 
-                // Send a packet to the client 
-                MinecraftServer server = world.getServer(); 
  
                 PacketByteBuf data = PacketByteBufs.create();                 PacketByteBuf data = PacketByteBufs.create();
tutorial/persistent_states.1741798780.txt.gz · Last modified: 2025/03/12 16:59 by lakazatong