DreamBlock.java

Go to the documentation of this file.

/*
 * MIT License
 *
 * Copyright (c) 2025 Dreamfire Studio
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */
package com.dreamfirestudios.dreamcore.DreamBlock;
 
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.block.Block;
 
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.function.Predicate;
 
public class DreamBlock {
 
    // ============================================================
    // Synchronous Methods
    // ============================================================
 
    public static List<Block> filterBlocksInRadius(final Location location, final int radius, final int step,
                                                   final RegionShape shape, final Predicate<Block> condition) {
        List<Block> result = new ArrayList<>();
        final World world = location.getWorld();
        if (world == null || step <= 0) return result;
 
        final int cx = location.getBlockX();
        final int cy = location.getBlockY();
        final int cz = location.getBlockZ();
 
        final int r2 = radius * radius;
        for (int x = cx - radius; x < cx + radius; x += step) {
            for (int y = cy - radius; y < cy + radius; y += step) {
                for (int z = cz - radius; z < cz + radius; z += step) {
                    if (shape == RegionShape.SPHERE) {
                        int dx = x - cx, dy = y - cy, dz = z - cz;
                        if (dx * dx + dy * dy + dz * dz > r2) continue;
                    }
                    Block block = world.getBlockAt(x, y, z);
                    if (condition.test(block)) result.add(block);
                }
            }
        }
        return result;
    }
 
    public static List<Block> returnAllBlocksInRadius(final Location location, final int radius, final int step,
                                                      final RegionShape shape, final Material... materials) {
        List<Block> result = new ArrayList<>();
        final World world = location.getWorld();
        if (world == null || step <= 0) return result;
 
        final int cx = location.getBlockX();
        final int cy = location.getBlockY();
        final int cz = location.getBlockZ();
 
        final int r2 = radius * radius;
        final boolean filterByMaterial = materials != null && materials.length > 0;
        final Set<Material> materialSet = filterByMaterial ? new HashSet<>(Arrays.asList(materials)) : null;
 
        for (int x = cx - radius; x < cx + radius; x += step) {
            for (int y = cy - radius; y < cy + radius; y += step) {
                for (int z = cz - radius; z < cz + radius; z += step) {
                    if (shape == RegionShape.SPHERE) {
                        int dx = x - cx, dy = y - cy, dz = z - cz;
                        if (dx * dx + dy * dy + dz * dz > r2) continue;
                    }
                    Block block = world.getBlockAt(x, y, z);
                    if (!filterByMaterial || materialSet.contains(block.getType())) result.add(block);
                }
            }
        }
        return result;
    }
 
    public static int replaceBlocksInRadius(final Location location, final int radius, final int step,
                                            final RegionShape shape, final Material[] targetMaterials,
                                            final Material replacementMaterial) {
        final World world = location.getWorld();
        if (world == null || step <= 0) return 0;
 
        int replaced = 0;
        final int cx = location.getBlockX();
        final int cy = location.getBlockY();
        final int cz = location.getBlockZ();
 
        final int r2 = radius * radius;
        final Set<Material> targets = new HashSet<>(Arrays.asList(targetMaterials));
 
        for (int x = cx - radius; x < cx + radius; x += step) {
            for (int y = cy - radius; y < cy + radius; y += step) {
                for (int z = cz - radius; z < cz + radius; z += step) {
                    if (shape == RegionShape.SPHERE) {
                        int dx = x - cx, dy = y - cy, dz = z - cz;
                        if (dx * dx + dy * dy + dz * dz > r2) continue;
                    }
                    Block block = world.getBlockAt(x, y, z);
                    if (targets.contains(block.getType())) {
                        block.setType(replacementMaterial, false);
                        replaced++;
                    }
                }
            }
        }
        return replaced;
    }
 
