DreamLocationLimiter.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.DreamLocationLimiter;
 
import com.dreamfirestudios.dreamcore.DreamCore;
import com.dreamfirestudios.dreamcore.DreamJava.DreamClassID;
import lombok.Getter;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.entity.Player;
import org.bukkit.util.Vector;
 
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.UUID;
 
public class DreamLocationLimiter extends DreamClassID {
 
    private final List<Player> players = new ArrayList<>();
 
    @Getter private LocationLimiterType locationLimiterType = LocationLimiterType.SNAP_TO_ORIGIN;
    @Getter private LocationLimiterStart locationLimiterStart = LocationLimiterStart.ORIGIN_POINT;
    @Getter private String edgeMessage = "You have reached the edge of the location!";
    @Getter private Location originPoint;
    @Getter private int distanceExtents = 10;
    @Getter private boolean stopped = false;
 
    private World originWorld;
 
    public void AddPlayer(Player player) {
        if (player == null) return;
        if (players.contains(player)) return;
 
        LocationLimiterPlayerAddedEvent evt = new LocationLimiterPlayerAddedEvent(this, player);
        if (evt.isCancelled()) return;
 
        if (!canPlayerBeLimited(player)) return;
 
        players.add(player);
    }
 
    public void RemovePlayer(Player player) {
        if (player == null) return;
        if (!players.remove(player)) return;
        new LocationLimiterPlayerRemovedEvent(this, player);
    }
 
    public void startLocationLimiter() {
        if (originPoint == null || originPoint.getWorld() == null) {
            throw new IllegalStateException("Origin point/world must be set before starting the limiter.");
        }
        originWorld = originPoint.getWorld();
 
        if (locationLimiterStart == LocationLimiterStart.ORIGIN_POINT) {
            for (Player player : players) {
                safeTeleport(player, originPoint);
            }
        }
    }
 
    public void tickLocationLimiter() {
        if (stopped) return;
        if (originPoint == null || originWorld == null) return;
 
        for (Player player : new ArrayList<>(players)) {
            if (player == null || !player.isOnline()) continue;
 
            if (!Objects.equals(player.getWorld(), originWorld)) {
                safeTeleport(player, originPoint);
                continue;
            }
 
            final double distance = player.getLocation().distance(originPoint);
            if (distance >= distanceExtents) {
                handleOutOfBoundsPlayer(player, distance);
            }
        }
    }
 
    private void handleOutOfBoundsPlayer(Player player, double distance) {
        if (edgeMessage != null && !edgeMessage.isEmpty()) {
            player.sendMessage(edgeMessage);
        }
 
        switch (locationLimiterType) {
            case SNAP_TO_ORIGIN:
                safeTeleport(player, originPoint);
                new LocationLimiterLimitHit(this, player);
                break;
            case PUSH_BACK:
                pushPlayerBack(player);
                new LocationLimiterLimitHit(this, player);
                break;
        }
    }
 
    private void pushPlayerBack(Player player) {
        Vector toOrigin = originPoint.toVector().subtract(player.getLocation().toVector()).normalize();
        player.setVelocity(toOrigin.multiply(0.5));
    }
 
    public void toggleLocationLimiter(boolean state) {
        this.stopped = !state;
    }
 
    public void stopLocationLimiter() {
        this.stopped = true;
        DreamCore.DreamLocationLimiters.remove(getClassID());
    }
 
    public void setEdgeMessage(String message) {
        this.edgeMessage = message == null ? "" : message;
    }
 
    public void setDistanceExtents(int extents) {
        if (extents <= 0) throw new IllegalArgumentException("Distance extents must be > 0");
        this.distanceExtents = extents;
    }
 
    public void setLocationLimiterType(LocationLimiterType type) {
        this.locationLimiterType = Objects.requireNonNull(type, "type");
    }
 
    public void setOriginPoint(Location origin) {
        if (origin == null || origin.getWorld() == null)
            throw new IllegalArgumentException("Origin point/world cannot be null.");
        this.originPoint = origin;
        this.originWorld = origin.getWorld();
    }
 
    @SuppressWarnings("unchecked")
    private boolean canPlayerBeLimited(Player player) {
        try {
            Class<?> actionEnum = Class.forName("com.dreamfirestudios.dreamcore.DreamfirePlayerAction");
            Class<?> apiClass   = Class.forName("com.dreamfirestudios.dreamcore.DreamfirePlayerActionAPI");
 
            Object actionValue = Enum.valueOf((Class<Enum>) actionEnum, "PlayerLocationLimiter");
            Method m = apiClass.getMethod("CanPlayerAction", actionEnum, UUID.class);
            Object result = m.invoke(null, actionValue, player.getUniqueId());
            return result instanceof Boolean && (Boolean) result;
        } catch (Throwable ignored) {
            return true; // default allow
        }
    }
 
    private void safeTeleport(Player player, Location target) {
        if (player == null || target == null || target.getWorld() == null) return;
        player.teleport(target);
    }
 
    // ---------------------------------------------------------------------
    // Builder
    // ---------------------------------------------------------------------
 
    public static class LocationLimiterBuilder {
        private final List<Player> players = new ArrayList<>();
        private LocationLimiterType type = LocationLimiterType.SNAP_TO_ORIGIN;
        private LocationLimiterStart start = LocationLimiterStart.ORIGIN_POINT;
        private String edgeMessage = "You have reached the edge of the location!";
        private int extents = 10;
 
        public LocationLimiterBuilder addPlayer(Player player) {
            if (player != null) this.players.add(player);
            return this;
        }
 
        public LocationLimiterBuilder type(LocationLimiterType type) {
            this.type = Objects.requireNonNull(type, "type");
            return this;
        }
 
        public LocationLimiterBuilder start(LocationLimiterStart start) {
            this.start = Objects.requireNonNull(start, "start");
            return this;
        }
 
        public LocationLimiterBuilder edgeMessage(String message) {
            if (message != null && !message.isBlank()) this.edgeMessage = message;
            return this;
        }
 
        public LocationLimiterBuilder extents(int distance) {
            if (distance <= 0) throw new IllegalArgumentException("Distance extents must be > 0");
            this.extents = distance;
            return this;
        }
 
        public DreamLocationLimiter build(Location originPoint) {
            if (originPoint == null || originPoint.getWorld() == null)
                throw new IllegalArgumentException("Origin point/world cannot be null.");
            DreamLocationLimiter limiter = new DreamLocationLimiter();
            limiter.locationLimiterType = this.type;
            limiter.locationLimiterStart = this.start;
            limiter.edgeMessage = this.edgeMessage;
            limiter.distanceExtents = this.extents;
            limiter.originPoint = originPoint;
            limiter.originWorld = originPoint.getWorld();
            for (Player p : players) limiter.AddPlayer(p);
            return DreamCore.DreamLocationLimiters.put(limiter.getClassID(), limiter);
        }
    }
}