添加突刺爆雷

src/main/java/com/atsuishio/superbwarfare/ModUtils.java

@@ -158,6 +158,7 @@ public class ModUtils {
         addNetworkMessage(ContainerDataMessage.class, ContainerDataMessage::encode, ContainerDataMessage::decode, ContainerDataMessage::handler, Optional.of(NetworkDirection.PLAY_TO_CLIENT));
         addNetworkMessage(RadarChangeModeMessage.class, RadarChangeModeMessage::encode, RadarChangeModeMessage::decode, RadarChangeModeMessage::handler);
         addNetworkMessage(RadarSetParametersMessage.class, RadarSetParametersMessage::encode, RadarSetParametersMessage::decode, RadarSetParametersMessage::handler);
+        addNetworkMessage(LungeMineAttackMessage.class, LungeMineAttackMessage::encode, LungeMineAttackMessage::decode, LungeMineAttackMessage::handler);
 
         event.enqueueWork(() -> BrewingRecipeRegistry.addRecipe(Ingredient.of(PotionUtils.setPotion(new ItemStack(Items.POTION), Potions.WATER)),
                 Ingredient.of(Items.LIGHTNING_ROD), PotionUtils.setPotion(new ItemStack(Items.POTION), ModPotion.SHOCK.get())));

src/main/java/com/atsuishio/superbwarfare/client/ClickHandler.java

@@ -87,9 +87,12 @@ public class ClickHandler {
 
         int button = event.getButton();
 
-        if (stack.is(ModTags.Items.GUN) || stack.is(ModItems.MONITOR.get()) || player.hasEffect(ModMobEffects.SHOCK.get())
+        if (stack.is(ModTags.Items.GUN) || stack.is(ModItems.MONITOR.get()) || stack.is(ModItems.LUNGE_MINE.get()) || player.hasEffect(ModMobEffects.SHOCK.get())
                 || (player.getVehicle() instanceof IArmedVehicleEntity && !(player.getVehicle() instanceof WheelChairEntity))) {
             if (button == GLFW.GLFW_MOUSE_BUTTON_LEFT) {
+                if (stack.is(ModItems.LUNGE_MINE.get())) {
+                    ModUtils.PACKET_HANDLER.sendToServer(new LungeMineAttackMessage(0));
+                }
                 event.setCanceled(true);
             }
         }

src/main/java/com/atsuishio/superbwarfare/client/model/item/LungeMineModel.java

@@ -0,0 +1,24 @@
+package com.atsuishio.superbwarfare.client.model.item;
+
+import com.atsuishio.superbwarfare.ModUtils;
+import com.atsuishio.superbwarfare.item.LungeMine;
+import net.minecraft.resources.ResourceLocation;
+import software.bernie.geckolib.model.GeoModel;
+
+public class LungeMineModel extends GeoModel<LungeMine> {
+
+    @Override
+    public ResourceLocation getAnimationResource(LungeMine animatable) {
+        return ModUtils.loc("animations/lunge_mine.animation.json");
+    }
+
+    @Override
+    public ResourceLocation getModelResource(LungeMine animatable) {
+        return ModUtils.loc("geo/lunge_mine.geo.json");
+    }
+
+    @Override
+    public ResourceLocation getTextureResource(LungeMine animatable) {
+        return ModUtils.loc("textures/item/lunge_mine.png");
+    }
+}

src/main/java/com/atsuishio/superbwarfare/client/renderer/item/LungeMineRenderer.java

@@ -0,0 +1,111 @@
+package com.atsuishio.superbwarfare.client.renderer.item;
+
+import com.atsuishio.superbwarfare.client.AnimationHelper;
+import com.atsuishio.superbwarfare.client.model.item.LungeMineModel;
+import com.atsuishio.superbwarfare.item.LungeMine;
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.blaze3d.vertex.VertexConsumer;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.model.PlayerModel;
+import net.minecraft.client.player.AbstractClientPlayer;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.entity.player.PlayerRenderer;
+import net.minecraft.client.renderer.texture.OverlayTexture;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.ItemDisplayContext;
+import net.minecraft.world.item.ItemStack;
+import software.bernie.geckolib.cache.object.BakedGeoModel;
+import software.bernie.geckolib.cache.object.GeoBone;
+import software.bernie.geckolib.renderer.GeoItemRenderer;
+import software.bernie.geckolib.util.RenderUtils;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class LungeMineRenderer extends GeoItemRenderer<LungeMine> {
+
+    public LungeMineRenderer() {
+        super(new LungeMineModel());
+    }
+
+    @Override
+    public RenderType getRenderType(LungeMine animatable, ResourceLocation texture, MultiBufferSource bufferSource, float partialTick) {
+        return RenderType.entityTranslucent(getTextureLocation(animatable));
+    }
+
+    private static final float SCALE_RECIPROCAL = 1.0f / 16.0f;
+    protected boolean renderArms = false;
+    protected MultiBufferSource currentBuffer;
+    protected RenderType renderType;
+    public ItemDisplayContext transformType;
+    protected LungeMine animatable;
+    private final Set<String> hiddenBones = new HashSet<>();
+
+    @Override
+    public void renderByItem(ItemStack stack, ItemDisplayContext transformType, PoseStack matrixStack, MultiBufferSource bufferIn, int combinedLightIn, int p_239207_6_) {
+        this.transformType = transformType;
+        if (this.animatable != null)
+            this.animatable.getTransformType(transformType);
+        super.renderByItem(stack, transformType, matrixStack, bufferIn, combinedLightIn, p_239207_6_);
+    }
+
+    @Override
+    public void actuallyRender(PoseStack matrixStackIn, LungeMine animatable, BakedGeoModel model, RenderType type, MultiBufferSource renderTypeBuffer, VertexConsumer vertexBuilder, boolean isRenderer, float partialTicks, int packedLightIn,
+                               int packedOverlayIn, float red, float green, float blue, float alpha) {
+        this.currentBuffer = renderTypeBuffer;
+        this.renderType = type;
+        this.animatable = animatable;
+        super.actuallyRender(matrixStackIn, animatable, model, type, renderTypeBuffer, vertexBuilder, isRenderer, partialTicks, packedLightIn, packedOverlayIn, red, green, blue, alpha);
+        if (this.renderArms) {
+            this.renderArms = false;
+        }
+    }
+
+    @Override
+    public void renderRecursively(PoseStack stack, LungeMine animatable, GeoBone bone, RenderType type, MultiBufferSource buffer, VertexConsumer bufferIn, boolean isReRender, float partialTick, int packedLightIn, int packedOverlayIn, float red,
+                                  float green, float blue, float alpha) {
+        Minecraft mc = Minecraft.getInstance();
+        String name = bone.getName();
+        boolean renderingArms = false;
+        if (name.equals("Lefthand")) {
+            bone.setHidden(true);
+            renderingArms = true;
+        } else {
+            bone.setHidden(this.hiddenBones.contains(name));
+        }
+
+        if (this.transformType.firstPerson() && renderingArms) {
+            AbstractClientPlayer localPlayer = mc.player;
+
+            if (localPlayer == null) {
+                return;
+            }
+
+            PlayerRenderer playerRenderer = (PlayerRenderer) mc.getEntityRenderDispatcher().getRenderer(localPlayer);
+            PlayerModel<AbstractClientPlayer> model = playerRenderer.getModel();
+            stack.pushPose();
+            RenderUtils.translateMatrixToBone(stack, bone);
+            RenderUtils.translateToPivotPoint(stack, bone);
+            RenderUtils.rotateMatrixAroundBone(stack, bone);
+            RenderUtils.scaleMatrixForBone(stack, bone);
+            RenderUtils.translateAwayFromPivotPoint(stack, bone);
+            ResourceLocation loc = localPlayer.getSkinTextureLocation();
+            VertexConsumer armBuilder = this.currentBuffer.getBuffer(RenderType.entitySolid(loc));
+            VertexConsumer sleeveBuilder = this.currentBuffer.getBuffer(RenderType.entityTranslucent(loc));
+            stack.translate(-1.0f * SCALE_RECIPROCAL, 2.0f * SCALE_RECIPROCAL, 0.0f);
+            AnimationHelper.renderPartOverBone(model.leftArm, bone, stack, armBuilder, packedLightIn, OverlayTexture.NO_OVERLAY, 1);
+            AnimationHelper.renderPartOverBone(model.leftSleeve, bone, stack, sleeveBuilder, packedLightIn, OverlayTexture.NO_OVERLAY, 1);
+
+            this.currentBuffer.getBuffer(this.renderType);
+            stack.popPose();
+        }
+        super.renderRecursively(stack, animatable, bone, type, buffer, bufferIn, isReRender, partialTick, packedLightIn, packedOverlayIn, red, green, blue, alpha);
+    }
+
+    @Override
+    public ResourceLocation getTextureLocation(LungeMine instance) {
+        return super.getTextureLocation(instance);
+    }
+}
+

src/main/java/com/atsuishio/superbwarfare/init/ModItems.java

@@ -99,6 +99,7 @@ public class ModItems {
     public static final RegistryObject<Item> JAVELIN_MISSILE = AMMO.register("javelin_missile", () -> new Item(new Item.Properties()));
     public static final RegistryObject<Item> MORTAR_SHELLS = AMMO.register("mortar_shells", () -> new Item(new Item.Properties()));
     public static final RegistryObject<Item> ROCKET = AMMO.register("rocket", Rocket::new);
+    public static final RegistryObject<Item> LUNGE_MINE = AMMO.register("lunge_mine", LungeMine::new);
     public static final RegistryObject<Item> HE_5_INCHES = AMMO.register("he_5_inches", He5Inches::new);
     public static final RegistryObject<Item> AP_5_INCHES = AMMO.register("ap_5_inches", Ap5Inches::new);
     public static final RegistryObject<Item> HAND_GRENADE = AMMO.register("hand_grenade", HandGrenade::new);

src/main/java/com/atsuishio/superbwarfare/item/LungeMine.java

@@ -0,0 +1,201 @@
+package com.atsuishio.superbwarfare.item;
+
+import com.atsuishio.superbwarfare.client.renderer.item.LungeMineRenderer;
+import com.atsuishio.superbwarfare.config.server.ExplosionDestroyConfig;
+import com.atsuishio.superbwarfare.init.ModDamageTypes;
+import com.atsuishio.superbwarfare.init.ModItems;
+import com.atsuishio.superbwarfare.tools.CustomExplosion;
+import com.atsuishio.superbwarfare.tools.ParticleTool;
+import com.atsuishio.superbwarfare.tools.TraceTool;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.model.HumanoidModel;
+import net.minecraft.client.player.LocalPlayer;
+import net.minecraft.client.renderer.BlockEntityWithoutLevelRenderer;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.sounds.SoundEvents;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.util.Mth;
+import net.minecraft.world.InteractionHand;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.HumanoidArm;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.Item;
+import net.minecraft.world.item.ItemDisplayContext;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.ClipContext;
+import net.minecraft.world.level.Explosion;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.HitResult;
+import net.minecraft.world.phys.Vec3;
+import net.minecraftforge.client.extensions.common.IClientItemExtensions;
+import software.bernie.geckolib.animatable.GeoItem;
+import software.bernie.geckolib.core.animatable.instance.AnimatableInstanceCache;
+import software.bernie.geckolib.core.animation.AnimatableManager;
+import software.bernie.geckolib.core.animation.AnimationController;
+import software.bernie.geckolib.core.animation.AnimationState;
+import software.bernie.geckolib.core.animation.RawAnimation;
+import software.bernie.geckolib.core.object.PlayState;
+import software.bernie.geckolib.util.GeckoLibUtil;
+
+import java.util.function.Consumer;
+
+public class LungeMine extends Item implements GeoItem, AnimatedItem {
+    private final AnimatableInstanceCache cache = GeckoLibUtil.createInstanceCache(this);
+    public static ItemDisplayContext transformType;
+
+    public LungeMine() {
+        super(new Properties().stacksTo(1));
+    }
+
+    @Override
+    public void initializeClient(Consumer<IClientItemExtensions> consumer) {
+        super.initializeClient(consumer);
+        consumer.accept(new IClientItemExtensions() {
+            private final BlockEntityWithoutLevelRenderer renderer = new LungeMineRenderer();
+
+            @Override
+            public BlockEntityWithoutLevelRenderer getCustomRenderer() {
+                return renderer;
+            }
+
+            private static final HumanoidModel.ArmPose LungeMinePose = HumanoidModel.ArmPose.create("LungeMine", false, (model, entity, arm) -> {
+                if (arm != HumanoidArm.LEFT) {
+                    model.rightArm.xRot = -22.5f * Mth.DEG_TO_RAD + model.head.xRot;
+                    model.rightArm.yRot = -10f * Mth.DEG_TO_RAD;
+                    model.leftArm.xRot = -55f * Mth.DEG_TO_RAD + model.head.xRot;
+                    model.leftArm.yRot = 50f * Mth.DEG_TO_RAD;
+                }
+            });
+
+            @Override
+            public HumanoidModel.ArmPose getArmPose(LivingEntity entityLiving, InteractionHand hand, ItemStack itemStack) {
+                if (!itemStack.isEmpty()) {
+                    if (entityLiving.getUsedItemHand() == hand) {
+                        return LungeMinePose;
+                    }
+                }
+                return HumanoidModel.ArmPose.EMPTY;
+            }
+        });
+    }
+
+    public static void attack(ItemStack stack, Player player) {
+        if (stack.getOrCreateTag().getInt("AttackTime") == 0) {
+            stack.getOrCreateTag().putInt("AttackTime" , 6);
+            player.getCooldowns().addCooldown(stack.getItem(), 6);
+            player.level().playSound(null, player.getOnPos(), SoundEvents.PLAYER_ATTACK_SWEEP, SoundSource.PLAYERS, 1, 1);
+        }
+
+    }
+
+    public void getTransformType(ItemDisplayContext type) {
+        transformType = type;
+    }
+
+    private PlayState idlePredicate(AnimationState<LungeMine> event) {
+        LocalPlayer player = Minecraft.getInstance().player;
+        if (player == null) return PlayState.STOP;
+        ItemStack stack = player.getMainHandItem();
+        if (stack.is(ModItems.LUNGE_MINE.get())) {
+            if (stack.getOrCreateTag().getInt("AttackTime") > 0) {
+                return event.setAndContinue(RawAnimation.begin().thenPlay("animation.lunge_mine.fire"));
+            }
+        }
+        return event.setAndContinue(RawAnimation.begin().thenLoop("animation.lunge_mine.idle"));
+    }
+
+    @Override
+    public void registerControllers(AnimatableManager.ControllerRegistrar data) {
+        var idleController = new AnimationController<>(this, "idleController", 0, this::idlePredicate);
+        data.add(idleController);
+    }
+
+    @Override
+    public AnimatableInstanceCache getAnimatableInstanceCache() {
+        return this.cache;
+    }
+
+    @Override
+    public void setAnimationProcedure(String procedure) {
+    }
+
+    @Override
+    public boolean onEntitySwing(ItemStack stack, LivingEntity entity) {
+        return false;
+    }
+
+    @Override
+    public boolean shouldCauseReequipAnimation(ItemStack oldStack, ItemStack newStack, boolean slotChanged) {
+        return false;
+    }
+
+    @Override
+    public boolean canAttackBlock(BlockState p_41441_, Level p_41442_, BlockPos p_41443_, Player p_41444_) {
+        return false;
+    }
+
+    @Override
+    public void inventoryTick(ItemStack itemstack, Level world, Entity entity, int slot, boolean selected) {
+        super.inventoryTick(itemstack, world, entity, slot, selected);
+
+        if (itemstack.getOrCreateTag().getInt("AttackTime") ==3) {
+            if (selected && entity.level() instanceof ServerLevel) {
+                boolean lookAtEntity = false;
+
+                Entity lookingEntity = TraceTool.findLookingEntity(entity,4.5);
+
+                HitResult result = entity.level().clip(new ClipContext(entity.getEyePosition(), entity.getEyePosition().add(entity.getLookAngle().scale(4.5)),
+                        ClipContext.Block.OUTLINE, ClipContext.Fluid.NONE, entity));
+
+                Vec3 looking = Vec3.atLowerCornerOf(entity.level().clip(new ClipContext(entity.getEyePosition(), entity.getEyePosition().add(entity.getLookAngle().scale(4)), ClipContext.Block.OUTLINE, ClipContext.Fluid.NONE, entity)).getBlockPos());
+                BlockState blockState = entity.level().getBlockState(BlockPos.containing(looking.x(), looking.y(), looking.z()));
+
+                Vec3 hitPos = result.getLocation();
+
+                if (lookingEntity != null) {
+                    lookAtEntity = true;
+                }
+
+//                if (entity instanceof Player player) {
+//                    player.displayClientMessage(Component.literal("" + lookAtEntity), true);
+//                }
+
+                if (lookAtEntity) {
+                    if (entity instanceof Player player && !player.isCreative()) {
+                        itemstack.shrink(1);
+                    }
+                    lookingEntity.hurt(ModDamageTypes.causeCannonFireDamage(entity.level().registryAccess(), entity, entity), 150);
+                    causeLungeMineExplode(entity.level(), entity, lookingEntity);
+                } else if (blockState.canOcclude()) {
+                    if (entity instanceof Player player && !player.isCreative()) {
+                        itemstack.shrink(1);
+                    }
+                    CustomExplosion explosion = new CustomExplosion(entity.level(), null,
+                            ModDamageTypes.causeProjectileBoomDamage(entity.level().registryAccess(), entity, entity), 60,
+                            looking.x, looking.y, looking.z, 5f, ExplosionDestroyConfig.EXPLOSION_DESTROY.get() ? Explosion.BlockInteraction.DESTROY : Explosion.BlockInteraction.KEEP).setDamageMultiplier(1.25f);
+                    explosion.explode();
+                    net.minecraftforge.event.ForgeEventFactory.onExplosionStart(entity.level(), explosion);
+                    explosion.finalizeExplosion(false);
+                    ParticleTool.spawnMediumExplosionParticles(entity.level(), hitPos);
+                }
+            }
+        }
+
+        if (itemstack.getOrCreateTag().getInt("AttackTime") > 0) {
+            itemstack.getOrCreateTag().putInt("AttackTime", itemstack.getOrCreateTag().getInt("AttackTime") - 1);
+        }
+    }
+
+    public static void causeLungeMineExplode(Level pLevel, Entity entity, Entity pLivingEntity) {
+        CustomExplosion explosion = new CustomExplosion(pLevel, pLivingEntity,
+                ModDamageTypes.causeProjectileBoomDamage(pLevel.registryAccess(), pLivingEntity, entity), 60,
+                pLivingEntity.getX(), pLivingEntity.getY(), pLivingEntity.getZ(), 5f, ExplosionDestroyConfig.EXPLOSION_DESTROY.get() ? Explosion.BlockInteraction.DESTROY : Explosion.BlockInteraction.KEEP).setDamageMultiplier(1.25f);
+        explosion.explode();
+        net.minecraftforge.event.ForgeEventFactory.onExplosionStart(pLevel, explosion);
+        explosion.finalizeExplosion(false);
+        ParticleTool.spawnMediumExplosionParticles(pLevel, pLivingEntity.position());
+    }
+}

src/main/java/com/atsuishio/superbwarfare/item/gun/GunItem.java

@@ -93,7 +93,7 @@ public abstract class GunItem extends Item {
 
     @Override
     public boolean onEntitySwing(ItemStack stack, LivingEntity entity) {
-        return super.onEntitySwing(stack, entity);
+        return false;
     }
 
     @Override

src/main/java/com/atsuishio/superbwarfare/network/message/LungeMineAttackMessage.java

@@ -0,0 +1,45 @@
+package com.atsuishio.superbwarfare.network.message;
+
+import com.atsuishio.superbwarfare.init.ModItems;
+import com.atsuishio.superbwarfare.item.LungeMine;
+import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraftforge.network.NetworkEvent;
+
+import java.util.function.Supplier;
+
+public class LungeMineAttackMessage {
+
+    private final int type;
+
+    public LungeMineAttackMessage(int type) {
+        this.type = type;
+    }
+
+    public static LungeMineAttackMessage decode(FriendlyByteBuf buffer) {
+        return new LungeMineAttackMessage(buffer.readInt());
+    }
+
+    public static void encode(LungeMineAttackMessage message, FriendlyByteBuf buffer) {
+        buffer.writeInt(message.type);
+    }
+
+    public static void handler(LungeMineAttackMessage message, Supplier<NetworkEvent.Context> contextSupplier) {
+        NetworkEvent.Context context = contextSupplier.get();
+        context.enqueueWork(() -> {
+            if (context.getSender() != null) {
+                Player player = context.getSender();
+
+                ItemStack stack = player.getMainHandItem();
+
+                if (stack.is(ModItems.LUNGE_MINE.get())) {
+                    if (message.type == 0) {
+                        LungeMine.attack(stack,player);
+                    }
+                }
+            }
+        });
+        context.setPacketHandled(true);
+    }
+}

src/main/java/com/atsuishio/superbwarfare/tools/SeekTool.java

@@ -1,6 +1,5 @@
 package com.atsuishio.superbwarfare.tools;
 
-import com.atsuishio.superbwarfare.entity.IArmedVehicleEntity;
 import com.atsuishio.superbwarfare.entity.VehicleEntity;
 import com.atsuishio.superbwarfare.entity.projectile.ProjectileEntity;
 import net.minecraft.core.BlockPos;
@@ -79,7 +78,7 @@ public class SeekTool {
                 .filter(e -> e.distanceToSqr(pos.getX(), pos.getY(), pos.getZ()) <= range * range
                         && e.isAlive()
                         && !(e instanceof ItemEntity || e instanceof ExperienceOrb || e instanceof HangingEntity || e instanceof ProjectileEntity || e instanceof Projectile || e instanceof ArmorStand)
-                        && (e instanceof LivingEntity || e instanceof IArmedVehicleEntity)
+                        && (e instanceof LivingEntity || e instanceof VehicleEntity)
                         && !(e instanceof Player player && (player.isCreative() || player.isSpectator())))
                 .toList();
     }

src/main/java/com/atsuishio/superbwarfare/tools/TraceTool.java

@@ -28,7 +28,7 @@ public class TraceTool {
         Vec3 viewVec = entity.getViewVector(1.0F);
         Vec3 toVec = eyePos.add(viewVec.x * entityReach, viewVec.y * entityReach, viewVec.z * entityReach);
         AABB aabb = entity.getBoundingBox().expandTowards(viewVec.scale(entityReach)).inflate(1.0D, 1.0D, 1.0D);
-        EntityHitResult entityhitresult = ProjectileUtil.getEntityHitResult(entity, eyePos, toVec, aabb, p -> !p.isSpectator(), distance);
+        EntityHitResult entityhitresult = ProjectileUtil.getEntityHitResult(entity, eyePos, toVec, aabb, p -> !p.isSpectator() && entity.getVehicle() != p && p.isAlive(), distance);
         if (entityhitresult != null) {
             Vec3 targetPos = entityhitresult.getLocation();
             double distanceToTarget = eyePos.distanceToSqr(targetPos);
@@ -68,7 +68,7 @@ public class TraceTool {
         Vec3 viewVec = player.getViewVector(1.0F);
         Vec3 toVec = eyePos.add(viewVec.x * entityReach, viewVec.y * entityReach, viewVec.z * entityReach);
         AABB aabb = player.getBoundingBox().expandTowards(viewVec.scale(entityReach)).inflate(1.0D, 1.0D, 1.0D);
-        EntityHitResult entityhitresult = ProjectileUtil.getEntityHitResult(player, eyePos, toVec, aabb, p -> !p.isSpectator() && p.isAlive(), distance);
+        EntityHitResult entityhitresult = ProjectileUtil.getEntityHitResult(player, eyePos, toVec, aabb, p -> !p.isSpectator() && player.getVehicle() != p && p.isAlive(), distance);
         if (entityhitresult != null) {
             Vec3 targetPos = entityhitresult.getLocation();
             double distanceToTarget = eyePos.distanceToSqr(targetPos);

src/main/resources/assets/superbwarfare/animations/lunge_mine.animation.json

@@ -0,0 +1,86 @@
+{
+	"format_version": "1.8.0",
+	"animations": {
+		"animation.lunge_mine.idle": {
+			"loop": true
+		},
+		"animation.lunge_mine.fire": {
+			"animation_length": 0.25,
+			"bones": {
+				"bone": {
+					"rotation": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.05": {
+							"vector": [1.73, 0, 0]
+						},
+						"0.0917": {
+							"vector": [-6, 0, 0]
+						},
+						"0.1833": {
+							"vector": [0.73, 0, 0]
+						},
+						"0.2417": {
+							"vector": [0, 0, 0]
+						}
+					},
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.05": {
+							"vector": [0, -0.4, 2]
+						},
+						"0.0917": {
+							"vector": [0, 0, -6]
+						},
+						"0.1833": {
+							"vector": [0, 0, 2]
+						},
+						"0.2417": {
+							"vector": [0, 0, 0]
+						}
+					}
+				},
+				"Lefthand": {
+					"rotation": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.05": {
+							"vector": [-9.75, 2.75, 0]
+						},
+						"0.0917": {
+							"vector": [20.25, -5.25, -6.25]
+						},
+						"0.1833": {
+							"vector": [-9.75, 2.75, 0]
+						},
+						"0.2417": {
+							"vector": [0, 0, 0]
+						}
+					},
+					"position": {
+						"0.0": {
+							"vector": [0, 0, 0]
+						},
+						"0.05": {
+							"vector": [1.755, 0, -0.945]
+						},
+						"0.0917": {
+							"vector": [-2.555, 0.405, 1.37]
+						},
+						"0.1833": {
+							"vector": [1.755, 0, -0.945]
+						},
+						"0.2417": {
+							"vector": [0, 0, 0]
+						}
+					}
+				}
+			}
+		}
+	},
+	"geckolib_format_version": 2
+}

src/main/resources/assets/superbwarfare/lang/en_us.json

@@ -153,6 +153,7 @@
   "item.superbwarfare.ap_5_inches": "AP Shell",
   "item.superbwarfare.javelin_missile": "Javelin Missile",
   "item.superbwarfare.heavy_ammo": "Heavy Ammo",
+  "item.superbwarfare.lunge_mine": "Lunge Mine",
 
   "block.superbwarfare.container": "Container",
   "des.superbwarfare.container.empty": "空的",

src/main/resources/assets/superbwarfare/lang/zh_cn.json

@@ -153,6 +153,7 @@
   "item.superbwarfare.ap_5_inches": "穿甲弹",
   "item.superbwarfare.javelin_missile": "标枪导弹",
   "item.superbwarfare.heavy_ammo": "重型弹药",
+  "item.superbwarfare.lunge_mine": "突刺爆雷",
 
   "block.superbwarfare.container": "集装箱",
   "des.superbwarfare.container.empty": "空的",

src/main/resources/assets/superbwarfare/models/displaysettings/lunge_mine.json

@@ -0,0 +1,114 @@
+{
+  "credit": "Made with Blockbench",
+  "parent": "builtin/entity",
+  "texture_size": [
+    32,
+    32
+  ],
+  "display": {
+    "thirdperson_righthand": {
+      "rotation": [
+        67.5,
+        7,
+        0
+      ],
+      "translation": [
+        -1.75,
+        2.5,
+        -0.25
+      ],
+      "scale": [
+        1.1,
+        1.1,
+        1.2
+      ]
+    },
+    "thirdperson_lefthand": {
+      "scale": [
+        0,
+        0,
+        0
+      ]
+    },
+    "firstperson_righthand": {
+      "rotation": [
+        7.14,
+        -1.62,
+        11.61
+      ],
+      "translation": [
+        -3.75,
+        -1,
+        0
+      ],
+      "scale": [
+        1.2,
+        1.2,
+        1.3
+      ]
+    },
+    "firstperson_lefthand": {
+      "scale": [
+        0,
+        0,
+        0
+      ]
+    },
+    "ground": {
+      "rotation": [
+        -90,
+        0,
+        0
+      ],
+      "translation": [
+        0,
+        24.75,
+        0
+      ]
+    },
+    "gui": {
+      "rotation": [
+        138.65,
+        -34.86,
+        151.18
+      ],
+      "translation": [
+        0,
+        -0.25,
+        0
+      ],
+      "scale": [
+        0.5,
+        0.5,
+        0.5
+      ]
+    },
+    "head": {
+      "rotation": [
+        -90,
+        0,
+        0
+      ],
+      "translation": [
+        0,
+        29.75,
+        0
+      ]
+    },
+    "fixed": {
+      "rotation": [
+        90,
+        45,
+        -90
+      ],
+      "scale": [
+        0.5,
+        0.5,
+        0.5
+      ]
+    }
+  },
+  "textures": {
+    "particle": "item/lunge_mine"
+  }
+}

src/main/resources/assets/superbwarfare/models/item/lunge_mine.json

@@ -0,0 +1,27 @@
+{
+	"loader": "forge:separate_transforms",
+	"gui_light": "front",
+	"base": {
+		"parent": "superbwarfare:item/lunge_mine_base"
+	},
+	"perspectives": {
+		"gui": {
+			"parent": "superbwarfare:item/lunge_mine_icon"
+		},
+		"thirdperson_righthand": {
+			"parent": "superbwarfare:item/lunge_mine_base"
+		},
+		"thirdperson_lefthand": {
+			"parent": "superbwarfare:item/lunge_mine_icon"
+		},
+		"ground": {
+			"parent": "superbwarfare:item/lunge_mine_icon"
+		},
+		"fixed": {
+			"parent": "superbwarfare:item/lunge_mine_icon"
+		},
+		"head": {
+		"parent": "superbwarfare:item/lunge_mine_base"
+		}
+	}
+}

src/main/resources/assets/superbwarfare/models/item/lunge_mine_base.json

@@ -0,0 +1,6 @@
+{
+  "parent": "superbwarfare:displaysettings/lunge_mine",
+  "textures": {
+    "layer0": "superbwarfare:item/lunge_mine"
+  }
+}

src/main/resources/assets/superbwarfare/models/item/lunge_mine_icon.json

@@ -0,0 +1,6 @@
+{
+  "parent": "item/generated",
+  "textures": {
+    "layer0": "superbwarfare:item/lunge_mine_icon"
+  }
+}

src/main/resources/data/superbwarfare/recipes/lunge_mine_crafting.json

@@ -0,0 +1,24 @@
+{
+  "type": "minecraft:crafting_shaped",
+  "category": "misc",
+  "pattern": [
+    " ba",
+    " cb",
+    "c  "
+  ],
+  "key": {
+    "a": {
+      "item": "minecraft:tnt"
+    },
+    "b": {
+      "item": "superbwarfare:high_energy_explosives"
+    },
+    "c": {
+      "item": "minecraft:stick"
+    }
+  },
+  "result": {
+    "item": "superbwarfare:lunge_mine",
+    "count": 2
+  }
+}