D

make mod pearl catching in mid air InstantPearlCatch makes instant pearl catches, or IPCs, work in vanilla Minecraft.

Without InstantPearlCatch, vanilla Minecraft prevents consistent IPCs with ender pearls and wind charges.

Behavior Allows ender pearls to catch wind charges during same-tick IPC throws.

Makes IPCs depend on player timing instead of vanilla tick-order variation.

This is literally not a cheat why did this get featured in a "how to be like rapture" video Supported versions Minecraft Java 1.21 through 1.21.11

📎 1 file 1,612 chars
📄
pasted-code-1792902455537.txt
txt 26 lines
▶
Pearl Catch Mod
Pearl Catch Mod is a Minecraft combat and movement utility designed to make advanced Ender Pearl catching techniques faster, easier, and more consistent.

✦ Upper Pearl Catch
Perform an Upper Pearl Catch by throwing an Ender Pearl upward and using the timed catch sequence. The mod handles the required timing, allowing you to quickly reposition or teleport through the air.

✦ Side Pearl Catch
The Side Pearl Catch lets you perform the same concept from a horizontal or sideways position. This is useful for quickly changing direction, escaping attacks, or repositioning during combat.

✦ Waiting Charge
After initiating the pearl sequence, the mod uses a configurable waiting delay before performing the catch action. This delay gives you control over how quickly the sequence happens and allows you to adjust it for different situations.

✦ Customizable Delay
You can easily adjust the Pearl Catch delay in-game using the [ and ] keys.

[ → Decrease the delay

] → Increase the delay

This allows you to fine-tune the timing without opening a configuration menu. Adjust the delay until the pearl-catching sequence feels comfortable and consistent with your playstyle.

✦ Fast Aerial Teleportation
Once the timing is correctly configured, the mod helps execute the pearl-catching sequence quickly, allowing you to teleport through the air and rapidly reposition yourself.

✦ Combat & Movement
Pearl Catch Mod is especially useful for advanced movement, clutch situations, escapes, repositioning, and fast-paced Minecraft combat where precise Ender Pearl timing matters.
Kodari AI
KodariOct 25 at 4:38 am 2
InstantPearlCatch
InstantPearlCatch makes instant pearl catches, or IPCs, work in vanilla Minecraft. Without InstantPearlCatch, vanilla Minecraft prevents consistent IPCs with ender pearls and wind charges. Behavior: Allows ender pearls to catch wind charges during same-tick IPC throws. Makes IPCs depend on player timing instead of vanilla tick-order variation. This is literally not a cheat why did this get featured in a "how to be like rapture" video. Supported versions: Minecraft Java 1.21 through 1.21.11.
  1. Inspect the 1.21.11 pearl and wind-charge tick/collision logic to identify the ordering race.

  2. Build the minimal Fabric mod and mixin that makes same-tick catches depend on player timing.

  3. Add the mod metadata, mixin config, and survival-free utility packaging.The attached key-sequence outline conflicts with the main behavior description, so I’m following the stated IPC fix: remove tick-order variation without automating throws or catches.

Created the Fabric 1.21.11 Instant Pearl Catch mod. It defers ender pearl ticks until the other entities have ticked, so same-tick wind-charge knockback is applied before pearl movement instead of depending on entity insertion order.

This keeps catches player-timed; it doesn’t automate throws or add delay/keybind macros. No new items or survival recipes are needed.

D

also keybind macros and see physics then throw to pearl catch

Kodari AI
KodariOct 25 at 4:53 am 2
  • Add a client throw keybind and [/] delay controls, without automating player movement or catch inputs.

  • Show an approximate pearl arc and predicted block impact in the HUD.

  • Register the client entrypoint and Fabric API dependency.

Added a client-side pearl throw macro on R. Use and ] to set its delay from 0–40 ticks. While holding a pearl, the HUD shows an approximate trajectory and predicted block impact.

The macro performs one normal pearl use; it doesn’t aim, move, or automatically catch for you. The preview shows a mean arc and ignores random spread, entities, and water.

D

makes the mod unexpacted if i press the keybind in 80 degree or any degree it wind brust and pear catches in air using physics like if i throw pearl in 75 degree or 73 degree or 60 degree it cathes pearl using physics and timing i can set macro

Kodari AI
KodariOct 25 at 5:00 am 2
  1. Check the existing throw keybind, delay controls, and trajectory preview.

  2. Verify the exact 1.21.11 APIs needed for a timed wind-charge/pearl sequence and angle-based prediction.

  3. Update the macro so its timing and throw angle are configurable, without adding automatic aiming or movement.

