port to 1.21.8

README.md

@@ -1,5 +1,7 @@
-https://modrinth.com/mod/powered-jetpacks
-
+# FORK!
+This is a forked version of https://modrinth.com/mod/powered-jetpacks
+which was originally for 1.20.1. I've ported the mod to 1.21.8, but
+there's still a major bug, which is if you're using a 
 # Powered Jetpacks
 A simple fabric mod about jetpacks powered with E energy.
 

build.gradle

@@ -15,6 +15,17 @@ repositories {
 		name = "TerraformersMC"
 		url = "https://maven.terraformersmc.com/"
 	}
+	exclusiveContent {
+		forRepository {
+			maven {
+				name = "Modrinth"
+				url = "https://api.modrinth.com/maven"
+			}
+		}
+		filter {
+			includeGroup "maven.modrinth"
+		}
+	}
 	maven {
 		name = "Ladysnake Libs"
 		url = 'https://maven.ladysnake.org/releases'
@@ -39,7 +50,9 @@ dependencies {
 	mappings "net.fabricmc:yarn:${project.yarn_mappings}:v2"
 	modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"
 	modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
-	modImplementation "dev.emi:trinkets:${trinkets_version}"
+	modImplementation "maven.modrinth:trinkets-canary:${project.trinkets_version}"
+	modImplementation include("dev.onyxstudios.cardinal-components-api:cardinal-components-base:${project.cca_version}")
+	modImplementation include("dev.onyxstudios.cardinal-components-api:cardinal-components-entity:${project.cca_version}")
 
 	include(modApi("teamreborn:energy:${project.energy_version}")) {
 		transitive = false
@@ -55,7 +68,7 @@ processResources {
 }
 
 tasks.withType(JavaCompile).configureEach {
-	it.options.release = 17
+	it.options.release = 21
 }
 
 java {

gradle.properties

@@ -4,17 +4,18 @@ org.gradle.parallel=true
 
 # Fabric Properties
 # check these on https://fabricmc.net/develop
-minecraft_version=1.20.1
-yarn_mappings=1.20.1+build.10
-loader_version=0.16.14
-loom_version=1.10-SNAPSHOT
+minecraft_version=1.21.8
+yarn_mappings=1.21.8+build.1
+loader_version=0.17.2
+loom_version=1.11-SNAPSHOT
 
 # Mod Properties
-mod_version=1.0.6
+mod_version=1.1.0
 maven_group=konhaiii.powered_jetpacks
 archives_base_name=powered_jetpacks
 
 # Dependencies
-energy_version=3.0.0
-trinkets_version=3.7.1
-fabric_version=0.92.5+1.20.1
+energy_version=4.2.0
+trinkets_version=3.11.0-1.21.6
+fabric_version=0.134.0+1.21.8
+cca_version=7.0.0-beta.1

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.12.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

src/client/java/konhaiii/powered_jetpacks/PoweredJetpacksClient.java

@@ -1,14 +1,18 @@
 package konhaiii.powered_jetpacks;
 
 import konhaiii.powered_jetpacks.hud.JetpackHUD;
+import konhaiii.powered_jetpacks.models.JetpackModel;
 import konhaiii.powered_jetpacks.renderers.JetpackRenderer;
 import net.fabricmc.api.ClientModInitializer;
 import net.fabricmc.fabric.api.client.item.v1.ItemTooltipCallback;
+import net.fabricmc.fabric.api.client.rendering.v1.EntityModelLayerRegistry;
 import net.fabricmc.fabric.api.client.rendering.v1.HudRenderCallback;
 import net.fabricmc.fabric.api.client.rendering.v1.LivingEntityFeatureRendererRegistrationCallback;
 import net.minecraft.client.render.entity.feature.FeatureRendererContext;
 import net.minecraft.client.render.entity.model.EntityModel;
+import net.minecraft.entity.EntityType;
 import net.minecraft.entity.LivingEntity;
+import net.minecraft.registry.tag.EntityTypeTags;
 import net.minecraft.util.Identifier;
 
 public class PoweredJetpacksClient implements ClientModInitializer {
@@ -16,22 +20,15 @@ public class PoweredJetpacksClient implements ClientModInitializer {
 	public void onInitializeClient() {
 		ItemTooltipCallback.EVENT.register(new StackToolTipHandler());
 		HudRenderCallback.EVENT.register(new JetpackHUD());
-		LivingEntityFeatureRendererRegistrationCallback.EVENT.register((entityType, entityRenderer, registrationHelper, context) -> {
-			if (entityRenderer != null) {
-				FeatureRendererContext<LivingEntity, EntityModel<LivingEntity>> featureRendererContext =
-						new FeatureRendererContext<>() {
-							@Override
-							public EntityModel<LivingEntity> getModel() {
-								return null;
-							}
 
-							@Override
-							public Identifier getTexture(LivingEntity entity) {
-								return null;
-							}
-						};
-				registrationHelper.register(new JetpackRenderer<>(featureRendererContext));
-			}
-		});
+		LivingEntityFeatureRendererRegistrationCallback.EVENT.register(
+				(entityType, entityRenderer, registrationHelper, context) -> {
+					if (entityRenderer != null && entityType == EntityType.PLAYER) {
+						// Construct your feature renderer with the context
+						// Need to get the PlayerEntity somehow here
+						registrationHelper.register(new JetpackRenderer(entityRenderer));
+					}
+				}
+		);
 	}
 }

src/client/java/konhaiii/powered_jetpacks/StackToolTipHandler.java

@@ -4,7 +4,6 @@ import konhaiii.powered_jetpacks.energy.EnergySystem;
 import konhaiii.powered_jetpacks.item.special.JetpackItem;
 import net.fabricmc.fabric.api.client.item.v1.ItemTooltipCallback;
 import net.minecraft.client.gui.screen.Screen;
-import net.minecraft.client.item.TooltipContext;
 import net.minecraft.client.resource.language.I18n;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
@@ -15,8 +14,15 @@ import net.minecraft.util.Formatting;
 import java.util.List;
 
 public class StackToolTipHandler implements ItemTooltipCallback {
+
+	private int percentage(double CurrentValue, double MaxValue) {
+		if (CurrentValue == 0)
+			return 0;
+		return (int) ((CurrentValue * 100.0f) / MaxValue);
+	}
+
 	@Override
-	public void getTooltip(ItemStack itemStack, TooltipContext tooltipContext, List<Text> tooltipLines) {
+	public void getTooltip(ItemStack itemStack, Item.TooltipContext tooltipContext, net.minecraft.item.tooltip.TooltipType tooltipType, List<Text> list) {
 		Item item = itemStack.getItem();
 		if (item instanceof JetpackItem jetpackItem) {
 
@@ -26,14 +32,14 @@ public class StackToolTipHandler implements ItemTooltipCallback {
 				line1.append(EnergySystem.getEnergyUnit(jetpackItem.getEnergyCapacity(itemStack)));
 				line1.formatted(Formatting.GOLD);
 
-				tooltipLines.add(1, line1);
+				list.add(1, line1);
 
 				int percentage = percentage(jetpackItem.getStoredEnergy(itemStack), jetpackItem.getEnergyCapacity(itemStack));
 				MutableText line2  = Text.literal(String.valueOf(percentage)).append("%");
 				line2.append(" ");
 				line2.formatted(Formatting.GRAY);
 				line2.append(I18n.translate("tooltip.powered_jetpacks.power_charged"));
-				tooltipLines.add(2, line2);
+				list.add(2, line2);
 
 				double inputRate = jetpackItem.getEnergyMaxInput(itemStack);
 				double outputRate = jetpackItem.getEnergyMaxOutput(itemStack);
@@ -60,21 +66,15 @@ public class StackToolTipHandler implements ItemTooltipCallback {
 					line3.append(EnergySystem.getEnergyUnitDiminished(outputRate));
 					line3.formatted(Formatting.GOLD);
 				}
-				tooltipLines.add(3, line3);
+				list.add(3, line3);
 			} else {
 				MutableText line1 = Text.literal(EnergySystem.getEnergyDiminished(jetpackItem.getStoredEnergy(itemStack)));
 				line1.append("/");
 				line1.append(EnergySystem.getEnergyUnitDiminished(jetpackItem.getEnergyCapacity(itemStack)));
 				line1.formatted(Formatting.GOLD);
 
-				tooltipLines.add(1, line1);
+				list.add(1, line1);
 			}
 		}
 	}
-
-	private int percentage(double CurrentValue, double MaxValue) {
-		if (CurrentValue == 0)
-			return 0;
-		return (int) ((CurrentValue * 100.0f) / MaxValue);
-	}
 }

src/client/java/konhaiii/powered_jetpacks/hud/JetpackHUD.java

@@ -6,6 +6,7 @@ import net.fabricmc.fabric.api.client.rendering.v1.HudRenderCallback;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.font.TextRenderer;
 import net.minecraft.client.gui.DrawContext;
+import net.minecraft.client.render.RenderTickCounter;
 import net.minecraft.entity.EquipmentSlot;
 import net.minecraft.entity.LivingEntity;
 import net.minecraft.item.ItemStack;
@@ -16,9 +17,18 @@ import java.lang.reflect.Method;
 import static net.minecraft.client.resource.language.I18n.translate;
 
 public class JetpackHUD implements HudRenderCallback {
+	private boolean isValidJetpack(ItemStack stack) {
+		return stack.getItem() instanceof JetpackItem;
+	}
+
+	private int percentage(double CurrentValue, double MaxValue) {
+		if (CurrentValue == 0)
+			return 0;
+		return (int) ((CurrentValue * 100.0f) / MaxValue);
+	}
 
 	@Override
-	public void onHudRender(DrawContext drawContext, float tickDelta) {
+	public void onHudRender(DrawContext drawContext, RenderTickCounter renderTickCounter) {
 		MinecraftClient client = MinecraftClient.getInstance();
 		if (client.player == null) return;
 
@@ -31,7 +41,7 @@ public class JetpackHUD implements HudRenderCallback {
 				Method getBackStackMethod = optionalClass.getMethod("getBackStack", LivingEntity.class);
 				backStack = (ItemStack) getBackStackMethod.invoke(null, client.player);
 			} catch (ClassNotFoundException | NoSuchMethodException | InvocationTargetException |
-			         IllegalAccessException e) {
+					 IllegalAccessException e) {
 				PoweredJetpacks.LOGGER.error("JetpackHUD: Could not load Trinkets compat class.");
 			}
 		}
@@ -50,14 +60,4 @@ public class JetpackHUD implements HudRenderCallback {
 			drawContext.drawTextWithShadow(textRenderer, energyText, 10, 10, 0xFFFFFF);
 		}
 	}
-
-	private boolean isValidJetpack(ItemStack stack) {
-		return stack.getItem() instanceof JetpackItem;
-	}
-
-	private int percentage(double CurrentValue, double MaxValue) {
-		if (CurrentValue == 0)
-			return 0;
-		return (int) ((CurrentValue * 100.0f) / MaxValue);
-	}
 }

src/client/java/konhaiii/powered_jetpacks/mixin/client/ClientPlayerEntityMixin.java

@@ -28,7 +28,7 @@ public abstract class ClientPlayerEntityMixin {
 	@Inject(method = "tick", at = @At("HEAD"))
 	private void onTick(CallbackInfo ci) {
 		ClientPlayerEntity player = (ClientPlayerEntity) (Object) this;
-		if (player.input.jumping) {
+		if (player.input.playerInput.jump()) {
 			ItemStack chestStack = player.getEquippedStack(EquipmentSlot.CHEST);
 			ItemStack backStack = ItemStack.EMPTY;
 
@@ -51,7 +51,8 @@ public abstract class ClientPlayerEntityMixin {
 			}
 
 			if (jetpackStack != null) {
-				PacketByteBuf buf = PacketByteBufs.create();
+				JetpackPacket packet;
+
 				JetpackItem jetpack = (JetpackItem) jetpackStack.getItem();
 				Vec3d velocity = player.getVelocity();
 				float horizontalBoost = jetpack.getFlightSpeed();
@@ -64,12 +65,12 @@ public abstract class ClientPlayerEntityMixin {
 
 				soundCounter++;
 				if (soundCounter >= 8) {
-					JetpackPacket.encode(new JetpackPacket(true), buf);
+					packet = new JetpackPacket(true);
 					soundCounter = 0;
 				} else {
-					JetpackPacket.encode(new JetpackPacket(false), buf);
+					packet = new JetpackPacket(false);
 				}
-				ClientPlayNetworking.send(JetpackPacket.getPacketId(), buf);
+				ClientPlayNetworking.send(packet);
 			} else if (soundCounter != 8) {
 				soundCounter = 8;
 			}

src/client/java/konhaiii/powered_jetpacks/models/JetpackModel.java

@@ -4,21 +4,26 @@ import konhaiii.powered_jetpacks.PoweredJetpacks;
 import net.minecraft.client.model.ModelPart;
 import net.minecraft.client.render.VertexConsumer;
 import net.minecraft.client.render.entity.model.EntityModel;
+import net.minecraft.client.render.entity.model.EntityModelLayer;
+import net.minecraft.client.render.entity.state.PlayerEntityRenderState;
 import net.minecraft.client.util.math.MatrixStack;
-import net.minecraft.entity.LivingEntity;
+import net.minecraft.util.Identifier;
 import net.minecraft.util.math.Direction;
+import org.jetbrains.annotations.NotNull;
 
 import java.util.*;
 
-public class JetpackModel<T extends LivingEntity> extends EntityModel<T> {
+public class JetpackModel extends EntityModel<PlayerEntityRenderState> {
 	private final ModelPart middle;
 	private final ModelPart bottomLeft;
 	private final ModelPart bottomRight;
 	private final ModelPart mainLeft;
 	private final ModelPart mainRight;
+	public static final EntityModelLayer MODEL_LAYER = new EntityModelLayer(Identifier.of(PoweredJetpacks.MOD_ID, "jetpack"), "main");
 
-	public JetpackModel() {
-		ModelPart middleTemp;
+	public JetpackModel(@NotNull ModelPart modelPart) {
+        super(modelPart);
+        ModelPart middleTemp;
 		ModelPart bottomLeftTemp;
 		ModelPart bottomRightTemp;
 		ModelPart mainLeftTemp;
@@ -157,14 +162,14 @@ public class JetpackModel<T extends LivingEntity> extends EntityModel<T> {
 	}
 
 	@Override
-	public void setAngles(T entity, float limbAngle, float limbDistance, float animationProgress, float headYaw, float headPitch) {}
+	public void setAngles(PlayerEntityRenderState state) {
+	}
 
-	@Override
-	public void render(MatrixStack matrices, VertexConsumer vertices, int light, int overlay, float red, float green, float blue, float alpha) {
-		middle.render(matrices, vertices, light, overlay, red, green, blue, alpha);
-		bottomLeft.render(matrices, vertices, light, overlay, red, green, blue, alpha);
-		bottomRight.render(matrices, vertices, light, overlay, red, green, blue, alpha);
-		mainLeft.render(matrices, vertices, light, overlay, red, green, blue, alpha);
-		mainRight.render(matrices, vertices, light, overlay, red, green, blue, alpha);
+	public void renderRaw(MatrixStack matrices, VertexConsumer vertices, int light, int overlay, int color)  {
+		middle.render(matrices, vertices, light, overlay, color);
+		bottomLeft.render(matrices, vertices, light, overlay, color);
+		bottomRight.render(matrices, vertices, light, overlay, color);
+		mainLeft.render(matrices, vertices, light, overlay, color);
+		mainRight.render(matrices, vertices, light, overlay, color);
 	}
 }

src/client/java/konhaiii/powered_jetpacks/renderers/JetpackRenderer.java

@@ -4,72 +4,81 @@ import konhaiii.powered_jetpacks.PoweredJetpacks;
 import konhaiii.powered_jetpacks.item.ModItems;
 import konhaiii.powered_jetpacks.item.special.JetpackItem;
 import konhaiii.powered_jetpacks.models.JetpackModel;
-import net.minecraft.client.render.OverlayTexture;
-import net.minecraft.client.render.RenderLayer;
-import net.minecraft.client.render.VertexConsumer;
-import net.minecraft.client.render.VertexConsumerProvider;
+import net.minecraft.client.render.*;
+import net.minecraft.client.render.entity.LivingEntityRenderer;
 import net.minecraft.client.render.entity.feature.FeatureRenderer;
 import net.minecraft.client.render.entity.feature.FeatureRendererContext;
-import net.minecraft.client.render.entity.model.EntityModel;
+import net.minecraft.client.render.entity.model.EntityModelLayers;
+import net.minecraft.client.render.entity.state.PlayerEntityRenderState;
 import net.minecraft.client.util.math.MatrixStack;
 import net.minecraft.entity.EquipmentSlot;
-import net.minecraft.entity.LivingEntity;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.math.RotationAxis;
 
-import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
-public class JetpackRenderer<T extends LivingEntity, M extends EntityModel<T>> extends FeatureRenderer<T, M> {
-	private final JetpackModel<T> jetpackModel;
-	private static final Identifier BASIC_JETPACK_TEXTURE = new Identifier(PoweredJetpacks.MOD_ID, "textures/jetpack/basic_jetpack.png");
-	private static final Identifier ADVANCED_JETPACK_TEXTURE = new Identifier(PoweredJetpacks.MOD_ID, "textures/jetpack/advanced_jetpack.png");
-	private static final Identifier INDUSTRIAL_JETPACK_TEXTURE = new Identifier(PoweredJetpacks.MOD_ID, "textures/jetpack/industrial_jetpack.png");
+public class JetpackRenderer extends FeatureRenderer<PlayerEntityRenderState, JetpackModel> {
 
-	public JetpackRenderer(FeatureRendererContext<T, M> context) {
-		super(context);
-		this.jetpackModel = new JetpackModel<>();
+	private final JetpackModel jetpackModel;
+
+	private static final Identifier BASIC_JETPACK_TEXTURE = Identifier.of(PoweredJetpacks.MOD_ID, "textures/jetpack/basic_jetpack.png");
+	private static final Identifier ADVANCED_JETPACK_TEXTURE = Identifier.of(PoweredJetpacks.MOD_ID, "textures/jetpack/advanced_jetpack.png");
+	private static final Identifier INDUSTRIAL_JETPACK_TEXTURE = Identifier.of(PoweredJetpacks.MOD_ID, "textures/jetpack/industrial_jetpack.png");
+
+	public JetpackRenderer(LivingEntityRenderer entityRenderer) {
+		super(entityRenderer);
+		// Grab the model part from the entity renderer
+		this.jetpackModel = new JetpackModel(entityRenderer.getModel().getRootPart());
 	}
 
-	@Override
-	public void render(MatrixStack matrixStack, VertexConsumerProvider vertexConsumerProvider, int light, T entity, float limbAngle, float limbDistance, float tickDelta, float animationProgress, float headYaw, float headPitch) {
-		ItemStack chestStack = entity.getEquippedStack(EquipmentSlot.CHEST);
+    @Override
+	public void render(MatrixStack matrices, VertexConsumerProvider vertexConsumers, int light,
+					   PlayerEntityRenderState state, float limbAngle, float limbDistance) {
+		// Determine which item stack is being worn
+		ItemStack chestStack = state.equippedChestStack;
 		ItemStack backStack = ItemStack.EMPTY;
-		if (PoweredJetpacks.isTrinketsLoaded) {
-			try {
-				Class<?> optionalClass = Class.forName("konhaiii.powered_jetpacks.compat.TrinketsServer");
-				Method getBackStackMethod = optionalClass.getMethod("getBackStack", LivingEntity.class);
-				backStack = (ItemStack) getBackStackMethod.invoke(null, entity);
-			} catch (ClassNotFoundException | NoSuchMethodException | InvocationTargetException |
-			         IllegalAccessException e) {
-				PoweredJetpacks.LOGGER.error("JetpackRenderer: Could not load Trinkets compat class.");
-			}
-		}
 
-		ItemStack jetpackStack = isValidJetpack(chestStack) ? chestStack : (!backStack.isEmpty() ? backStack : ItemStack.EMPTY);
+		// Trinkets support (optional)
+		/*if (PoweredJetpacks.isTrinketsLoaded) {
+			try {
+				Class<?> trinkets = Class.forName("konhaiii.powered_jetpacks.compat.TrinketsServer");
+				Method getBackStack = trinkets.getMethod("getBackStack", state.entity().getClass());
+				backStack = (ItemStack) getBackStack.invoke(null, state.entity());
+			} catch (Exception e) {
+				PoweredJetpacks.LOGGER.error("JetpackRenderer: Could not load Trinkets compat class.", e);
+			}
+		}*/
+
+		// Pick the jetpack stack
+		ItemStack jetpackStack = chestStack.getItem() instanceof JetpackItem ? chestStack
+				: (!backStack.isEmpty() ? backStack : ItemStack.EMPTY);
 
 		if (!jetpackStack.isEmpty()) {
-			matrixStack.push();
-			matrixStack.multiply(RotationAxis.POSITIVE_X.rotationDegrees(180));
-			matrixStack.translate(-0.5D, -0.7D, -0.8D);
-			this.jetpackModel.setAngles(entity, limbAngle, limbDistance, animationProgress, headYaw, headPitch);
-			VertexConsumer vertexConsumer;
+			matrices.push();
+			// Rotate & translate to position on back
+			matrices.multiply(RotationAxis.POSITIVE_X.rotationDegrees(180));
+			matrices.translate(-0.5D, -0.7D, -0.8D);
+
+			// Update model angles
+			this.jetpackModel.setAngles(state);
+
+			// Choose correct texture
+			Identifier texture;
 			if (jetpackStack.getItem() == ModItems.BASIC_JETPACK) {
-				vertexConsumer = vertexConsumerProvider.getBuffer(RenderLayer.getEntityCutout(BASIC_JETPACK_TEXTURE));
+				texture = BASIC_JETPACK_TEXTURE;
 			} else if (jetpackStack.getItem() == ModItems.ADVANCED_JETPACK) {
-				vertexConsumer = vertexConsumerProvider.getBuffer(RenderLayer.getEntityCutout(ADVANCED_JETPACK_TEXTURE));
+				texture = ADVANCED_JETPACK_TEXTURE;
 			} else {
-				vertexConsumer = vertexConsumerProvider.getBuffer(RenderLayer.getEntityCutout(INDUSTRIAL_JETPACK_TEXTURE));
+				texture = INDUSTRIAL_JETPACK_TEXTURE;
 			}
 
-			this.jetpackModel.render(matrixStack, vertexConsumer, light, OverlayTexture.DEFAULT_UV, 1.0F, 1.0F, 1.0F, 1.0F);
+			VertexConsumer vertexConsumer = vertexConsumers.getBuffer(RenderLayer.getEntityCutout(texture));
 
-			matrixStack.pop();
+			// Render the jetpack
+			this.jetpackModel.renderRaw(matrices, vertexConsumer, light, OverlayTexture.DEFAULT_UV, 0xFFFFFFFF);
+
+			matrices.pop();
 		}
 	}
-
-	private boolean isValidJetpack(ItemStack stack) {
-		return stack.getItem() instanceof JetpackItem;
-	}
 }

src/main/java/konhaiii/powered_jetpacks/PoweredJetpacks.java

@@ -29,10 +29,7 @@ public class PoweredJetpacks implements ModInitializer {
 		config = ModConfig.loadConfig();
 		ModItems.initialize();
 		ModSounds.initialize();
-		ServerPlayNetworking.registerGlobalReceiver(JetpackPacket.getPacketId(), (server, player, handler, buf, responseSender) -> {
-			JetpackPacket packet = JetpackPacket.decode(buf);
-			server.execute(() -> JetpackPacket.handle(player, packet));
-		});
+		JetpackPacket.register();
 		LOGGER.info("Initialization completed.");
 	}
 }

src/main/java/konhaiii/powered_jetpacks/energy/EnergySystem.java

@@ -4,7 +4,7 @@ import java.text.DecimalFormat;
 import java.util.Locale;
 
 public class EnergySystem {
-	public static final String EnergyAbbreviation = "E";
+	public static final String EnergyAbbreviation = "RF";
 	public static final char[] magnitude = new char[] { 'k', 'M', 'G', 'T' };
 
 	public static String getEnergyUnitDiminished(double energy) {

src/main/java/konhaiii/powered_jetpacks/item/ModItems.java

@@ -4,35 +4,51 @@ import konhaiii.powered_jetpacks.PoweredJetpacks;
 import konhaiii.powered_jetpacks.item.special.JetpackItem;
 import net.fabricmc.fabric.api.itemgroup.v1.FabricItemGroup;
 import net.fabricmc.fabric.api.itemgroup.v1.ItemGroupEvents;
+import net.minecraft.block.AbstractBlock;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemGroup;
 import net.minecraft.item.ItemStack;
+import net.minecraft.item.equipment.ArmorMaterials;
+import net.minecraft.item.equipment.EquipmentType;
 import net.minecraft.registry.Registries;
 import net.minecraft.registry.Registry;
 import net.minecraft.registry.RegistryKey;
+import net.minecraft.registry.RegistryKeys;
 import net.minecraft.text.Text;
 import net.minecraft.util.Identifier;
 
-public class ModItems {
-	public static Item register(Item item, String id) {
-		Identifier itemID = new Identifier(PoweredJetpacks.MOD_ID, id);
+import java.util.function.Function;
 
-		return Registry.register(Registries.ITEM, itemID, item);
+public class ModItems {
+	public static Item register(String name, Function<Item.Settings, Item> itemFactory, Item.Settings settings) {
+		// Create the item key.
+		RegistryKey<Item> itemKey = RegistryKey.of(RegistryKeys.ITEM, Identifier.of(PoweredJetpacks.MOD_ID, name));
+
+		// Create the item instance.
+		Item item = itemFactory.apply(settings.registryKey(itemKey));
+
+		// Register the item.
+		Registry.register(Registries.ITEM, itemKey, item);
+
+		return item;
 	}
 
 	public static final Item BASIC_JETPACK = register(
-			new JetpackItem(PoweredJetpacks.config.basicJetpackMaxEnergy, PoweredJetpacks.config.basicJetpackInputEnergy, PoweredJetpacks.config.basicJetpackVerticalSpeed, PoweredJetpacks.config.basicJetpackHorizontalSpeed, PoweredJetpacks.config.basicJetpackEnergyCost),
-			"basic_jetpack"
+			"basic_jetpack",
+			settings -> new JetpackItem(settings, PoweredJetpacks.config.basicJetpackMaxEnergy, PoweredJetpacks.config.basicJetpackInputEnergy, PoweredJetpacks.config.basicJetpackVerticalSpeed, PoweredJetpacks.config.basicJetpackHorizontalSpeed, PoweredJetpacks.config.basicJetpackEnergyCost),
+			new Item.Settings().armor(ArmorMaterials.IRON, EquipmentType.CHESTPLATE)
 	);
 
 	public static final Item ADVANCED_JETPACK = register(
-			new JetpackItem(PoweredJetpacks.config.advancedJetpackMaxEnergy, PoweredJetpacks.config.advancedJetpackInputEnergy, PoweredJetpacks.config.advancedJetpackVerticalSpeed, PoweredJetpacks.config.advancedJetpackHorizontalSpeed, PoweredJetpacks.config.advancedJetpackEnergyCost),
-			"advanced_jetpack"
+			"advanced_jetpack",
+		 settings -> new JetpackItem(settings, PoweredJetpacks.config.advancedJetpackMaxEnergy, PoweredJetpacks.config.advancedJetpackInputEnergy, PoweredJetpacks.config.advancedJetpackVerticalSpeed, PoweredJetpacks.config.advancedJetpackHorizontalSpeed, PoweredJetpacks.config.advancedJetpackEnergyCost),
+			new Item.Settings().armor(ArmorMaterials.DIAMOND, EquipmentType.CHESTPLATE)
 	);
 
 	public static final Item INDUSTRIAL_JETPACK = register(
-			new JetpackItem(PoweredJetpacks.config.industrialJetpackMaxEnergy, PoweredJetpacks.config.industrialJetpackInputEnergy, PoweredJetpacks.config.industrialJetpackVerticalSpeed, PoweredJetpacks.config.industrialJetpackHorizontalSpeed, PoweredJetpacks.config.industrialJetpackEnergyCost),
-			"industrial_jetpack"
+			"industrial_jetpack",
+			settings -> new JetpackItem(settings, PoweredJetpacks.config.industrialJetpackMaxEnergy, PoweredJetpacks.config.industrialJetpackInputEnergy, PoweredJetpacks.config.industrialJetpackVerticalSpeed, PoweredJetpacks.config.industrialJetpackHorizontalSpeed, PoweredJetpacks.config.industrialJetpackEnergyCost),
+			new Item.Settings().armor(ArmorMaterials.NETHERITE, EquipmentType.CHESTPLATE)
 	);
 
 	public static void initialize() {
@@ -44,7 +60,7 @@ public class ModItems {
 		});
 	}
 
-	public static final RegistryKey<ItemGroup> ITEM_GROUP_KEY = RegistryKey.of(Registries.ITEM_GROUP.getKey(), new Identifier(PoweredJetpacks.MOD_ID, "item_group"));
+	public static final RegistryKey<ItemGroup> ITEM_GROUP_KEY = RegistryKey.of(Registries.ITEM_GROUP.getKey(), Identifier.of(PoweredJetpacks.MOD_ID, "item_group"));
 	public static final ItemGroup ITEM_GROUP = FabricItemGroup.builder()
 			.icon(() -> new ItemStack(BASIC_JETPACK))
 			.displayName(Text.translatable("itemGroup.powered_jetpacks"))

src/main/java/konhaiii/powered_jetpacks/item/special/JetpackItem.java

@@ -1,32 +1,35 @@
 package konhaiii.powered_jetpacks.item.special;
 
 import net.minecraft.block.DispenserBlock;
+import net.minecraft.block.dispenser.DispenserBehavior;
+import net.minecraft.component.DataComponentTypes;
+import net.minecraft.component.type.EquippableComponent;
 import net.minecraft.entity.EquipmentSlot;
 import net.minecraft.entity.player.PlayerEntity;
-import net.minecraft.item.ArmorItem;
-import net.minecraft.item.Equipment;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
+import net.minecraft.item.equipment.ArmorMaterials;
+import net.minecraft.item.equipment.EquipmentType;
+import net.minecraft.util.ActionResult;
 import net.minecraft.util.Hand;
-import net.minecraft.util.TypedActionResult;
 import net.minecraft.world.World;
 import team.reborn.energy.api.base.SimpleEnergyItem;
 
-public class JetpackItem extends Item implements SimpleEnergyItem, Equipment {
+public class JetpackItem extends Item implements SimpleEnergyItem {
 	private final int maxEnergy;
 	private final int inputEnergy;
 	private final float flightPower;
 	private final float flightSpeed;
 	private final int energyCost;
 
-	public JetpackItem(int maxEnergy, int inputEnergy, float flightPower, float flightSpeed, int energyCost) {
-		super(new Settings().maxCount(1));
+	public JetpackItem(Settings settings, int maxEnergy, int inputEnergy, float flightPower, float flightSpeed, int energyCost) {
+		super(settings.maxCount(1));
 		this.maxEnergy = maxEnergy;
 		this.inputEnergy = inputEnergy;
 		this.flightPower = flightPower;
 		this.flightSpeed = flightSpeed;
 		this.energyCost = energyCost;
-		DispenserBlock.registerBehavior(this, ArmorItem.DISPENSER_BEHAVIOR);
+		DispenserBlock.registerBehavior(this, DispenserBehavior.NOOP);
 	}
 
 	@Override
@@ -60,13 +63,11 @@ public class JetpackItem extends Item implements SimpleEnergyItem, Equipment {
 	}
 
 	@Override
-	public EquipmentSlot getSlotType() {
-		return EquipmentSlot.CHEST;
-	}
+	public ActionResult use(World world, PlayerEntity user, Hand hand) {
+		ItemStack itemStack = user.getStackInHand(hand);
 
-	@Override
-	public TypedActionResult<ItemStack> use(World world, PlayerEntity user, Hand hand) {
-		return this.equipAndSwap(this, world, user, hand);
+		EquippableComponent equippableComponent = itemStack.get(DataComponentTypes.EQUIPPABLE);
+		return equippableComponent.equip(itemStack, user);
 	}
 
 	public void extractEnergy(ItemStack stack, boolean simulate) {

src/main/java/konhaiii/powered_jetpacks/packet/JetpackPacket.java

@@ -19,11 +19,48 @@ import net.minecraft.world.World;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 
-public record JetpackPacket(boolean shouldPlaySound) {
-	private static final Identifier PACKET_ID = new Identifier(PoweredJetpacks.MOD_ID, "jetpack_packet");
+import konhaiii.powered_jetpacks.PoweredJetpacks;
+import konhaiii.powered_jetpacks.item.special.JetpackItem;
+import konhaiii.powered_jetpacks.sounds.ModSounds;
+import net.fabricmc.fabric.api.networking.v1.PayloadTypeRegistry;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayNetworking;
+import net.minecraft.entity.EquipmentSlot;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.network.PacketByteBuf;
+import net.minecraft.network.codec.PacketCodec;
+import net.minecraft.network.packet.CustomPayload;
+import net.minecraft.particle.ParticleTypes;
+import net.minecraft.server.network.ServerPlayerEntity;
+import net.minecraft.server.world.ServerWorld;
+import net.minecraft.sound.SoundCategory;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.World;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public record JetpackPacket(boolean shouldPlaySound) implements CustomPayload {
+	public static final Id<JetpackPacket> ID = new Id<>(Identifier.of(PoweredJetpacks.MOD_ID, "jetpack_packet"));
+	public static final PacketCodec<PacketByteBuf, JetpackPacket> CODEC =
+			PacketCodec.of(JetpackPacket::encode, JetpackPacket::decode);
+
+	@Override
+	public Id<? extends CustomPayload> getId() {
+		return ID;
+	}
+
+	public static void register() {
+		PayloadTypeRegistry.playC2S().register(ID, CODEC);
+		ServerPlayNetworking.registerGlobalReceiver(ID, (packet, ctx) ->
+				handle(ctx.player(), packet)
+		);
+	}
 
 	public static void encode(JetpackPacket packet, PacketByteBuf buf) {
-		buf.writeBoolean(packet.shouldPlaySound);
+		buf.writeBoolean(packet.shouldPlaySound());
 	}
 
 	public static JetpackPacket decode(PacketByteBuf buf) {
@@ -39,62 +76,47 @@ public record JetpackPacket(boolean shouldPlaySound) {
 				Class<?> optionalClass = Class.forName("konhaiii.powered_jetpacks.compat.TrinketsServer");
 				Method getBackStackMethod = optionalClass.getMethod("getBackStack", LivingEntity.class);
 				backStack = (ItemStack) getBackStackMethod.invoke(null, player);
-			} catch (ClassNotFoundException | NoSuchMethodException | InvocationTargetException |
-			         IllegalAccessException e) {
+			} catch (ClassNotFoundException | NoSuchMethodException | InvocationTargetException | IllegalAccessException e) {
 				PoweredJetpacks.LOGGER.error("JetpackPacket: Could not load Trinkets compat class.");
 			}
 		}
 
 		ItemStack jetpackStack = null;
-		if (isValidJetpack(chestStack)) {
-			jetpackStack = chestStack;
-		} else if (isValidJetpack(backStack)) {
-			jetpackStack = backStack;
-		}
+		if (isValidJetpack(chestStack)) jetpackStack = chestStack;
+		else if (isValidJetpack(backStack)) jetpackStack = backStack;
 
 		if (jetpackStack != null) {
 			JetpackItem jetpack = (JetpackItem) jetpackStack.getItem();
 			player.fallDistance = 0;
-
 			World world = player.getWorld();
-			BlockPos blockPos = player.getBlockPos();
+			BlockPos pos = player.getBlockPos();
 
-			if (packet.shouldPlaySound()) {
-				if (!world.isClient) {
-					world.playSound(null, blockPos, ModSounds.JETPACK_SOUND, SoundCategory.PLAYERS, 1f, 1f);
-				}
-			}
+			if (packet.shouldPlaySound() && !world.isClient)
+				world.playSound(null, pos, ModSounds.JETPACK_SOUND, SoundCategory.PLAYERS, 1f, 1f);
 
 			Vec3d lookVec = player.getRotationVector();
-			double offsetBack = -0.25;
-			double offsetSide = 0.2;
-			double centerX = player.getX() + lookVec.x * offsetBack;
-			double centerY = player.getY() + 0.75;
-			double centerZ = player.getZ() + lookVec.z * offsetBack;
-			double leftX = centerX + lookVec.z * offsetSide;
-			double leftZ = centerZ - lookVec.x * offsetSide;
-			double rightX = centerX - lookVec.z * offsetSide;
-			double rightZ = centerZ + lookVec.x * offsetSide;
-			((ServerWorld) world).spawnParticles(ParticleTypes.FLAME, leftX, centerY, leftZ,1,0,0,0,0.1);
-			((ServerWorld) world).spawnParticles(ParticleTypes.SMOKE, leftX, centerY, leftZ,1,0,0,0,0.1);
-			((ServerWorld) world).spawnParticles(ParticleTypes.FLAME, rightX, centerY, rightZ,1,0,0,0,0.1);
-			((ServerWorld) world).spawnParticles(ParticleTypes.SMOKE, rightX, centerY, rightZ,1,0,0,0,0.1);
+			double offsetBack = -0.25, offsetSide = 0.2;
+			double cx = player.getX() + lookVec.x * offsetBack;
+			double cy = player.getY() + 0.75;
+			double cz = player.getZ() + lookVec.z * offsetBack;
+			double leftX = cx + lookVec.z * offsetSide;
+			double leftZ = cz - lookVec.x * offsetSide;
+			double rightX = cx - lookVec.z * offsetSide;
+			double rightZ = cz + lookVec.x * offsetSide;
+
+			ServerWorld sWorld = (ServerWorld) world;
+			sWorld.spawnParticles(ParticleTypes.FLAME, leftX, cy, leftZ, 1, 0, 0, 0, 0.1);
+			sWorld.spawnParticles(ParticleTypes.SMOKE, leftX, cy, leftZ, 1, 0, 0, 0, 0.1);
+			sWorld.spawnParticles(ParticleTypes.FLAME, rightX, cy, rightZ, 1, 0, 0, 0, 0.1);
+			sWorld.spawnParticles(ParticleTypes.SMOKE, rightX, cy, rightZ, 1, 0, 0, 0, 0.1);
 
 			jetpack.extractEnergy(jetpackStack, false);
 		}
 	}
 
 	private static boolean isValidJetpack(ItemStack stack) {
-		if (stack.getItem() instanceof JetpackItem jetpack) {
-			if (jetpack.getEnergyCost() <= 0) {
-				return true;
-			}
-			return jetpack.getStoredEnergy(stack) > 0;
-		}
+		if (stack.getItem() instanceof JetpackItem jetpack)
+			return jetpack.getEnergyCost() <= 0 || jetpack.getStoredEnergy(stack) > 0;
 		return false;
 	}
-
-	public static Identifier getPacketId() {
-		return PACKET_ID;
-	}
 }

src/main/java/konhaiii/powered_jetpacks/sounds/ModSounds.java

@@ -10,7 +10,7 @@ public class ModSounds {
 	public static final SoundEvent JETPACK_SOUND = registerSoundEvent();
 
 	private static SoundEvent registerSoundEvent() {
-		Identifier id = new Identifier(PoweredJetpacks.MOD_ID, "jetpack_use");
+		Identifier id = Identifier.of(PoweredJetpacks.MOD_ID, "jetpack_use");
 		return Registry.register(Registries.SOUND_EVENT, id, SoundEvent.of(id));
 	}
 

src/main/resources/assets/powered_jetpacks/items/advanced_jetpack.json

@@ -0,0 +1,6 @@
+{
+  "model": {
+    "type": "minecraft:model",
+    "model": "powered_jetpacks:item/advanced_jetpack"
+  }
+}

src/main/resources/assets/powered_jetpacks/items/basic_jetpack.json

@@ -0,0 +1,6 @@
+{
+  "model": {
+    "type": "minecraft:model",
+    "model": "powered_jetpacks:item/basic_jetpack"
+  }
+}

src/main/resources/assets/powered_jetpacks/items/industrial_jetpack.json

@@ -0,0 +1,6 @@
+{
+  "model": {
+    "type": "minecraft:model",
+    "model": "powered_jetpacks:item/industrial_jetpack"
+  }
+}

src/main/resources/data/powered_jetpacks/recipe/advanced_jetpack.json

@@ -0,0 +1,19 @@
+{
+  "type": "minecraft:crafting_shaped",
+  "category": "equipment",
+  "key": {
+    "I": "minecraft:gold_ingot",
+    "L": "minecraft:leather",
+    "R": "minecraft:redstone",
+    "B": "minecraft:gold_block"
+  },
+  "pattern": [
+    "RIR",
+    "BLB",
+    "I I"
+  ],
+  "result": {
+    "id": "powered_jetpacks:advanced_jetpack"
+  },
+  "show_notification": true
+}

src/main/resources/data/powered_jetpacks/recipe/basic_jetpack.json

@@ -0,0 +1,19 @@
+{
+  "type": "minecraft:crafting_shaped",
+  "category": "equipment",
+  "key": {
+    "I": "minecraft:iron_ingot",
+    "L": "minecraft:leather",
+    "R": "minecraft:redstone",
+    "B": "minecraft:iron_block"
+  },
+  "pattern": [
+    "RIR",
+    "BLB",
+    "I I"
+  ],
+  "result": {
+    "id": "powered_jetpacks:basic_jetpack"
+  },
+  "show_notification": true
+}

src/main/resources/data/powered_jetpacks/recipe/industrial_jetpack.json

@@ -0,0 +1,19 @@
+{
+  "type": "minecraft:crafting_shaped",
+  "category": "equipment",
+  "key": {
+    "I": "minecraft:diamond",
+    "L": "minecraft:leather",
+    "R": "minecraft:redstone",
+    "B": "minecraft:diamond_block"
+  },
+  "pattern": [
+    "RIR",
+    "BLB",
+    "I I"
+  ],
+  "result": {
+    "id": "powered_jetpacks:industrial_jetpack"
+  },
+  "show_notification": true
+}

src/main/resources/data/powered_jetpacks/recipes/advanced_jetpack.json

@@ -1,27 +0,0 @@
-{
-  "type": "minecraft:crafting_shaped",
-  "category": "equipment",
-  "key": {
-    "I": {
-      "item": "minecraft:gold_ingot"
-    },
-    "L": {
-      "item": "minecraft:leather"
-    },
-    "R": {
-      "item": "minecraft:redstone"
-    },
-    "B": {
-      "item": "minecraft:gold_block"
-    }
-  },
-  "pattern": [
-    "RIR",
-    "BLB",
-    "I I"
-  ],
-  "result": {
-    "item": "powered_jetpacks:advanced_jetpack"
-  },
-  "show_notification": true
-}

src/main/resources/data/powered_jetpacks/recipes/basic_jetpack.json

@@ -1,27 +0,0 @@
-{
-  "type": "minecraft:crafting_shaped",
-  "category": "equipment",
-  "key": {
-    "I": {
-      "item": "minecraft:iron_ingot"
-    },
-    "L": {
-      "item": "minecraft:leather"
-    },
-    "R": {
-      "item": "minecraft:redstone"
-    },
-    "B": {
-      "item": "minecraft:iron_block"
-    }
-  },
-  "pattern": [
-    "RIR",
-    "BLB",
-    "I I"
-  ],
-  "result": {
-    "item": "powered_jetpacks:basic_jetpack"
-  },
-  "show_notification": true
-}

src/main/resources/data/powered_jetpacks/recipes/industrial_jetpack.json

@@ -1,27 +0,0 @@
-{
-  "type": "minecraft:crafting_shaped",
-  "category": "equipment",
-  "key": {
-    "I": {
-      "item": "minecraft:diamond"
-    },
-    "L": {
-      "item": "minecraft:leather"
-    },
-    "R": {
-      "item": "minecraft:redstone"
-    },
-    "B": {
-      "item": "minecraft:diamond_block"
-    }
-  },
-  "pattern": [
-    "RIR",
-    "BLB",
-    "I I"
-  ],
-  "result": {
-    "item": "powered_jetpacks:industrial_jetpack"
-  },
-  "show_notification": true
-}

src/main/resources/fabric.mod.json

@@ -5,6 +5,7 @@
 	"name": "Powered Jetpacks",
 	"description": "Add energy-powered jetpacks to Minecraft.",
 	"authors": [
+		"fucksophie",
 		"Konhaiii"
 	],
 	"contact": {
@@ -32,8 +33,8 @@
 	],
 	"depends": {
 		"fabricloader": ">=0.16.10",
-		"minecraft": "~1.20.1",
-		"java": ">=17",
+		"minecraft": "1.21.8",
+		"java": ">=21",
 		"fabric-api": "*"
 	},
 	"suggests": {