sophie/powered_jetpacks
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

port to 1.21.8
Some checks are pending
build / build (push) Waiting to run
Details

Browse source
This commit is contained in:
Soph :3 2025-10-06 22:57:40 +03:00
parent c3903552c8
commit d26d4f0ea8
30 changed files with 326 additions and 267 deletions
Download patch file Download diff file Expand all files Collapse all files

29
src/client/java/konhaiii/powered_jetpacks/PoweredJetpacksClient.java
View file

@ -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));
}
}
);
}
}

24
src/client/java/konhaiii/powered_jetpacks/StackToolTipHandler.java
View file

@ -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);
}
}

24
src/client/java/konhaiii/powered_jetpacks/hud/JetpackHUD.java
View file

@ -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);
}
}

11
src/client/java/konhaiii/powered_jetpacks/mixin/client/ClientPlayerEntityMixin.java
View file

@ -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;
}

29
src/client/java/konhaiii/powered_jetpacks/models/JetpackModel.java
View file

@ -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);
}
}

97
src/client/java/konhaiii/powered_jetpacks/renderers/JetpackRenderer.java
View file

@ -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;
}
}
}