minecraft-kajetans-mod/src/main/java/me/km/utils/Utils.java

package me.km.utils;

import java.util.List;
import net.minecraft.entity.Entity;
import net.minecraft.entity.LivingEntity;
import net.minecraft.entity.player.PlayerEntity;
import net.minecraft.entity.player.ServerPlayerEntity;
import net.minecraft.entity.projectile.ProjectileEntity;
import net.minecraft.server.MinecraftServer;
import net.minecraft.util.math.AxisAlignedBB;
import net.minecraft.world.IWorld;
import net.minecraft.util.DamageSource;
import net.minecraft.util.RegistryKey;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.math.RayTraceContext;
import net.minecraft.util.math.RayTraceResult;
import net.minecraft.util.math.vector.Vector3d;
import net.minecraft.util.registry.Registry;
import net.minecraft.world.World;
import net.minecraft.world.server.ServerWorld;

public class Utils {
    public static Entity getEntityFromProjectile(Entity ent) {
        if(ent instanceof ProjectileEntity) {
            return ((ProjectileEntity) ent).getOwner();
        }
        return null;
    }

    public static PlayerEntity getDamager(DamageSource ds) {
        Entity ent = ds.getEntity();
        if(ent == null) {
            return null;
        }
        if(ent instanceof PlayerEntity) {
            return (PlayerEntity) ent;
        }
        return null;
    }

    private static AxisAlignedBB buildBoxAround(double x, double y, double z, double radius) {
        return new AxisAlignedBB(x - radius, y - radius, z - radius, x + radius, y + radius,
                z + radius);
    }

    public static <T extends Entity> List<T> getEntities(IWorld w, double x, double y, double z,
            double radius, Class<T> type) {
        double sqareRadius = radius * radius;
        return w.getEntitiesOfClass(type, buildBoxAround(x, y, z, radius),
                ent -> ent.distanceToSqr(x, y, z) <= sqareRadius);
    }

    public static List<Entity> getEntities(Entity ent, double radius) {
        double sqareRadius = radius * radius;
        double x = ent.getX();
        double y = ent.getY();
        double z = ent.getZ();
        return ent.level.getEntities(ent, buildBoxAround(x, y, z, radius),
                e -> e.distanceToSqr(x, y, z) <= sqareRadius);
    }

    public static List<Entity> getEntities(Location loc, double radius) {
        double sqareRadius = radius * radius;
        double x = loc.getX();
        double y = loc.getY();
        double z = loc.getZ();
        return loc.getWorld().getEntities((Entity) null, buildBoxAround(x, y, z, radius),
                ent -> ent.distanceToSqr(x, y, z) <= sqareRadius);
    }

    public static List<PlayerEntity> getPlayers(IWorld w, double x, double y, double z,
            double radius) {
        double sqareRadius = radius * radius;
        return w.getEntitiesOfClass(PlayerEntity.class, buildBoxAround(x, y, z, radius),
                p -> p.distanceToSqr(x, y, z) <= sqareRadius);
    }

    public static List<PlayerEntity> getPlayers(Entity not, double radius) {
        double sqareRadius = radius * radius;
        return not.level.getEntitiesOfClass(PlayerEntity.class,
                buildBoxAround(not.getX(), not.getY(), not.getZ(), radius),
                p -> p != not && p.distanceToSqr(not) <= sqareRadius);
    }

    public static List<LivingEntity> getLiving(Entity not, double radius) {
        double sqareRadius = radius * radius;
        return not.level.getEntitiesOfClass(LivingEntity.class,
                buildBoxAround(not.getX(), not.getY(), not.getZ(), radius),
                p -> p != not && p.distanceToSqr(not) <= sqareRadius);
    }

    public static List<LivingEntity> getLiving(Location loc, double radius) {
        double sqareRadius = radius * radius;
        double x = loc.getX();
        double y = loc.getY();
        double z = loc.getZ();
        return loc.getWorld().getEntitiesOfClass(LivingEntity.class,
                buildBoxAround(x, y, z, radius), p -> p.distanceToSqr(x, y, z) <= sqareRadius);
    }

    public static <T extends Entity> T getEntity(IWorld w, double x, double y, double z,
            double radius, Class<T> type) {
        return getEntities(w, x, y, z, radius, type).stream().min(
                (e1, e2) -> Double.compare(e1.distanceToSqr(x, y, z), e2.distanceToSqr(x, y, z)))
                .orElse(null);
    }

