DreamBlockMask.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.DreamBlockMask;
 
import com.dreamfirestudios.dreamcore.DreamCore;
import lombok.Getter;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.block.BlockState;
import org.bukkit.entity.Player;
import org.bukkit.util.Vector;
 
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
 
public class DreamBlockMask {
 
    private Player player;
 
    @Getter private boolean deleteMaskOnNull;
    @Getter private boolean ignoreAir;
    @Getter private boolean resetLastFrames;
    @Getter private boolean keepTrailTheSame;
    @Getter private double minDistance;
    @Getter private double maxX;
    @Getter private double maxY;
    @Getter private double maxZ;
 
    @Getter private Map<Material, Material> blockExceptions;
 
    private Map<Vector, BlockState> lastFrameBlockStates = new HashMap<>();
    private final Map<Vector, BlockState> visitedTrailLocations = new HashMap<>();
 
    @Getter
    private volatile boolean actionBarPaused = true;
 
    private DreamBlockMask() { }
 
    // ----------------------------- Mutation helpers -----------------------------
 
    public void addToExceptions(Map<Material, Material> blockExceptions){
        if (blockExceptions == null) throw new IllegalArgumentException("Block exceptions cannot be null.");
        this.blockExceptions = mergeExceptions(this.blockExceptions, blockExceptions);
    }
 
    // ----------------------------- Frame cycle -----------------------------
 
    public boolean displayNextFrame(){
        if (player == null || !player.isOnline() || actionBarPaused) return true;
 
        final Location playerLoc = player.getLocation();
        final double px = playerLoc.getX();
        final double py = playerLoc.getY();
        final double pz = playerLoc.getZ();
 
        final Map<Vector, BlockState> previousFrameStates = new HashMap<>();
        final Map<Vector, BlockState> newFrameStates = new HashMap<>();
 
        // NOTE: Iterate using doubles to preserve exact behavior of your original logic.
        for (double x = px - maxX; x < px + maxX; x++){
            for (double y = py - maxY; y < py + maxY; y++){
                for (double z = pz - maxZ; z < pz + maxZ; z++){
 
                    final Location loc = new Location(player.getWorld(), x, y, z);
                    if (loc.distance(playerLoc) < minDistance) continue;
 
                    final var block = loc.getBlock();
                    if (block == null) continue; // defensive
                    if (block.getType() == Material.AIR && ignoreAir) continue;
 
                    final Material viewMat = blockExceptions.getOrDefault(block.getType(), Material.BARRIER);
                    if (viewMat == null) continue;
 
                    final Vector key = block.getLocation().toVector();
                    previousFrameStates.put(key, block.getState());
 
                    final BlockState newState = block.getState();
                    newState.setType(viewMat);
                    newFrameStates.put(key, newState);
 
                    if (keepTrailTheSame && !visitedTrailLocations.containsKey(key)) {
                        visitedTrailLocations.put(key, newState);
                    }
                }
            }
        }
 
        // Restore areas from last frame that are no longer present (unless retained in the trail map).
        if (resetLastFrames) {
            for (Map.Entry<Vector, BlockState> e : lastFrameBlockStates.entrySet()) {
                if (!newFrameStates.containsKey(e.getKey()) && !visitedTrailLocations.containsKey(e.getKey())) {
                    newFrameStates.put(e.getKey(), e.getValue());
                }
            }
        }
 
        // Pre-apply event hook
        new BlockMaskFrameComputedEvent(player, this,
                Collections.unmodifiableMap(newFrameStates),
                Collections.unmodifiableMap(previousFrameStates));
 
        // Apply and swap
        player.sendBlockChanges(newFrameStates.values());
        lastFrameBlockStates = previousFrameStates;
 
        // Post-apply event hook
        new BlockMaskFrameAppliedEvent(player, this,
                Collections.unmodifiableMap(newFrameStates));
 
        return false;
    }
 
    public void pause() {
        if (!actionBarPaused) {
            actionBarPaused = true;
            // restore what the player currently sees for last frame and persistent trail
            player.sendBlockChanges(lastFrameBlockStates.values());
            player.sendBlockChanges(visitedTrailLocations.values());
            new BlockMaskPausedEvent(player, this);
        }
    }
 
    public void play() {
        if (actionBarPaused) {
            actionBarPaused = false;
            new BlockMaskStartedEvent(player, this);
        }
    }
 
