DreamEntityMask.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.DreamEntityMask;
 
import com.dreamfirestudios.dreamcore.DreamCore;
import com.dreamfirestudios.dreamcore.DreamVanish.DreamVanish;
import lombok.Getter;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
 
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
 
 
public class DreamEntityMask {
 
    @Getter private Player player;
 
    private boolean deleteMaskOnNull;
 
    @Getter private double minDistance;
 
    @Getter private double maxDistance;
 
    private EntityMaskType entityMaskType;
 
    private final List<EntityType> entityTypeExceptions = new ArrayList<>();
 
    private final List<UUID> uuidExceptions = new ArrayList<>();
 
    private List<Entity> lastFrameEntities = new ArrayList<>();
 
    @Getter private boolean actionBarPaused = true;
 
    // ---------------- Exceptions ----------------
 
 
    public void addToExceptions(EntityType entityType){
        if (!entityTypeExceptions.contains(entityType)) {
            entityTypeExceptions.add(entityType);
        }
    }
 
 
    public void addToExceptions(UUID entityUUID){
        if (!uuidExceptions.contains(entityUUID)) {
            uuidExceptions.add(entityUUID);
        }
    }
 
    // ---------------- Frame update ----------------
 
 
    public void displayNextFrame(){
        if (player == null || !player.isOnline() || actionBarPaused) return;
 
        var newEntityStates = new ArrayList<Entity>();
 
        var playerWorld = player.getWorld();
        for (var entity : playerWorld.getEntities()){
            if (entityTypeExceptions.contains(entity.getType())) continue;
            if (uuidExceptions.contains(entity.getUniqueId())) continue;
            if (!isCorrectForMaskType(entity)) continue;
 
            double distance = player.getLocation().distance(entity.getLocation());
            if (distance < minDistance || distance > maxDistance) continue;
 
            newEntityStates.add(entity);
        }
 
        // Reveal old entities, hide new ones
        for (var entity : lastFrameEntities) DreamVanish.showTargetToViewer(entity, player);
        for (var entity : newEntityStates) DreamVanish.hideTargetFromViewer(entity, player);
 
        lastFrameEntities = newEntityStates;
    }
 
 
    private boolean isCorrectForMaskType(Entity entity){
        return switch (entityMaskType) {
            case Entity -> true;
            case LivingEntity -> entity instanceof LivingEntity;
            case Player -> entity instanceof Player;
        };
    }
 
    // ---------------- Lifecycle ----------------
 
 
    public void pause() {
        if (!actionBarPaused){
            actionBarPaused = true;
            new EntityMaskPausedEvent(this);
            for (var entity : lastFrameEntities) DreamVanish.showTargetToViewer(entity, player);
        }
    }
 
 
    public void play() {
        if (actionBarPaused){
            actionBarPaused = false;
            new EntityMaskStartedEvent(this);
        }
    }
 
 
    public DreamEntityMask stop(){
        actionBarPaused = true;
        new EntityMaskStoppedEvent(this);
        for (var entity : lastFrameEntities) DreamVanish.showTargetToViewer(entity, player);
 
        return DreamCore.DreamEntityMasks.remove(player.getUniqueId());
    }
 
    // ---------------- Builder ----------------
 
 
    public static class Builder {
        private boolean deleteMaskOnNull = false;
        private double minDistance = 0;
        private double maxDistance = 5;
        private EntityMaskType entityMaskType = EntityMaskType.Player;
        private final List<UUID> uuidExceptions = new ArrayList<>();
        private final List<EntityType> entityTypeExceptions = new ArrayList<>();
 
 
        public Builder entityTypeExceptions(List<EntityType> exceptions){
            for (var type : exceptions) {
                if (!entityTypeExceptions.contains(type)) entityTypeExceptions.add(type);
            }
            return this;
        }
 
 
        public Builder uuidExceptions(List<UUID> exceptions){
            for (var id : exceptions) {
                if (!uuidExceptions.contains(id)) uuidExceptions.add(id);
            }
            return this;
        }
 
        public Builder deleteMaskOnNull(boolean deleteMaskOnNull){
            this.deleteMaskOnNull = deleteMaskOnNull;
            return this;
        }
 
        public Builder minDistance(double minDistance){
            this.minDistance = minDistance;
            return this;
        }
 
        public Builder maxDistance(double maxDistance){
            this.maxDistance = maxDistance;
            return this;
        }
 
        public Builder entityMaskType(EntityMaskType entityMaskType){
            this.entityMaskType = entityMaskType;
            return this;
        }
 
 
        public DreamEntityMask CreateMask(Player player){
            if (player == null) throw new IllegalArgumentException("Player cannot be null");
 
            var storedMask = DreamCore.DreamEntityMasks.getOrDefault(player.getUniqueId(), null);
            if (storedMask != null){
                entityTypeExceptions.forEach(storedMask::addToExceptions);
                uuidExceptions.forEach(storedMask::addToExceptions);
                return storedMask;
            }
 
            var createdMask = new DreamEntityMask();
            createdMask.player = player;
            createdMask.deleteMaskOnNull = deleteMaskOnNull;
            createdMask.minDistance = minDistance;
            createdMask.maxDistance = maxDistance;
            createdMask.entityMaskType = entityMaskType;
 
            entityTypeExceptions.forEach(createdMask::addToExceptions);
            uuidExceptions.forEach(createdMask::addToExceptions);
 
            new EntityMaskCreateEvent(createdMask, player);
            return DreamCore.DreamEntityMasks.put(player.getUniqueId(), createdMask);
        }
    }
}