BlurpRaycast

BlurpRaycast is a builder-style utility for performing raycasting in plugins.

Features

• Builder pattern for fluent raycast configuration

• Cast rays from a location in a direction (vector)

• Set max distance and precision (step size)

• Ignore entities, fluids, or blocks as needed

• Filter which entities and blocks are considered

• Returns the first hit block or entity (with hit location)

• Simple API for common raycasting needs

Usage

Basic Example

BlurpRaycast raycast = new BlurpRaycast()
    .from(player.getEyeLocation())
    .vector(player.getLocation().getDirection())
    .maxDistance(20)
    .precision(0.2F);

BlurpRaycast.RaycastResult result = raycast.cast();

if (result != null) {
    if (result.hitEntity()) {
        // Handle entity hit
    } else if (result.hitBlock()) {
        // Handle block hit
    }
}

Ignore Entities or Blocks

new BlurpRaycast()
    .from(location)
    .vector(direction)
    .ignoreEntities()
    .ignoreBlocks()
    .cast();

Filtering Entities or Blocks

new BlurpRaycast()
    .from(location)
    .vector(direction)
    .filter(entity -> entity instanceof Player, Entity.class)
    .filter(block -> block.getType().isSolid(), Block.class)
    .cast();

API Reference

Method	Description
from(Location)	Set the starting location
vector(Vector)	Set the direction vector
maxDistance(float)	Set the maximum raycast distance
precision(float)	Set the step size (default: 0.25)
ignoreEntities()	Ignore entities during raycast
ignoreFluids()	Ignore fluid blocks during raycast
ignoreBlocks()	Ignore blocks (ray passes through all blocks)
filter(Predicate, Class)	Filter entities or blocks (use Entity/Block)
cast()	Perform the raycast and return result

RaycastResult

• getHitLocation(): The location where the ray hit

• getGitEntity(): The entity hit (if any)

• getGitBlock(): The block hit (if any)

• hitEntity(): Returns true if an entity was hit

• hitBlock(): Returns true if a block was hit

Notes

• All distances are in blocks.

• Precision should be > 0; smaller values are more accurate but slower.