    public DreamBlockMask stop(){
        actionBarPaused = true;
        player.sendBlockChanges(lastFrameBlockStates.values());
        player.sendBlockChanges(visitedTrailLocations.values());
        new BlockMaskStoppedEvent(player, this);
        return DreamCore.DreamBlockMasks.remove(player.getUniqueId());
    }
 
    // ----------------------------- Utilities -----------------------------
 
    public Map<Vector, BlockState> getVisitedTrailLocationsView() {
        return Collections.unmodifiableMap(visitedTrailLocations);
    }
 
    private static Map<Material, Material> mergeExceptions(Map<Material, Material> base, Map<Material, Material> add) {
        Map<Material, Material> out = new HashMap<>(base);
        out.putAll(add);
        return Collections.unmodifiableMap(out);
    }
 
    // ----------------------------- Builder -----------------------------
 
    public static class Builder {
 
        private final Map<Material, Material> blockExceptions = new HashMap<>();
        private boolean deleteMaskOnNull = false;
        private boolean ignoreAir = true;
        private boolean resetLastFrames = true;
        private boolean keepTrailTheSame = false;
        private double minDistance = 0.0d;
        private double maxX = 5.0d;
        private double maxY = 5.0d;
        private double maxZ = 5.0d;
 
        public Builder blockExceptions(Map<Material, Material> blockExceptions){
            if (blockExceptions == null) throw new IllegalArgumentException("Block exceptions cannot be null.");
            this.blockExceptions.putAll(blockExceptions);
            return this;
        }
 
        public Builder blockExceptions(Material target, Material view){
            if (target == null || view == null) throw new IllegalArgumentException("Block type cannot be null.");
            this.blockExceptions.put(target, view);
            return this;
        }
 
        public Builder deleteMaskOnNull(boolean deleteMaskOnNull){
            this.deleteMaskOnNull = deleteMaskOnNull;
            return this;
        }
 
        public Builder ignoreAir(boolean ignoreAir){
            this.ignoreAir = ignoreAir;
            return this;
        }
 
        public Builder resetLastFrames(boolean resetLastFrames){
            this.resetLastFrames = resetLastFrames;
            return this;
        }
 
        public Builder keepTrailTheSame(boolean keepTrailTheSame){
            this.keepTrailTheSame = keepTrailTheSame;
            return this;
        }
 
        public Builder minDistance(double minDistance){
            if (minDistance < 0) throw new IllegalArgumentException("minDistance cannot be negative.");
            this.minDistance = minDistance;
            return this;
        }
 
        public Builder maxX(double maxX){
            if (maxX < 0) throw new IllegalArgumentException("Max X cannot be negative.");
            this.maxX = maxX;
            return this;
        }
 
        public Builder maxY(double maxY){
            if (maxY < 0) throw new IllegalArgumentException("Max Y cannot be negative.");
            this.maxY = maxY;
            return this;
        }
 
        public Builder maxZ(double maxZ){
            if (maxZ < 0) throw new IllegalArgumentException("Max Z cannot be negative.");
            this.maxZ = maxZ;
            return this;
        }
 
        public DreamBlockMask CreateMask(Player player){
            if (player == null) throw new IllegalArgumentException("Player cannot be null.");
            var stored = DreamCore.DreamBlockMasks.getOrDefault(player.getUniqueId(), null);
            if (stored != null){
                stored.addToExceptions(this.blockExceptions);
                return stored;
            }
 
            DreamBlockMask mask = new DreamBlockMask();
            mask.player = player;
            mask.deleteMaskOnNull = deleteMaskOnNull;
            mask.resetLastFrames = resetLastFrames;
            mask.keepTrailTheSame = keepTrailTheSame;
            mask.minDistance = minDistance;
            mask.maxX = maxX;
            mask.maxY = maxY;
            mask.maxZ = maxZ;
            mask.ignoreAir = ignoreAir;
            mask.blockExceptions = Collections.unmodifiableMap(new HashMap<>(this.blockExceptions));
 
            new BlockMaskCreatedEvent(mask, player);
            // NOTE: As written, this returns the previous value (if any) — not the newly created mask.
            // Left unchanged to avoid behavior changes without your approval.
            return DreamCore.DreamBlockMasks.put(player.getUniqueId(), mask);
        }
    }
}