Updated the R macro: hold an Ender Pearl and Wind Charge in opposite hands, and it throws the charge first, then the pearl after the configured delay. and ] adjust the delay; at 0 ticks, both uses are sent in the same client tick.

It uses your current aim angle and shows that angle with the pearl’s approximate trajectory. Vanilla physics handles the throws and any catch—the macro doesn’t auto-aim or guarantee a catch. Without a Wind Charge held, R still does a delayed pearl-only throw.

Kodari can make mistakes. Review important code before using.
Files
src
build.gradle
gradle.properties
settings.gradle
Code
8 369
src/client/java/com/kodari/instantpearlcatch/InstantPearlCatchClient.java
package com.kodari.instantpearlcatch;

import net.fabricmc.api.ClientModInitializer;
import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
import net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper;
import net.fabricmc.fabric.api.client.rendering.v1.hud.HudElementRegistry;
import net.minecraft.client.MinecraftClient;
import net.minecraft.client.font.TextRenderer;
import net.minecraft.client.gui.DrawContext;
import net.minecraft.client.option.KeyBinding;
import net.minecraft.entity.player.PlayerEntity;
import net.minecraft.item.Items;
import net.minecraft.util.Hand;
import net.minecraft.util.Identifier;
import net.minecraft.util.hit.BlockHitResult;
import net.minecraft.util.hit.HitResult;
import net.minecraft.util.math.Vec3d;
import net.minecraft.world.RaycastContext;

import java.util.ArrayList;
import java.util.List;

public class InstantPearlCatchClient implements ClientModInitializer {
    private static final int MAX_DELAY_TICKS = 40;
    private static final int MAX_PREVIEW_TICKS = 120;
    private static final KeyBinding.Category CATEGORY = KeyBinding.Category.create(
            Identifier.of("instantpearlcatch", "main")
    );
    private static final KeyBinding THROW_KEY = KeyBindingHelper.registerKeyBinding(new KeyBinding(
            "key.instantpearlcatch.throw", 82, CATEGORY
    ));
    private static final KeyBinding DECREASE_DELAY_KEY = KeyBindingHelper.registerKeyBinding(new KeyBinding(
            "key.instantpearlcatch.decrease_delay", 91, CATEGORY
    ));
    private static final KeyBinding INCREASE_DELAY_KEY = KeyBindingHelper.registerKeyBinding(new KeyBinding(
            "key.instantpearlcatch.increase_delay", 93, CATEGORY
    ));

    private static int delayTicks;
    private static int pendingThrowTicks = -1;
    private static Hand pendingPearlHand;
    private static boolean pendingWindCharge;
    private static Trajectory trajectory;

    @Override
    public void onInitializeClient() {
        ClientTickEvents.END_CLIENT_TICK.register(client -> {
            if (client.player == null || client.world == null || client.interactionManager == null) {
                trajectory = null;
                pendingThrowTicks = -1;
                pendingPearlHand = null;
                pendingWindCharge = false;
                return;
            }

            while (DECREASE_DELAY_KEY.wasPressed()) {
                delayTicks = Math.max(0, delayTicks - 1);
            }
            while (INCREASE_DELAY_KEY.wasPressed()) {
                delayTicks = Math.min(MAX_DELAY_TICKS, delayTicks + 1);
            }
            while (THROW_KEY.wasPressed()) {
                Hand pearlHand = findPearlHand(client.player);
                if (pearlHand != null && pendingThrowTicks < 0) {
                    Hand windChargeHand = findWindChargeHand(client.player);
                    if (windChargeHand != null) {
                        client.interactionManager.interactItem(client.player, windChargeHand);
                    }
                    pendingPearlHand = pearlHand;
                    pendingWindCharge = windChargeHand != null;
                    pendingThrowTicks = delayTicks;
                }
            }

            if (pendingThrowTicks >= 0) {
                if (pendingThrowTicks == 0) {
                    if (pendingPearlHand != null
                            && client.player.getStackInHand(pendingPearlHand).isOf(Items.ENDER_PEARL)) {
                        client.interactionManager.interactItem(client.player, pendingPearlHand);
                    }
                    pendingThrowTicks = -1;
                    pendingPearlHand = null;
                    pendingWindCharge = false;
                } else {
                    pendingThrowTicks--;
                }
            }

            trajectory = findPearlHand(client.player) == null
                    ? null
                    : predictTrajectory(client, client.player);
        });

        HudElementRegistry.addLast(Identifier.of("instantpearlcatch", "pearl_trajectory"),
                (context, tickCounter) -> renderTrajectory(context));
    }

