chore: ported to 1.20.6

.github/workflows/build.yml

@@ -18,6 +18,7 @@ jobs:
     with:
       curse-publish-task: ""
       maven-snapshots: true
+      java-version: 21
     secrets:
       ftb-maven-token: ${{ secrets.FTB_MAVEN_TOKEN }}
-      saps-token: ${{ secrets.SAPS_TOKEN }}
+      saps-token: ${{ secrets.SAPS_TOKEN }}

.github/workflows/release.yml

@@ -11,7 +11,8 @@ jobs:
     uses: FTBTeam/mods-meta/.github/workflows/standard-release.yml@main
     with:
       curse-publish-task: curseforge
+      java-version: 21
     secrets:
       ftb-maven-token: ${{ secrets.FTB_MAVEN_TOKEN }}
       saps-token: ${{ secrets.SAPS_TOKEN }}
-      curse-token: ${{ secrets.CURSEFORGE_KEY }}
+      curse-token: ${{ secrets.CURSEFORGE_KEY }}

build.gradle

@@ -1,6 +1,6 @@
 plugins {
 	id "architectury-plugin" version "3.4-SNAPSHOT"
-	id "dev.architectury.loom" version "1.5-SNAPSHOT" apply false
+	id "dev.architectury.loom" version "1.6-SNAPSHOT" apply false
 }
 
 architectury {
@@ -33,7 +33,7 @@ allprojects {
 	// needs to be done AFTER version is set
 	apply from: "https://raw.githubusercontent.com/FTBTeam/mods-meta/main/gradle/publishing.gradle"
 
-	sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = 17
+	sourceCompatibility = targetCompatibility = compileJava.sourceCompatibility = compileJava.targetCompatibility = 21
 
 	compileJava {
 		options.encoding = "UTF-8"

common/build.gradle

@@ -9,7 +9,7 @@ dependencies {
 def ENV = System.getenv()
 
 architectury {
-	common("forge", "fabric", "neoforge")
+	common(/* "forge", */ "fabric", "neoforge")
 }
 
 configurations {

common/src/main/java/dev/ftb/mods/ftbchunks/FTBChunks.java

@@ -6,6 +6,7 @@
 import dev.architectury.event.EventResult;
 import dev.architectury.event.events.common.*;
 import dev.architectury.hooks.level.entity.PlayerHooks;
+import dev.architectury.networking.NetworkManager;
 import dev.architectury.registry.registries.Registrar;
 import dev.architectury.registry.registries.RegistrarManager;
 import dev.architectury.utils.Env;
@@ -205,7 +206,7 @@ private void loggedIn(PlayerLoggedInAfterTeamEvent event) {
 		SNBTCompoundTag config = new SNBTCompoundTag();
 		FTBChunksWorldConfig.CONFIG.write(config);
 		UUID managerId = FTBTeamsAPI.api().getManager().getId();
-		new LoginDataPacket(managerId, config).sendTo(player);
+		NetworkManager.sendToPlayer(player, new LoginDataPacket(managerId, config));
 		SendGeneralDataPacket.send(data, player);
 		FTBChunks.LOGGER.debug("server config and team data sent to {}", playerId);
 
@@ -214,15 +215,15 @@ private void loggedIn(PlayerLoggedInAfterTeamEvent event) {
 
 		for (ClaimedChunkImpl chunk : ClaimedChunkManagerImpl.getInstance().getAllClaimedChunks()) {
 			chunksToSend.computeIfAbsent(Pair.of(chunk.getPos().dimension(), chunk.getTeamData().getTeamId()), s -> new ArrayList<>())
-					.add(new SendChunkPacket.SingleChunk(now, chunk.getPos().x(), chunk.getPos().z(), chunk));
+					.add(SendChunkPacket.SingleChunk.create(now, chunk.getPos().x(), chunk.getPos().z(), chunk));
 		}
 
 		chunksToSend.forEach((dimensionAndId, chunkPackets) -> {
 			FTBTeamsAPI.api().getManager().getTeamByID(dimensionAndId.getRight()).ifPresent(team -> {
 				ChunkTeamDataImpl teamData = ClaimedChunkManagerImpl.getInstance().getOrCreateData(team);
 				if (teamData.canPlayerUse(player, FTBChunksProperties.CLAIM_VISIBILITY)) {
 					SendManyChunksPacket packet = new SendManyChunksPacket(dimensionAndId.getLeft(), dimensionAndId.getRight(), chunkPackets);
-					packet.sendTo(player);
+					NetworkManager.sendToPlayer(player, packet);
 				}
 			});
 		});
@@ -414,7 +415,7 @@ private void playerCloned(ServerPlayer oldPlayer, ServerPlayer newPlayer, boolea
 		if (!wonGame) {
 			newPlayer.getLastDeathLocation().ifPresent(loc -> {
 				int num = newPlayer.getStats().getValue(Stats.CUSTOM.get(Stats.DEATHS));
-				new PlayerDeathPacket(loc, num).sendTo(newPlayer);
+				NetworkManager.sendToPlayer(newPlayer, new PlayerDeathPacket(loc, num));
 			});
 		}
 	}
@@ -425,7 +426,8 @@ private void playerChangedDimension(ServerPlayer serverPlayer, ResourceKey<Level
 		StageHelper.INSTANCE.getProvider().sync(serverPlayer);
 	}
 
-	private void teamConfig(TeamCollectPropertiesEvent event) {
+	@SuppressWarnings("UnreachableCode")
+    private void teamConfig(TeamCollectPropertiesEvent event) {
 		event.add(FTBChunksProperties.ALLOW_EXPLOSIONS);
 		event.add(FTBChunksProperties.ALLOW_MOB_GRIEFING);
 		event.add(FTBChunksProperties.ALLOW_ALL_FAKE_PLAYERS);
@@ -484,7 +486,8 @@ private void playerLeftParty(PlayerLeftPartyTeamEvent event) {
 		});
 	}
 
-	private void transferClaims(ChunkTeamDataImpl transferFrom, ChunkTeamDataImpl transferTo, Collection<ClaimedChunkImpl> chunksToTransfer) {
+	@SuppressWarnings("UnreachableCode")
+    private void transferClaims(ChunkTeamDataImpl transferFrom, ChunkTeamDataImpl transferTo, Collection<ClaimedChunkImpl> chunksToTransfer) {
 		CommandSourceStack sourceStack = ClaimedChunkManagerImpl.getInstance().getMinecraftServer().createCommandSourceStack();
 
 		String fromName = transferFrom.getTeam().getShortName();
@@ -508,11 +511,11 @@ private void transferClaims(ChunkTeamDataImpl transferFrom, ChunkTeamDataImpl tr
 			ChunkDimPos cdp = chunk.getPos();
 			if (total >= transferTo.getMaxClaimChunks()) {
 				chunk.unclaim(sourceStack, false);
-				chunksToUnclaim.computeIfAbsent(cdp.dimension(), s -> new ArrayList<>()).add(new SendChunkPacket.SingleChunk(now, cdp.x(), cdp.z(), null));
+				chunksToUnclaim.computeIfAbsent(cdp.dimension(), s -> new ArrayList<>()).add(SendChunkPacket.SingleChunk.create(now, cdp.x(), cdp.z(), null));
 				unclaimed++;
 			} else {
 				chunk.setTeamData(transferTo);
-				chunksToSend.computeIfAbsent(cdp.dimension(), s -> new ArrayList<>()).add(new SendChunkPacket.SingleChunk(now, cdp.x(), cdp.z(), chunk));
+				chunksToSend.computeIfAbsent(cdp.dimension(), s -> new ArrayList<>()).add(SendChunkPacket.SingleChunk.create(now, cdp.x(), cdp.z(), chunk));
 				transferred++;
 			}
 
@@ -542,7 +545,7 @@ private void transferClaims(ChunkTeamDataImpl transferFrom, ChunkTeamDataImpl tr
 
 			chunksToUnclaim.forEach((dimension, chunkPackets) -> {
 				if (!chunkPackets.isEmpty()) {
-					new SendManyChunksPacket(dimension, Util.NIL_UUID, chunkPackets).sendToAll(sourceStack.getServer());
+					NetworkManager.sendToPlayers(sourceStack.getServer().getPlayerList().getPlayers(), new SendManyChunksPacket(dimension, Util.NIL_UUID, chunkPackets));
 				}
 			});
 		}

common/src/main/java/dev/ftb/mods/ftbchunks/FTBChunksCommands.java

@@ -8,6 +8,7 @@
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
 import com.mojang.brigadier.tree.LiteralCommandNode;
 import com.mojang.util.UndashedUuid;
+import dev.architectury.networking.NetworkManager;
 import dev.ftb.mods.ftbchunks.api.ChunkTeamData;
 import dev.ftb.mods.ftbchunks.api.ClaimResult;
 import dev.ftb.mods.ftbchunks.api.ClaimedChunk;
@@ -180,7 +181,7 @@ public static void registerCommands(CommandDispatcher<CommandSourceStack> dispat
 				.then(Commands.literal("block_color")
 //						.requires(source -> source.getServer().isSingleplayer())
 						.executes(context -> {
-							new RequestBlockColorPacket().sendTo(context.getSource().getPlayerOrException());
+							NetworkManager.sendToPlayer(context.getSource().getPlayerOrException(), new RequestBlockColorPacket());
 							return 1;
 						})
 				)
@@ -203,8 +204,7 @@ public static void registerCommands(CommandDispatcher<CommandSourceStack> dispat
 
 	private static int addWaypoint(CommandSourceStack source, String name, BlockPos position, ChatFormatting color) throws CommandSyntaxException {
 		if (color.getColor() != null) {
-			ServerPlayer player = source.getPlayerOrException();
-			new AddWaypointPacket(name, position, color.getColor()).sendTo(player);
+			NetworkManager.sendToPlayer(source.getPlayerOrException(), new AddWaypointPacket(name, position, color.getColor()));
 		}
 		return 1;
 	}
@@ -465,13 +465,13 @@ private static int viewLoadedChunks(CommandSourceStack source, ServerLevel level
 		}
 
 		source.sendSuccess(() -> Component.literal(String.format("Chunks Loaded: %d. Check the map to see loaded chunks", chunks.size())), false);
-		new LoadedChunkViewPacket(level.dimension(), chunks).sendTo(source.getPlayerOrException());
+		NetworkManager.sendToPlayer(source.getPlayerOrException(), new LoadedChunkViewPacket(level.dimension(), chunks));
 
 		return 1;
 	}
 
 	private static int resetLoadedChunks(CommandSourceStack source, ServerLevel level) throws CommandSyntaxException {
-		new LoadedChunkViewPacket(level.dimension(), Long2IntMaps.EMPTY_MAP).sendTo(source.getPlayerOrException());
+		NetworkManager.sendToPlayer(source.getPlayerOrException(), new LoadedChunkViewPacket(level.dimension(), Long2IntMaps.EMPTY_MAP));
 		return 1;
 	}
 

common/src/main/java/dev/ftb/mods/ftbchunks/LongRangePlayerTracker.java

@@ -2,6 +2,7 @@
 
 import com.google.common.collect.HashBasedTable;
 import com.google.common.collect.Table;
+import dev.architectury.networking.NetworkManager;
 import dev.ftb.mods.ftbchunks.api.FTBChunksProperties;
 import dev.ftb.mods.ftbchunks.data.ChunkTeamDataImpl;
 import dev.ftb.mods.ftbchunks.data.ClaimedChunkManagerImpl;
@@ -39,19 +40,19 @@ public void tick(MinecraftServer server) {
             // 16 blocks in chunk
             int maxDistSq = server.getPlayerList().getViewDistance() * server.getPlayerList().getViewDistance() * 256;
 
-            players.forEach(p1 -> p1.level().players().forEach(p2a -> {
-                if (p2a instanceof ServerPlayer p2) {
-                    if (shouldTrack(p1, p2, maxDistSq)) {
-                        // send a tracking update to p1 IF p2's pos has changed by more than 4 blocks
-                        BlockPos lastPos = trackingMap.get(p1.getUUID(), p2.getUUID());
-                        if (lastPos == null || p2.blockPosition().distSqr(lastPos) > 16) {
-                            new SendPlayerPositionPacket(p2, p2.blockPosition()).sendTo(p1);
-                            trackingMap.put(p1.getUUID(), p2.getUUID(), p2.blockPosition());
+            players.forEach(trackingPlayer -> trackingPlayer.level().players().forEach(p2a -> {
+                if (p2a instanceof ServerPlayer trackedPlayer) {
+                    if (shouldTrack(trackingPlayer, trackedPlayer, maxDistSq)) {
+                        // send a tracking update to p1's client IF p2's pos has changed by more than 4 blocks
+                        BlockPos lastPos = trackingMap.get(trackingPlayer.getUUID(), trackedPlayer.getUUID());
+                        if (lastPos == null || trackedPlayer.blockPosition().distSqr(lastPos) > 16) {
+                            NetworkManager.sendToPlayer(trackingPlayer, SendPlayerPositionPacket.startTracking(trackedPlayer));
+                            trackingMap.put(trackingPlayer.getUUID(), trackedPlayer.getUUID(), trackedPlayer.blockPosition());
                         }
-                    } else if (trackingMap.contains(p1.getUUID(), p2.getUUID())) {
-                        // send an invalid pos to tell p1's client to stop tracking p2
-                        new SendPlayerPositionPacket(p2, null).sendTo(p1);
-                        trackingMap.remove(p1.getUUID(), p2.getUUID());
+                    } else if (trackingMap.contains(trackingPlayer.getUUID(), trackedPlayer.getUUID())) {
+                        // tell p1's client to stop tracking p2
+                        NetworkManager.sendToPlayer(trackingPlayer, SendPlayerPositionPacket.stopTracking(trackedPlayer));
+                        trackingMap.remove(trackingPlayer.getUUID(), trackedPlayer.getUUID());
                     }
                 }
             }));
@@ -73,7 +74,7 @@ public void stopTracking(ServerPlayer player) {
         toRemove.forEach((trackingId, disconnectedId) -> {
             ServerPlayer trackingPlayer = player.getServer().getPlayerList().getPlayer(trackingId);
             if (trackingPlayer != null) {
-                new SendPlayerPositionPacket(player, null).sendTo(trackingPlayer);
+                NetworkManager.sendToPlayer(trackingPlayer, SendPlayerPositionPacket.stopTracking(player));
             }
             trackingMap.remove(trackingId, disconnectedId);
         });

common/src/main/java/dev/ftb/mods/ftbchunks/api/Protection.java

@@ -1,16 +1,17 @@
 package dev.ftb.mods.ftbchunks.api;
 
 import net.minecraft.core.BlockPos;
+import net.minecraft.core.component.DataComponents;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.effect.MobEffectCategory;
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.item.PotionItem;
-import net.minecraft.world.item.alchemy.PotionUtils;
 import net.minecraft.world.level.block.state.BlockState;
 import org.jetbrains.annotations.Nullable;
 
+import java.util.stream.StreamSupport;
+
 @FunctionalInterface
 public interface Protection {
 	/**
@@ -57,7 +58,7 @@ public interface Protection {
 	Protection RIGHT_CLICK_ITEM = (player, pos, hand, chunk, entity) -> {
 		ItemStack stack = player.getItemInHand(hand);
 
-		if (stack.isEdible() || isBeneficialPotion(stack) || stack.is(FTBChunksTags.Items.RIGHT_CLICK_WHITELIST_TAG)) {
+		if (isFood(stack) || isBeneficialPotion(stack) || stack.is(FTBChunksTags.Items.RIGHT_CLICK_WHITELIST_TAG)) {
 			return ProtectionPolicy.ALLOW;
 		} else if (chunk != null && chunk.getTeamData().canPlayerUse(player, FTBChunksProperties.BLOCK_INTERACT_MODE)) {
 			return ProtectionPolicy.ALLOW;
@@ -68,9 +69,17 @@ public interface Protection {
 		return ProtectionPolicy.ALLOW;
 	};
 
+	static boolean isFood(ItemStack stack) {
+        //noinspection DataFlowIssue
+        return stack.has(DataComponents.FOOD) && stack.get(DataComponents.FOOD).nutrition() > 0;
+	}
+
 	static boolean isBeneficialPotion(ItemStack stack) {
-		return stack.getItem() instanceof PotionItem && PotionUtils.getMobEffects(stack).stream()
-				.noneMatch(effect -> effect.getEffect().getCategory() == MobEffectCategory.HARMFUL);
+		if (stack.has(DataComponents.POTION_CONTENTS)) {
+			return StreamSupport.stream(stack.get(DataComponents.POTION_CONTENTS).getAllEffects().spliterator(), false)
+					.noneMatch(effect -> effect.getEffect().value().getCategory() == MobEffectCategory.HARMFUL);
+		}
+		return false;
 	}
 
 	Protection EDIT_FLUID = (player, pos, hand, chunk, entity) -> {

common/src/main/java/dev/ftb/mods/ftbchunks/client/FTBChunksClient.java

@@ -87,7 +87,7 @@
 import net.minecraft.world.level.biome.Biome;
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.level.chunk.ChunkAccess;
-import net.minecraft.world.level.chunk.ChunkStatus;
+import net.minecraft.world.level.chunk.status.ChunkStatus;
 import net.minecraft.world.phys.BlockHitResult;
 import net.minecraft.world.phys.Vec3;
 import org.jetbrains.annotations.Nullable;
@@ -759,8 +759,8 @@ private List<Component> buildMinimapTextData(Minecraft mc, double playerX, doubl
 
 	private void drawInWorldIcons(Minecraft mc, GuiGraphics graphics, float tickDelta, double playerX, double playerY, double playerZ, int scaledWidth, int scaledHeight) {
 		GuiHelper.setupDrawing();
-		float ww2 = scaledWidth / 2F;
-		float wh2 = scaledHeight / 2F;
+		float scaledWidth2 = scaledWidth / 2F;
+		float scaledHeight2 = scaledHeight / 2F;
 		InWorldMapIcon focusedIcon = null;
 
 		for (MapIcon icon : mapIcons) {
@@ -773,9 +773,9 @@ private void drawInWorldIcons(Minecraft mc, GuiGraphics graphics, float tickDelt
 				if (lookAngle > 0) {  // icon in front of the player
 					worldMatrix.transform(v);
 					v.div(v.w());
-					float ix = ww2 + v.x() * ww2;
-					float iy = wh2 - v.y() * wh2;
-					double mouseDist = MathUtils.dist(ix, iy, ww2, wh2);
+					float ix = scaledWidth2 + v.x() * scaledWidth2;
+					float iy = scaledHeight2 - v.y() * scaledHeight2;
+					double mouseDist = MathUtils.dist(ix, iy, scaledWidth2, scaledHeight2);
 					InWorldMapIcon inWorldMapIcon = new InWorldMapIcon(icon, ix, iy, playerDist, mouseDist);
 
 					if (mouseDist <= 5D * FTBChunksClientConfig.WAYPOINT_FOCUS_DISTANCE.get() && (focusedIcon == null || focusedIcon.distanceToMouse() > mouseDist)) {
@@ -813,7 +813,7 @@ private void drawInWorldIcons(Minecraft mc, GuiGraphics graphics, float tickDelt
 		inWorldMapIcons.clear();
 	}
 
-	public void renderWorldLast(PoseStack poseStack, Matrix4f projectionMatrix, Camera camera, float tickDelta) {
+	public void renderWorldLast(PoseStack poseStack, Matrix4f projectionMatrix, Matrix4f modelViewMatrix, Camera camera, float tickDelta) {
 		Minecraft mc = Minecraft.getInstance();
 
 		if (mc.options.hideGui || MapManager.getInstance().isEmpty() || mc.level == null || mc.player == null
@@ -822,7 +822,7 @@ public void renderWorldLast(PoseStack poseStack, Matrix4f projectionMatrix, Came
 		}
 
 		worldMatrix = new Matrix4f(projectionMatrix);
-		worldMatrix.mul(poseStack.last().pose());
+		worldMatrix.mul(modelViewMatrix);
 		cameraPos = camera.getPosition();
 
 		if (!FTBChunksClientConfig.IN_WORLD_WAYPOINTS.get()) {
@@ -1113,11 +1113,11 @@ public void maybeClearDeathpoint(Player player) {
 		});
 	}
 
-	public void updateTrackedPlayerPos(GameProfile profile, BlockPos pos, boolean valid) {
+	public void updateTrackedPlayerPos(GameProfile profile, BlockPos pos) {
 		// called periodically when a player (outside of vanilla entity tracking range) that this client is tracking moves
 		boolean changed = false;
-		if (!valid) {
-			// invalid block pos indicates player should no longer be tracked on this client
+		if (pos == null) {
+			// null block pos indicates player should no longer be tracked on this client
 			// - player is either no longer in this world, or is now within the vanilla tracking range
 			changed = longRangePlayerTracker.remove(profile.getId()) != null;
 		} else {

common/src/main/java/dev/ftb/mods/ftbchunks/client/FTBChunksClientConfig.java

@@ -1,5 +1,6 @@
 package dev.ftb.mods.ftbchunks.client;
 
+import dev.architectury.networking.NetworkManager;
 import dev.architectury.platform.Platform;
 import dev.ftb.mods.ftbchunks.FTBChunks;
 import dev.ftb.mods.ftbchunks.FTBChunksWorldConfig;
@@ -111,7 +112,7 @@ static void openServerSettings(Screen screen) {
 			if (accepted) {
 				SNBTCompoundTag config = new SNBTCompoundTag();
 				FTBChunksWorldConfig.CONFIG.write(config);
-				new ServerConfigRequestPacket(config).sendToServer();
+				NetworkManager.sendToServer(new ServerConfigRequestPacket(config));
 			}
 			Minecraft.getInstance().setScreen(screen);
 		});

common/src/main/java/dev/ftb/mods/ftbchunks/client/gui/ChunkScreen.java

@@ -2,6 +2,7 @@
 
 import com.mojang.blaze3d.platform.InputConstants;
 import com.mojang.blaze3d.systems.RenderSystem;
+import dev.architectury.networking.NetworkManager;
 import dev.ftb.mods.ftbchunks.FTBChunks;
 import dev.ftb.mods.ftbchunks.FTBChunksWorldConfig;
 import dev.ftb.mods.ftbchunks.api.ClaimResult;
@@ -103,9 +104,10 @@ public void addWidgets() {
 		}
 
 		addAll(chunkButtons);
-		new RequestMapDataPacket(chunkPos.x - FTBChunks.TILE_OFFSET, chunkPos.z - FTBChunks.TILE_OFFSET,
-				chunkPos.x + FTBChunks.TILE_OFFSET, chunkPos.z + FTBChunks.TILE_OFFSET
-		).sendToServer();
+		NetworkManager.sendToServer(new RequestMapDataPacket(
+				chunkPos.x - FTBChunks.TILE_OFFSET, chunkPos.z - FTBChunks.TILE_OFFSET,
+				chunkPos.x + FTBChunks.TILE_OFFSET, chunkPos.z + FTBChunks.TILE_OFFSET)
+		);
 
 		add(new SimpleButton(this, Component.translatable("ftbchunks.gui.large_map"), Icons.MAP,
 				(simpleButton, mouseButton) -> LargeMapScreen.openMap()
@@ -121,7 +123,7 @@ public void mouseReleased(MouseButton button) {
 		super.mouseReleased(button);
 
 		if (!selectedChunks.isEmpty()) {
-			new RequestChunkChangePacket(ChunkChangeOp.create(button.isLeft(), isShiftKeyDown()), selectedChunks).sendToServer();
+			NetworkManager.sendToServer(new RequestChunkChangePacket(ChunkChangeOp.create(button.isLeft(), isShiftKeyDown()), selectedChunks));
 			selectedChunks.clear();
 			playClickSound();
 		}
@@ -313,7 +315,7 @@ public void tick() {
 
 			if (lastAdjust > 0L && System.currentTimeMillis() - lastAdjust > 1000L) {
 				// send update to server, but not more than once a second - avoid flood of updates while adjusting mouse wheel
-				new UpdateForceLoadExpiryPacket(chunkPos.dim(Minecraft.getInstance().level), chunk.getForceLoadExpiryDate().orElse(null)).sendToServer();
+				NetworkManager.sendToServer(new UpdateForceLoadExpiryPacket(chunkPos.dim(Minecraft.getInstance().level), chunk.getForceLoadExpiryDate().orElse(null)));
 				lastAdjust = 0L;
 			}
 		}