    private static boolean doesIntersect(AxisAlignedBB bound, Vector3d start, Vector3d unit) {
        double lowerX = Double.NEGATIVE_INFINITY;
        double upperX = Double.POSITIVE_INFINITY;
        if(unit.x != 0) {
            if(unit.x > 0) {
                lowerX = (bound.minX - start.x) / unit.x;
                upperX = (bound.maxX - start.x) / unit.x;
            } else {
                lowerX = (bound.maxX - start.x) / unit.x;
                upperX = (bound.minX - start.x) / unit.x;
            }
        }

        double lowerY = Double.NEGATIVE_INFINITY;
        double upperY = Double.POSITIVE_INFINITY;
        if(unit.y != 0) {
            if(unit.y > 0) {
                lowerY = (bound.minY - start.y) / unit.y;
                upperY = (bound.maxY - start.y) / unit.y;
            } else {
                lowerY = (bound.maxY - start.y) / unit.y;
                upperY = (bound.minY - start.y) / unit.y;
            }
        }

        double lowerZ = Double.NEGATIVE_INFINITY;
        double upperZ = Double.POSITIVE_INFINITY;
        if(unit.z != 0) {
            if(unit.z > 0) {
                lowerZ = (bound.minZ - start.z) / unit.z;
                upperZ = (bound.maxZ - start.z) / unit.z;
            } else {
                lowerZ = (bound.maxZ - start.z) / unit.z;
                upperZ = (bound.minZ - start.z) / unit.z;
            }
        }

        return Math.max(Math.max(lowerX, lowerY), lowerZ) < Math.min(Math.min(upperX, upperY),
                upperZ);
    }

    private static Vector3d getTargetVector(Entity ent, double range) {
        if(range > 128) {
            range = 128;
        }
        World w = ent.level;
        Vector3d start = ent.getEyePosition(1.0f);
        Vector3d look = ent.getForward();
        Vector3d end = start.add(look.x * range, look.y * range, look.z * range);

        RayTraceResult ray = w.clip(new RayTraceContext(start, end,
                RayTraceContext.BlockMode.COLLIDER, RayTraceContext.FluidMode.NONE, ent));
        if(ray == null || ray.getLocation() == null) {
            return end;
        }
        return ray.getLocation();
    }

    @SuppressWarnings("unchecked")
    public static <T extends Entity> T getTargetedEntity(PlayerEntity p, double radius,
            Class<T> type) {
        World w = p.level;
        Vector3d l = getTargetVector(p, radius);
        Vector3d eye = p.getEyePosition(1.0f);
        Vector3d unit = new Vector3d(l.x - eye.x, l.y - eye.y, l.z - eye.z);

        List<Entity> col = w.getEntities(p, new AxisAlignedBB(eye.x, eye.y, eye.z, l.x, l.y, l.z));
        col.removeIf(ent -> !type.isAssignableFrom(ent.getClass()));
        // removes entities, which do not intersect with the sight vector
        col.removeIf(ent -> !doesIntersect(ent.getBoundingBox().inflate(0.1), eye, unit));

        return (T) col.stream().sorted((Entity e1, Entity e2) -> {
            return Double.compare(e1.distanceToSqr(eye.x, eye.y, eye.z),
                    e2.distanceToSqr(eye.x, eye.y, eye.z));
        }).findFirst().orElse(null);
    }

    public static ServerPlayerEntity getPlayerByName(MinecraftServer server, String name) {
        String nameLower = name.toLowerCase();
        return server.getPlayerList().getPlayers().stream()
                .filter(pl -> pl.getName().getContents().toLowerCase().contains(nameLower))
                .findFirst().orElse(null);
    }

    public static String getWorldName(World w) {
        return w.dimension().getRegistryName().getPath();
    }

    public static World getWorldFromName(MinecraftServer server, String name) {
        ServerWorld sw = server.getLevel(
                RegistryKey.create(Registry.DIMENSION_REGISTRY, new ResourceLocation(name)));
        if(sw != null) {
            return sw;
        }
        return server.getLevel(
                RegistryKey.create(Registry.DIMENSION_REGISTRY, new ResourceLocation("km", name)));
    }
}