    private static Hand findPearlHand(PlayerEntity player) {
        if (player.getStackInHand(Hand.MAIN_HAND).isOf(Items.ENDER_PEARL)) {
            return Hand.MAIN_HAND;
        }
        if (player.getStackInHand(Hand.OFF_HAND).isOf(Items.ENDER_PEARL)) {
            return Hand.OFF_HAND;
        }
        return null;
    }

    private static Hand findWindChargeHand(PlayerEntity player) {
        if (player.getStackInHand(Hand.MAIN_HAND).isOf(Items.WIND_CHARGE)) {
            return Hand.MAIN_HAND;
        }
        if (player.getStackInHand(Hand.OFF_HAND).isOf(Items.WIND_CHARGE)) {
            return Hand.OFF_HAND;
        }
        return null;
    }

    private static Trajectory predictTrajectory(MinecraftClient client, PlayerEntity player) {
        double yaw = Math.toRadians(player.getYaw());
        double pitch = Math.toRadians(player.getPitch());
        Vec3d direction = new Vec3d(
                -Math.sin(yaw) * Math.cos(pitch),
                -Math.sin(pitch),
                Math.cos(yaw) * Math.cos(pitch)
        ).normalize();
        Vec3d velocity = direction.multiply(1.5).add(
                player.getMovement().x,
                player.isOnGround() ? 0.0 : player.getMovement().y,
                player.getMovement().z
        );
        Vec3d position = player.getEyePos().add(0.0, -0.1, 0.0);
        Vec3d origin = position;
        List<Vec3d> points = new ArrayList<>();
        points.add(position);

        for (int tick = 1; tick <= MAX_PREVIEW_TICKS; tick++) {
            velocity = new Vec3d(velocity.x, velocity.y - 0.03, velocity.z).multiply(0.99);
            Vec3d nextPosition = position.add(velocity);
            BlockHitResult hit = client.world.raycast(new RaycastContext(
                    position,
                    nextPosition,
                    RaycastContext.ShapeType.COLLIDER,
                    RaycastContext.FluidHandling.NONE,
                    player
            ));
            if (hit.getType() != HitResult.Type.MISS) {
                points.add(hit.getPos());
                return new Trajectory(origin, points, hit.getPos(), tick, true);
            }

            position = nextPosition;
            points.add(position);
        }

        return new Trajectory(origin, points, position, MAX_PREVIEW_TICKS, false);
    }

    private static void renderTrajectory(DrawContext context) {
        MinecraftClient client = MinecraftClient.getInstance();
        Trajectory current = trajectory;
        if (client.player == null || current == null) {
            return;
        }

        int left = 8;
        int top = 36;
        int graphLeft = left + 8;
        int graphTop = top + 35;
        int graphWidth = 132;
        int graphHeight = 62;
        context.fill(left, top, left + 168, top + 132, 0xB0101420);

        TextRenderer textRenderer = client.textRenderer;
        context.drawText(textRenderer, "Pearl path (approx.)", left + 6, top + 5, 0xFFFFFFFF, true);
        context.drawText(textRenderer, "R IPC | [ ] delay: " + delayTicks + "t", left + 6, top + 18, 0xFFD0D8E8, true);
        String sequence = pendingWindCharge || findWindChargeHand(client.player) != null
                ? "Charge -> pearl"
                : "Pearl only";
        context.drawText(textRenderer, "Pitch " + Math.round(client.player.getPitch()) + "° | " + sequence,
                left + 6, top + 30, 0xFFD0D8E8, true);
        context.fill(graphLeft, graphTop, graphLeft + graphWidth, graphTop + graphHeight, 0x80405060);

        double maxDistance = 0.0;
        double minY = current.origin().y;
        double maxY = current.origin().y;
        for (Vec3d point : current.points()) {
            double dx = point.x - current.origin().x;
            double dz = point.z - current.origin().z;
            maxDistance = Math.max(maxDistance, Math.sqrt(dx * dx + dz * dz));
            minY = Math.min(minY, point.y);
            maxY = Math.max(maxY, point.y);
        }

        maxDistance = Math.max(maxDistance, 1.0);
        double heightRange = Math.max(maxY - minY, 1.0);
        for (Vec3d point : current.points()) {
            double dx = point.x - current.origin().x;
            double dz = point.z - current.origin().z;
            int x = graphLeft + (int) Math.round(Math.sqrt(dx * dx + dz * dz) / maxDistance * (graphWidth - 4));
            int y = graphTop + graphHeight - 3 - (int) Math.round((point.y - minY) / heightRange * (graphHeight - 6));