    public static int countBlocksInRadius(final Location location, final int radius, final int step,
                                          final RegionShape shape, final Material... materials) {
        final World world = location.getWorld();
        if (world == null || step <= 0) return 0;
 
        int count = 0;
        final int cx = location.getBlockX();
        final int cy = location.getBlockY();
        final int cz = location.getBlockZ();
 
        final int r2 = radius * radius;
        final boolean filterByMaterial = materials != null && materials.length > 0;
        final Set<Material> materialSet = filterByMaterial ? new HashSet<>(Arrays.asList(materials)) : null;
 
        for (int x = cx - radius; x < cx + radius; x += step) {
            for (int y = cy - radius; y < cy + radius; y += step) {
                for (int z = cz - radius; z < cz + radius; z += step) {
                    if (shape == RegionShape.SPHERE) {
                        int dx = x - cx, dy = y - cy, dz = z - cz;
                        if (dx * dx + dy * dy + dz * dz > r2) continue;
                    }
                    Block block = world.getBlockAt(x, y, z);
                    if (!filterByMaterial || materialSet.contains(block.getType())) count++;
                }
            }
        }
        return count;
    }
 
    public static Block findClosestBlock(final Location location, final int radius,
                                         final RegionShape shape, final Material material) {
        final World world = location.getWorld();
        if (world == null) return null;
 
        Block closest = null;
        double bestDist = Double.MAX_VALUE;
 
        final int cx = location.getBlockX();
        final int cy = location.getBlockY();
        final int cz = location.getBlockZ();
        final int r2 = radius * radius;
 
        for (int x = cx - radius; x < cx + radius; x++) {
            for (int y = cy - radius; y < cy + radius; y++) {
                for (int z = cz - radius; z < cz + radius; z++) {
                    if (shape == RegionShape.SPHERE) {
                        int dx = x - cx, dy = y - cy, dz = z - cz;
                        if (dx * dx + dy * dy + dz * dz > r2) continue;
                    }
                    Block block = world.getBlockAt(x, y, z);
                    if (block.getType() == material) {
                        double dist = location.distanceSquared(block.getLocation());
                        if (dist < bestDist) {
                            bestDist = dist;
                            closest = block;
                        }
                    }
                }
            }
        }
        return closest;
    }
 
    public static int clearBlocksInRadius(final Location location, final int radius, final int step,
                                          final RegionShape shape, final Material... materials) {
        final World world = location.getWorld();
        if (world == null || step <= 0) return 0;
 
        int cleared = 0;
        final int cx = location.getBlockX();
        final int cy = location.getBlockY();
        final int cz = location.getBlockZ();
 
        final int r2 = radius * radius;
        final boolean filterByMaterial = materials != null && materials.length > 0;
        final Set<Material> materialSet = filterByMaterial ? new HashSet<>(Arrays.asList(materials)) : null;
 
        for (int x = cx - radius; x < cx + radius; x += step) {
            for (int y = cy - radius; y < cy + radius; y += step) {
                for (int z = cz - radius; z < cz + radius; z += step) {
                    if (shape == RegionShape.SPHERE) {
                        int dx = x - cx, dy = y - cy, dz = z - cz;
                        if (dx * dx + dy * dy + dz * dz > r2) continue;
                    }
                    Block block = world.getBlockAt(x, y, z);
                    if (!filterByMaterial || materialSet.contains(block.getType())) {
                        block.setType(Material.AIR, false);
                        cleared++;
                    }
                }
            }
        }
        return cleared;
    }
 
    // ============================================================
    // Asynchronous Wrappers (Read-only)
    // ============================================================
 
    public static CompletableFuture<List<Block>> filterBlocksInRadiusAsync(final Location location, final int radius,
                                                                           final int step, final RegionShape shape,
                                                                           final Predicate<Block> condition) {
        return CompletableFuture.supplyAsync(() -> filterBlocksInRadius(location, radius, step, shape, condition));
    }
 
    public static CompletableFuture<List<Block>> returnAllBlocksInRadiusAsync(final Location location, final int radius,
                                                                              final int step, final RegionShape shape,
                                                                              final Material... materials) {
        return CompletableFuture.supplyAsync(() -> returnAllBlocksInRadius(location, radius, step, shape, materials));
    }
 
    public static CompletableFuture<Integer> countBlocksInRadiusAsync(final Location location, final int radius,
                                                                      final int step, final RegionShape shape,
                                                                      final Material... materials) {
        return CompletableFuture.supplyAsync(() -> countBlocksInRadius(location, radius, step, shape, materials));
    }
 
    public static CompletableFuture<Block> findClosestBlockAsync(final Location location, final int radius,
                                                                 final RegionShape shape, final Material material) {
        return CompletableFuture.supplyAsync(() -> findClosestBlock(location, radius, shape, material));
    }
}